Support `pyconvert`

[LilithHafner]

I'm trying to convert SymPy expressions to ModelingToolkit.jl expressions, converting SymPy expressions to Julia Exprs would be a great first step.

julia> f = pyeval("sympy.core.sympify", Main)
Python: <function sympify at 0x16c71cd60>

julia> expr = f("a + b ** 3")
Python: a + b**3

julia> pyconvert(Any, expr)
:(a + b ^ 3)     # Wanted
Python: a + b**3 # Actual

[LilithHafner]

If this is something you are interested in, I'd be happy to make a PR. Here's a draft implementeation

using PythonCall
using PythonCall: pyconvert_add_rule, pyconvert_return
_convertargs(x) = (pyconvert(Any, arg) for arg in x.args)
pyconvert_add_rule("sympy.core.add:Add", Expr, (::Type{Expr}, x::Py) -> pyconvert_return(Expr(:call, :+, _convertargs(x)...)))
pyconvert_add_rule("sympy.core.mul:Mul", Expr, (::Type{Expr}, x::Py) -> pyconvert_return(Expr(:call, :*, _convertargs(x)...)))
pyconvert_add_rule("sympy.core.power:Pow", Expr, (::Type{Expr}, x::Py) -> pyconvert_return(Expr(:call, :^, _convertargs(x)...)))
pyconvert_add_rule("sympy.core.symbol:Symbol", Symbol, (::Type{Symbol}, x::Py) -> pyconvert_return(Symbol(x)))

pyconvert_add_rule("sympy.core.numbers:ImaginaryUnit", Complex{Bool}, (::Type{Complex{Bool}}, ::Py) -> pyconvert_return(im))
pyconvert_add_rule("sympy.core.numbers:Catalan", Irrational{:catalan}, (::Type{Irrational{:catalan}}, ::Py) -> pyconvert_return(MathConstants.catalan))
pyconvert_add_rule("sympy.core.numbers:EulerGamma", Irrational{:γ}, (::Type{Irrational{:γ}}, ::Py) -> pyconvert_return(MathConstants.γ))
pyconvert_add_rule("sympy.core.numbers:Pi", Irrational{:π}, (::Type{Irrational{:π}}, ::Py) -> pyconvert_return(π))
pyconvert_add_rule("sympy.core.numbers:GoldenRatio", Irrational{:φ}, (::Type{Irrational{:φ}}, ::Py) -> pyconvert_return(MathConstants.φ))
pyconvert_add_rule("sympy.core.numbers:Exp1", Irrational{:ℯ}, (::Type{Irrational{:ℯ}}, ::Py) -> pyconvert_return(ℯ))

pyconvert_add_rule("sympy.core.relational:Equality", Expr, (::Type{Expr}, x::Py) -> pyconvert_return(Expr(:call, :(==), _convertargs(x)...)))
pyconvert_add_rule("sympy.core.relational:Unequality", Expr, (::Type{Expr}, x::Py) -> pyconvert_return(Expr(:call, :(!=), _convertargs(x)...)))
pyconvert_add_rule("sympy.core.relational:GreaterThan", Expr, (::Type{Expr}, x::Py) -> pyconvert_return(Expr(:call, :>=, _convertargs(x)...)))
pyconvert_add_rule("sympy.core.relational:LessThan", Expr, (::Type{Expr}, x::Py) -> pyconvert_return(Expr(:call, :<=, _convertargs(x)...)))
pyconvert_add_rule("sympy.core.relational:StrictGreaterThan", Expr, (::Type{Expr}, x::Py) -> pyconvert_return(Expr(:call, :>, _convertargs(x)...)))
pyconvert_add_rule("sympy.core.relational:StrictLessThan", Expr, (::Type{Expr}, x::Py) -> pyconvert_return(Expr(:call, :<, _convertargs(x)...)))

[jverzani]

Thanks. I think you have much of what you want already handled via convert:

julia> convert(Expr, a+b^3)
:(a + b ^ 3)

That relies on an internal walk_expression function, which may benefit from your rules. If you think so, please make a PR to fix that, as it will make lambdify more useful.

You might also bypass the intermediate conversion using SymbolicUtils to walk the expression tree using operation, arguments, and istree though you may need to define conversions from non trees to Symbolic objects (symbols -> symbols, numbers -> numbers).

[LilithHafner]

Lovely, I'm glad not to reinvent the wheel here. However, I'm confused about how to use convert here. In the example in the OP, I have an object expr of type PythonCall.Py with pytype <class 'sympy.core.add.Add'> and I want to turn it into an Expr. convert isn't doing it for me.

julia> convert(Expr, expr)
ERROR: MethodError: Cannot `convert` an object of type Py to an object of type Expr

Do you have any functionality in this package that supports converting this type of Py object into any type of native Julia object (Expr, Symbolics.jl expression, ModelingToolkit.jl equation, etc.)?

[jverzani]

Sorry, missed that. Maybe convert(Expr, Sym(expr)) will work with the dispatch mechanisms in place.

[LilithHafner]

Lovely! That is exactly what I'm looking for and solves my use case.

It's unfortunate that there are so many different ways to convert things, which makes discoverability harder.

• convert
• pyconvert
• Sym

Do you think pyconvert(Sym, expr) should fall back to Sym(expr) and pyconvert(Expr, expr) should fall back to convert(Expr, Sym(expr))? (with expr as defined in the OP)

[jverzani]

Sorry, never finished this conversation up. There is some work on this in the Symbolics extension for pyconvert(Symbolics.Num, SymPyPythonCall.Sym)

So, currently, by my accounting

• convert(Expr, x::Sym) for Sym -> Expr (I can't really define pyconvert(Expr, expr) in this package)
• pyconvert(Num, x::Sym) for Sym -> Num
• sympify(string(ex::Expr)) for Expr -> Sym (maybe this could be convert(::Type{Sym}, ex::Expr), but I'm not sure how robust this is.
• ↑(ex) for Py object -> Sym

I guess this should be documented somewhere.

[LilithHafner]

If you claim ownership over the sympy python package (which seems reasonable) then you can define pyconvert(Expr, sympy_object) via PythonCall's extensibility mechanisms.