Como devo organizar minhas funções com Pyparsing?

Question

Estou analisando um arquivo com python e Pyparsing (é o arquivo de relatório para Psat no Matlab, mas isso não é importante). aqui é o que eu tenho até agora. Eu acho que é uma bagunça e gostaria de alguns conselhos sobre como melhorá -la. Especificamente, como devo organizar minhas definições gramaticais com Pyparsing?

Devo ter todas as minhas definições gramaticais em uma função? Nesse caso, será uma função enorme. Caso contrário, como faço para terminar. No momento, dividi -o nas seções do arquivo. Vale a pena fazer muitas funções que apenas são chamadas uma vez de um lugar. Nem realmente parece certo para mim.

Devo colocar todo o meu código de entrada e saída em um arquivo separado para as outras funções de classe? Isso tornaria o objetivo da classe muito mais claro.

Também estou interessado em saber se existe uma maneira mais fácil de analisar um arquivo, fazer algumas verificações de sanidade e armazenar os dados em uma classe. Parece que gasto muito do meu tempo fazendo isso.

(Vou aceitar respostas de É bom o suficiente ou Use X em vez de Pyparsing Se as pessoas concordarem)

Answer 1

Eu poderia ir de qualquer maneira usando um único big método para criar seu analisador versus tomá -lo nas etapas da maneira que você o possui agora.

Eu posso ver que você definiu alguns utilitários auxiliares úteis, como Slit ("suprimir literal", presumo), stringtolits e decimaltáveis. Isso parece bom para mim.

Eu gosto que você esteja usando nomes de resultados, eles realmente melhoram a robustez do seu código de pós-pós-picante. Eu recomendaria usar o formulário de atalho que foi adicionado no Pyparsing 1.4.7, no qual você pode substituir

busname.setResultsName("bus1")

com

busname("bus1")

Isso pode organizar seu código bastante.

Eu olhava para trás através de suas ações de análise para ver onde você está usando índices numéricos para acessar tokens individuais e voltar e atribuir nomes de resultados. Aqui está um caso, onde o getstats retorna (ngroup + sgroup).setParseAction(self.process_stats). process_stats tem referências como:

self.num_load = tokens[0]["loads"]
self.num_generator = tokens[0]["generators"]
self.num_transformer = tokens[0]["transformers"]
self.num_line = tokens[0]["lines"]
self.num_bus = tokens[0]["buses"]
self.power_rate = tokens[1]["rate"]

Eu gosto que você tenha agrupado os valores e as estatísticas, mas vá em frente e dê a eles nomes, como "Rede" e "Soln". Então você pode escrever este código de ação Parse como (eu também converti para o-para mim-mais fácil de ler a notação de atributo de objeto em vez da notação do elemento dicto):

self.num_load = tokens.network.loads
self.num_generator = tokens.network.generators
self.num_transformer = tokens.network.transformers
self.num_line = tokens.network.lines
self.num_bus = tokens.network.buses
self.power_rate = tokens.soln.rate

Além disso, uma pergunta de estilo: por que você às vezes usa o explícito e o construtor, em vez de usar o operador '+'?

busdef = And([busname.setResultsName("bus1"),
            busname.setResultsName("bus2"),
            integer.setResultsName("linenum"),
            decimaltable("pf qf pl ql".split())])

Isso é tão facilmente escrito:

busdef = (busname("bus1") + busname("bus2") + 
            integer("linenum") + 
            decimaltable("pf qf pl ql".split()))

No geral, acho que isso é par para um arquivo dessa complexidade. Eu tenho um formato semelhante (proprietário, infelizmente, não posso ser compartilhado) no qual eu construí o código em peças semelhantes à maneira como você tem, mas em um grande método, algo assim:

def parser():
    header = Group(...)
    inputsummary = Group(...)
    jobstats = Group(...)
    measurements = Group(...)
    return header("hdr") + inputsummary("inputs") + jobstats("stats") + measurements("meas")

As construções do grupo são especialmente úteis em um grande analisador como esse, para estabelecer uma espécie de espaço para nome para nomes de resultados em cada seção dos dados analisados.