Merge pull request #1046 from mathics/improve-to-python

WIP Add PythonForm and use sympy numeric constants

Author: rocky

mathics/builtin/__init__.py

@@ -61,7 +61,8 @@ def is_builtin(var):
 
 # builtins = dict(builtins)
 
-mathics_to_sympy = {}
+mathics_to_sympy = {} # here we have: name -> sympy object
+mathics_to_python = {} # here we have: name -> string
 sympy_to_mathics = {}
 
 box_constructs = {}
@@ -72,6 +73,10 @@ def is_builtin(var):
 def add_builtins(new_builtins):
     for var_name, builtin in new_builtins:
         name = builtin.get_name()
+        if hasattr(builtin, "python_equivalent"):
+            # print("XXX", builtin.python_equivalent)
+            mathics_to_python[name] = builtin.python_equivalent
+
         if isinstance(builtin, SympyObject):
             mathics_to_sympy[name] = builtin
             for sympy_name in builtin.get_sympy_names():

mathics/builtin/arithmetic.py

@@ -11,6 +11,7 @@
 
 import sympy
 import mpmath
+import math
 
 from mathics.builtin.base import (
     Builtin,
@@ -1034,6 +1035,7 @@ class Infinity(SympyConstant):
     """
 
     sympy_name = "oo"
+    python_equivalent = math.inf
 
     rules = {
         "Infinity": "DirectedInfinity[1]",
@@ -1338,6 +1340,8 @@ class I(Predefined):
      = 10
     """
 
+    python_equivalent = 1j
+
     def evaluate(self, evaluation):
         return Complex(Integer(0), Integer(1))
 

mathics/builtin/base.py

@@ -51,6 +51,8 @@ def has_option(options, name, evaluation):
     return get_option(options, name, evaluation, evaluate=False) is not None
 
 
+mathics_to_python = {}
+
 class Builtin(object):
     name: typing.Optional[str] = None
     context = "System`"
@@ -75,6 +77,8 @@ def __new__(cls, *args, **kwargs):
 
     def __init__(self, *args, **kwargs):
         super(Builtin, self).__init__()
+        if hasattr(self, "python_equivalent"):
+            mathics_to_python[self.get_name()] = self.python_equivalent
 
     def contribute(self, definitions, is_pymodule=False):
         from mathics.core.parser import parse_builtin_rule

mathics/builtin/exptrig.py

@@ -53,7 +53,6 @@ def apply_N(self, precision, evaluation):
         else:
             return PrecisionReal(sympy.pi.n(d))
 
-
 class E(SympyConstant):
     """
     <dl>

mathics/builtin/inout.py

@@ -20,7 +20,7 @@
 from mathics.builtin.lists import list_boxes
 from mathics.builtin.options import options_to_rules
 from mathics.core.expression import (
-    Expression, String, Symbol, Integer, Real, BoxError,
+    Expression, String, StringFromPython, Symbol, Integer, Real, BoxError,
     from_python, MachineReal, PrecisionReal)
 from mathics.core.numbers import (
     dps, convert_base, machine_precision, reconstruct_digits)
@@ -1938,6 +1938,42 @@ def apply_mathml(self, expr, evaluation) -> Expression:
         return Expression('RowBox', Expression('List', String(mathml)))
 
 
+class PythonForm(Builtin):
+    """
+    <dl>
+      <dt>'PythonForm[$expr$]'
+      <dd>returns an approximate equivalent of $expr$ in Python, when that is possible. We assume
+      that Python has sympy imported. No explicit import will be include in the result.
+    </dl>
+
+    >> PythonForm[Infinity]
+    = math.inf
+    >> PythonForm[Pi]
+    = sympy.pi
+    >> E // PythonForm
+    = sympy.E
+    >> {1, 2, 3} // PythonForm
+    = [1, 2, 3]
+    """
+    # >> PythonForm[HoldForm[Sqrt[a^3]]]
+    #  = sympy.sqrt{a**3} # or something like this
+
+
+    def apply_python(self, expr, evaluation) -> Expression:
+        'MakeBoxes[expr_, PythonForm]'
+
+        try:
+            # from trepan.api import debug; debug()
+            python_equivalent = expr.to_python(python_form = True)
+        except:
+            return
+        return StringFromPython(python_equivalent)
+
+    def apply(self, expr, evaluation) -> Expression:
+        "PythonForm[expr_]"
+        return self.apply_python(expr, evaluation)
+
+
 class TeXForm(Builtin):
     r"""
     <dl>

mathics/core/expression.py

@@ -3,9 +3,11 @@
 # -*- coding: utf-8 -*-
 
 
+import ast
 import sympy
 import mpmath
 import math
+import inspect
 import re
 
 import typing
@@ -135,10 +137,10 @@ def __ge__(self, other) -> bool:
         return self.get_sort_key() >= other.get_sort_key()
 
     def __eq__(self, other) -> bool:
-        return self.get_sort_key() == other.get_sort_key()
+        return hasattr(other, "get_sort_key") and self.get_sort_key() == other.get_sort_key()
 
     def __ne__(self, other) -> bool:
-        return self.get_sort_key() != other.get_sort_key()
+        return (not hasattr(other, "get_sort_key")) or self.get_sort_key() != other.get_sort_key()
 
 
 # ExpressionCache keeps track of the following attributes for one Expression instance:
@@ -937,20 +939,32 @@ def to_python(self, *args, **kwargs):
         numbers    -> Python number
         If kwarg n_evaluation is given, apply N first to the expression.
         """
+        from mathics.builtin.base import mathics_to_python
 
         n_evaluation = kwargs.get('n_evaluation')
         if n_evaluation is not None:
             value = Expression('N', self).evaluate(n_evaluation)
             return value.to_python()
         head_name = self._head.get_name()
-        if head_name == 'System`List':
-            return [leaf.to_python(*args, **kwargs) for leaf in self._leaves]
         if head_name == 'System`DirectedInfinity' and len(self._leaves) == 1:
             direction = self._leaves[0].get_int_value()
             if direction == 1:
-                return float('inf')
+                return math.inf
             if direction == -1:
-                return -float('inf')
+                return -math.inf
+        elif head_name == 'System`List':
+            return [leaf.to_python(*args, **kwargs) for leaf in self._leaves]
+        if head_name in mathics_to_python:
+            py_obj = mathics_to_python[head_name]
+            # Start here
+            # if inspect.isfunction(py_obj) or inspect.isbuiltin(py_obj):
+            #     args = [leaf.to_python(*args, **kwargs) for leaf in self._leaves]
+            #     return ast.Call(
+            #         func=py_obj.__name__,
+            #         args=args,
+            #         keywords=[],
+            #         )
+            return py_obj
         return self
 
     def get_sort_key(self, pattern_sort=False):
@@ -1785,8 +1799,10 @@ def to_python(self, *args, **kwargs):
             value = Expression('N', self).evaluate(n_evaluation)
             return value.to_python()
 
-        # return name as string (Strings are returned with quotes)
-        return self.name
+        if kwargs.get("python_form", False):
+            return self.to_sympy(**kwargs)
+        else:
+            return self.name
 
     def default_format(self, evaluation, form) -> str:
         return self.name
@@ -2614,6 +2630,19 @@ def __getnewargs__(self):
         return (self.value,)
 
 
+class StringFromPython(String):
+    def __new__(cls, value):
+        self = super(StringFromPython, cls).__new__(cls, value)
+        if isinstance(value, sympy.NumberSymbol):
+            self.value = "sympy." + str(value)
+
+        # Note that the test is done with math.inf first.
+        # This is to use float's ==, which may not strictly be necessary.
+        if math.inf == value:
+            self.value = "math.inf"
+        return self
+
+
 def get_default_value(name, evaluation, k=None, n=None):
     pos = []
     if k is not None:

test/test_to_python.py

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+from .helper import session, check_evaluation
+
+import math
+import sympy
+import sys
+from mathics.core.parser import parse, SingleLineFeeder
+from mathics.core.definitions import Definitions
+from mathics.core.evaluation import Evaluation
+import pytest
+
+
+def test_to_infinity():
+    for str_expr, str_expected, message in (
+        (
+            "PythonForm[Infinity]",
+            '"math.inf"',
+            "Infinity",
+        ),
+        (
+            "PythonForm[{1, 2, 3, 4}]",
+            '"[1, 2, 3, 4]"',
+            "Simple List of integers",
+        ),
+        (
+            "Pi // PythonForm",
+            '"sympy.pi"',
+            "Pi",
+        ),
+
+    ):
+        check_evaluation(str_expr, str_expected, message)