WIP

Author: jverzani

ext/SymPyPythonCallSymbolicsExt.jl

@@ -3,69 +3,83 @@ module SymPyPythonCallSymbolicsExt
 # from https://github.com/JuliaSymbolics/Symbolics.jl/pull/957/
 # by @jClugstor
 import SymPyPythonCall
-const sp = SymPyPythonCall.sympy.py
+#const sp = SymPyPythonCall.sympy.py
 const PythonCall = SymPyPythonCall.PythonCall
-import PythonCall: Py, pyisinstance, pyconvert
+import PythonCall: pyconvert
 
 import Symbolics
 import Symbolics: @variables
 
 # rule functions
-function pyconvert_rule_sympy_symbol(::Type{Symbolics.Num}, x::Py)
+function pyconvert_rule_sympy_symbol(::Type{Symbolics.Num}, x)
+    #=
     if !pyisinstance(x,sp.Symbol)
         return PythonCall.pyconvert_unconverted()
     end
+    =#
     name = PythonCall.pyconvert(Symbol,x.name)
     return PythonCall.pyconvert_return(Symbolics.variable(name))
 end
 
-function pyconvert_rule_sympy_pow(::Type{Symbolics.Num}, x::Py)
+function pyconvert_rule_sympy_pow(::Type{Symbolics.Num}, x)
+    #=
     if !pyisinstance(x,sp.Pow)
         return PythonCall.pyconvert_unconverted()
     end
+    =#
     expbase = pyconvert(Symbolics.Num,x.base)
     exp = pyconvert(Symbolics.Num,x.exp)
     return PythonCall.pyconvert_return(expbase^exp)
 end
 
-function pyconvert_rule_sympy_mul(::Type{Symbolics.Num}, x::Py)
+function pyconvert_rule_sympy_mul(::Type{Symbolics.Num}, x)
+    #=
     if !pyisinstance(x,sp.Mul)
         return PythonCall.pyconvert_unconverted()
     end
+    =#
     mult = reduce(*,PythonCall.pyconvert.(Symbolics.Num,x.args))
     return PythonCall.pyconvert_return(mult)
 end
 
-function pyconvert_rule_sympy_add(::Type{Symbolics.Num}, x::Py)
+function pyconvert_rule_sympy_add(::Type{Symbolics.Num}, x)
+    #=
     if !pyisinstance(x,sp.Add)
         return PythonCall.pyconvert_unconverted()
     end
+    =#
     sum = reduce(+, PythonCall.pyconvert.(Symbolics.Num,x.args))
     return PythonCall.pyconvert_return(sum)
 end
 
-function pyconvert_rule_sympy_equality(::Type{Symbolics.Equation}, x::Py)
+function pyconvert_rule_sympy_equality(::Type{Symbolics.Equation}, x)
+    #=
     if !pyisinstance(x,sp.Equality)
          return PythonCall.pyconvert_unconverted()
     end
+    =#
     rhs = pyconvert(Symbolics.Num,x.rhs)
     lhs = pyconvert(Symbolics.Num,x.lhs)
     return PythonCall.pyconvert_return(rhs ~ lhs)
 end
-function pyconvert_rule_sympy_derivative(::Type{Symbolics.Num}, x::Py)
+function pyconvert_rule_sympy_derivative(::Type{Symbolics.Num}, x)
+    #=
     if !pyisinstance(x,sp.Derivative)
         return PythonCall.pyconvert_unconverted()
     end
+    =#
     variables = pyconvert.(Symbolics.Num,x.variables)
     derivatives = prod(var -> Differential(var), variables)
     expr = pyconvert(Symbolics.Num, x.expr)
     return PythonCall.pyconvert_return(derivatives(expr))
 end
 
-function pyconvert_rule_sympy_function(::Type{Symbolics.Num}, x::Py)
+function pyconvert_rule_sympy_function(::Type{Symbolics.Num}, x)
+    #=
     if !pyisinstance(x,sp.Function)
         return PythonCall.pyconvert_unconverted()
     end
+    =#
     name = pyconvert(Symbol,x.name)
     args = pyconvert.(Symbolics.Num,x.args)
     func = @variables $name(..)