Como montar árvores de sintaxe abstrata Python (AST) no Mathematica?

Não tenho certeza do que exatamente você está procurando. Acho que a resposta para sua pergunta:

Estou tentando gerar código Python programaticamente no MMA […] e, em seguida, envie-o para Python para avaliação. Eu poderia montar strings de código Python, mas depois tenho que lidar com todo o recuo, o que parece uma dor.

É possível criar esse tipo de objeto Python no lado do Mathematica?

é bastante simples usando ExternalEvaluate e Python “s ” ast ” biblioteca.

Aqui está um exemplo:

code = ""[i**2 for i in range(10)]""; astTemplate = StringTemplate["import ast; eval(compile(ast.parse(`1`, mode="eval"), "", "eval"))"]; astTemplate[code] (* "import ast; eval(compile(ast.parse("[i**2 for i in range(10)]", mode="eval"), "", "eval"))" *) ExternalEvaluate["Python", astTemplate[code]] (* {0, 1, 4, 9, 16, 25, 36, 49, 64, 81} *) 

(Eu usei eval em vez de exec, porque eval retorna um valor.)

Comentários

• Obrigado Anton. Sim, eu poderia ter sido mais claro. Deixe-me atualizar um pouco a minha pergunta. Basicamente, quero gerar o ” ‘ [i ** 2 para i no intervalo (10)] ‘ ” participe de sua resposta no lado do MMA, mas não como uma string Python, mas como o objeto ast.Module que pode ser conectado ao compile e eval e exec.

Acho que compilar o código Python como uma string é realmente mais simples do que o que você propõe. Mas também sei que apenas dizendo que não vai convencer ninguém, aqui está um exemplo.

Definimos algumas cabeças simbólicas que representarão nosso programa Python no Mathematica, e uma função para renderizar expressões com essas cabeças simbólicas:

ToPythonString[statements_List] := StringRiffle[ToPythonString /@ statements, "\n"] ToPythonString[PyBlock[statement_, children_, indent_ : 0]] := StringJoin[ StringRepeat[" ", indent], statement, ":\n", ToPythonString[PyIndent /@ children] ] ToPythonString[PyStatement[statement_, indent_ : 0]] := StringJoin[ StringRepeat[" ", indent], statement ] PyIndent[PyBlock[statement_, children_, indent_ : 0]] := PyBlock[ statement, PyIndent /@ children, indent + 1 ] PyIndent[PyStatement[statement_, indent_ : 0]] := PyStatement[ statement, indent + 1 ] 

O que essas funções nos permitem fazer é escrever código Python no Mathematica sem pensar sobre a indentação, é um pouco como construção de código Python com o módulo ast.

Este é um exemplo de renderização da expressão simbólica como uma string:

prog = { PyStatement["a = 1"], PyStatement["b = 2"], PyBlock["If a > b", { PyStatement["Print("a is larger than b")"] }], PyBlock["def f(x)", { PyStatement["Print("executing f")"], PyBlock["if x > 0", { PyStatement["Print("x is larger than 0")"] }] }] }; ToPythonString[prog] 

Out:

a = 1 b = 2 If a > b: Print("a is larger than b") def f(x): Print("executing f") if x > 0: Print("x is larger than 0") 

Podemos facilmente desenvolver isso e tornar nossa representação simbólica do programa Python mais descritiva.

PyAssign[lhs_, rhs_] := PyStatement[lhs <> " = " <> rhs] PyPrint[text_] := PyStatement["Print(" <> text <> ")"] PyFunction[name_, args_, statements_] := PyBlock[ "def " <> name <> "(" <> StringRiffle[args, ", "] <> ")", statements ] PyIf[cond_, statements_] := PyBlock[ "If " <> cond, statements ] PyIf[cond_, statements_, elseStatements_] := { PyBlock[ "If " <> cond, statements ], PyBlock[ "else", elseStatements ] } 

Com essas definições auxiliares, agora podemos escrever o seguinte programa em um estilo muito legível.

prog = { PyAssign["a", "1"], PyAssign["b", "2"], PyIf[ "a > b", { PyPrint["a is larger than b"] }], PyFunction["f", {"x"}, PyIf[ "x > 0", {PyPrint["x is larger than 0"]}, {PyPrint["x is not larger than 0"]} ] ] }; ToPythonString[prog] 

Out:

a = 1 b = 2 If a > b: Print(a is larger than b) def f(x): If x > 0: Print(x is larger than 0) else: Print(x is not larger than 0) 

Se você ainda não fez isso, procure ” C simbólico na documentação do Mathematica. É basicamente uma maneira de construir um AST para um programa de linguagem C no Mathematica que pode então ser convertido em código C executável. Isso é basicamente para onde estamos indo com este código também, embora se eu pretendesse fazer uma implementação completa como essa não seria exatamente assim (o módulo ast certamente vale a pena estudar se alguém quiser seguir o caminho).

De volta ao ponto: o que eu quero transmitir com esta resposta é que você não precisa gastar muito tempo para construir uma pequena estrutura que mais ou menos resolva o problema de recuo que você mencionou em sua pergunta .

Comentários

• Sim CE, isso se parece muito com o que eu estava imaginando que seria uma tortura de implementar, e você está certo, você conseguiu bastante simples. Terei que continuar desta forma estendendo a linguagem para baixo em direção às folhas para cobrir átomos e operadores e listas e tuplas e tal, mas esta estrutura lida com todo o recuo e deve ser factível.
• @berniethejet Neste exemplo, eu defini por exemplo PyIf para algo que é avaliado em outra coisa. Em vez disso, você pode adicionar a definição a ToPythonString, ou seja, ToPythonString[PyIf[...]] :=. Dessa forma, você pode inspecionar todo o seu programa de forma simbólica, sem que seja avaliado até que você chame ToPythonString.
• Obrigado, é bom saber. Sua estrutura é certamente melhor do que qualquer outra que eu teria remendado (resmungando o tempo todo, como seria inevitável, irritado com a cruzada de recuo de Guido ‘).