Merge branch 'master' into fixes4Compile

Author: mmatera

mathics/builtin/__init__.py

@@ -1,12 +1,11 @@
-#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-from mathics.core.expression import ensure_context
 
 import glob
 import importlib
 import re
 import os.path as osp
 from mathics.settings import ENABLE_FILES_MODULE
+from mathics.version import __version__  # noqa used in loading to check consistency.
 
 # Get a list of file in this directory. We'll exclude from the start
 # files with leading characters we don't want like __init__ with its leading underscore.
@@ -23,8 +22,6 @@
     PatternObject,
 )
 
-from mathics.settings import ENABLE_FILES_MODULE
-
 exclude_files = set(("files", "codetables", "base", "importexport", "colors"))
 module_names = [
     f for f in __py_files__ if re.match("^[a-z0-9]+$", f) if f not in exclude_files
@@ -38,12 +35,20 @@
 for module_name in module_names:
     try:
         module = importlib.import_module("mathics.builtin." + module_name)
-    except:
-        # print("XXX", module_name)
+    except Exception as e:
+        print(e)
+        print(f"    Not able to load {module_name}. Check your installation.")
+        print(f"    mathics.builtin loads from {__file__[:-11]}")
         continue
+
+    if __version__ != module.__version__:
+        print(
+            f"Version {module.__version__} in the module do not match with {__version__}"
+        )
+
     modules.append(module)
 
-builtins = []
+_builtins = []
 builtins_by_module = {}
 
 
@@ -75,7 +80,7 @@ def is_builtin(var):
                 # This set the default context for symbols in mathics.builtins
                 if not type(instance).context:
                     type(instance).context = "System`"
-                builtins.append( (instance.get_name(), instance))
+                _builtins.append((instance.get_name(), instance))
                 builtins_by_module[module.__name__].append(instance)
 
 
@@ -85,7 +90,6 @@ def is_builtin(var):
 mathics_to_python = {}  # here we have: name -> string
 sympy_to_mathics = {}
 
-box_constructs = {}
 pattern_objects = {}
 builtins_precedence = {}
 
@@ -101,20 +105,26 @@ def add_builtins(new_builtins):
             mathics_to_sympy[name] = builtin
             for sympy_name in builtin.get_sympy_names():
                 sympy_to_mathics[sympy_name] = builtin
-        if isinstance(builtin, BoxConstruct):
-            box_constructs[name] = builtin
         if isinstance(builtin, Operator):
             builtins_precedence[name] = builtin.precedence
         if isinstance(builtin, PatternObject):
             pattern_objects[name] = builtin.__class__
-    builtins.update(dict(new_builtins))
+    _builtins.update(dict(new_builtins))
 
 
-new_builtins = builtins
-builtins = {}
+new_builtins = _builtins
+_builtins = {}
 add_builtins(new_builtins)
 
 
+def builtins_dict():
+    return {
+        builtin.get_name(): builtin
+        for modname, builtins in builtins_by_module.items()
+        for builtin in builtins
+    }
+
+
 def get_module_doc(module):
     doc = module.__doc__
     if doc is not None:
@@ -134,8 +144,8 @@ def get_module_doc(module):
 
 def contribute(definitions):
     # let MakeBoxes contribute first
-    builtins["System`MakeBoxes"].contribute(definitions)
-    for name, item in builtins.items():
+    _builtins["System`MakeBoxes"].contribute(definitions)
+    for name, item in _builtins.items():
         if name != "System`MakeBoxes":
             item.contribute(definitions)
 

mathics/builtin/algebra.py

@@ -1,9 +1,9 @@
-#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
 Algebraic Manipulation
 """
 
+from mathics.version import __version__  # noqa used in loading to check consistency.
 
 from mathics.builtin.base import Builtin
 from mathics.core.expression import Expression, Integer, Symbol, Atom, Number

mathics/builtin/arithmetic.py

@@ -1,4 +1,3 @@
-#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 # cython: language_level=3
 
@@ -8,10 +7,9 @@
 Basic arithmetic functions, including complex number arithmetic.
 """
 
-
+from mathics.version import __version__  # noqa used in loading to check consistency.
 import sympy
 import mpmath
-import math
 
 from mathics.builtin.base import (
     Builtin,
@@ -1350,7 +1348,7 @@ def apply(self, expr, evaluation):
         # try expanding the expression
             exprexp = Expression("ExpandAll", expr).evaluate(evaluation)
             exprexp = exprexp.to_sympy()
-            result = _iszero(exprexp)        
+            result = _iszero(exprexp)
         if result is None:
             # Can't get exact answer, so try approximate equal
             numeric_val = Expression("N", expr).evaluate(evaluation)

mathics/builtin/assignment.py

@@ -1,6 +1,6 @@
-#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
+from mathics.version import __version__  # noqa used in loading to check consistency.
 
 import mathics.builtin
 from mathics.builtin.base import (
@@ -848,7 +848,7 @@ def _get_usage_string(symbol, evaluation, htmlout=False):
     bio = pymathics.get(definition.name)
     if bio is None:
         bio = builtins.get(definition.name)
-    
+
     if bio is not None:
         from mathics.doc.doc import Doc
         docstr = bio.builtin.__class__.__doc__
@@ -1768,9 +1768,6 @@ def apply(self, module, evaluation):
         except ImportError as e:
             evaluation.message(self.get_name(), 'notfound', module)
             return SymbolFailed
-        except PyMathicsLoadException as e:
-            evaluation.message(self.get_name(), 'notmathicslib', module)
-            return SymbolFailed
         else:
         # Add Pymathics` to $ContextPath so that when user don't
         # have to qualify Pymathics variables and functions,

mathics/builtin/attributes.py

@@ -1,4 +1,3 @@
-#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
 r"""
@@ -8,9 +7,9 @@
 However, you can set any symbol as an attribute, in contrast to \Mathematica.
 """
 
+from mathics.version import __version__  # noqa used in loading to check consistency.
 
 from mathics.builtin.base import Predefined, Builtin
-from mathics.builtin.evaluation import Sequence
 from mathics.core.expression import Expression, Symbol, SymbolNull, String
 from mathics.builtin.assignment import get_symbol_list
 

mathics/builtin/base.py

@@ -1,17 +1,16 @@
-#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
-import mpmath
 import re
 import sympy
 
 from functools import total_ordering
 import importlib
 from itertools import chain
-
 import typing
 from typing import Any, cast
 
+from mathics.version import __version__  # noqa used in loading to check consistency.
+
 from mathics.core.definitions import Definition
 from mathics.core.parser.util import SystemDefinitions, PyMathicsDefinitions
 from mathics.core.rules import Rule, BuiltinRule, Pattern
@@ -28,6 +27,7 @@
 )
 from mathics.core.numbers import get_precision, PrecisionValueError
 
+
 def get_option(options, name, evaluation, pop=False, evaluate=True):
     # we do not care whether an option X is given as System`X,
     # Global`X, or with any prefix from $ContextPath for that
@@ -84,6 +84,7 @@ def __init__(self, *args, **kwargs):
 
     def contribute(self, definitions, is_pymodule=False):
         from mathics.core.parser import parse_builtin_rule
+
         # Set the default context
         if not self.context:
             self.context = "Pymathics`" if is_pymodule else "System`"
@@ -147,9 +148,7 @@ def check_options(options_to_check, evaluation):
 
         for pattern, function in self.get_functions(is_pymodule=is_pymodule):
             rules.append(
-                BuiltinRule(
-                    name, pattern, function, check_options, system=True
-                )
+                BuiltinRule(name, pattern, function, check_options, system=True)
             )
         for pattern, replace in self.rules.items():
             if not isinstance(pattern, BaseExpression):
@@ -270,7 +269,7 @@ def contextify_form_name(f):
             attributes=attributes,
             options=options,
             defaultvalues=defaults,
-            builtin=self
+            builtin=self,
         )
         if is_pymodule:
             definitions.pymathics[name] = definition
@@ -366,7 +365,7 @@ def get_option_string(self, *params):
         return None, s
 
 
-class InstancableBuiltin(Builtin):
+class InstanceableBuiltin(Builtin):
     def __new__(cls, *args, **kwargs):
         new_kwargs = kwargs.copy()
         new_kwargs["expression"] = False
@@ -379,7 +378,7 @@ def __new__(cls, *args, **kwargs):
             try:
                 instance.init(*args, **kwargs)
             except TypeError:
-                # TypeError occurs when unpickling instance, e.g. PatterObject,
+                # TypeError occurs when unpickling instance, e.g. PatternObject,
                 # because parameter expr is not given. This should no be a
                 # problem, as pickled objects need their init-method not
                 # being called.
@@ -533,15 +532,15 @@ def apply(self, expr, evaluation) -> Symbol:
 
 
 class SympyFunction(SympyObject):
-    def get_constant(self, precision, have_mpmath=False):
+    def get_constant(self, precision, evaluation, have_mpmath=False):
         try:
             d = get_precision(precision, evaluation)
         except PrecisionValueError:
             return
 
         sympy_fn = self.to_sympy()
         if d is None:
-            result = self.get_mpmath_function()if have_mpmath else sympy_fn()
+            result = self.get_mpmath_function() if have_mpmath else sympy_fn()
             return MachineReal(result)
         else:
             return PrecisionReal(sympy_fn.n(d))
@@ -594,11 +593,105 @@ class BoxConstructError(Exception):
     pass
 
 
-class BoxConstruct(Builtin):
-    def get_option_values(self, leaves, evaluation=None, **options):
-        default = evaluation.definitions.get_options(self.get_name()).copy()
-        options = Expression("List", *leaves).get_option_values(evaluation)
-        default.update(options)
+class BoxConstruct(InstanceableBuiltin):
+    def __new__(cls, *leaves, **kwargs):
+        instance = super().__new__(cls, *leaves, **kwargs)
+        instance._leaves = leaves
+        return instance
+
+    def evaluate(self, evaluation):
+        # THINK about: Should we evaluate the leaves here?
+        return
+
+    def get_head_name(self):
+        return self.get_name()
+
+    def get_lookup_name(self):
+        return self.get_name()
+
+    def get_string_value(self):
+        return "-@" + self.get_head_name() + "@-"
+
+    def same(self, expr):
+        return expr.same(self)
+
+    def is_atom(self):
+        return False
+
+    def do_format(self, evaluation, format):
+        return self
+
+    def format(self, evaluation, fmt):
+        return self
+
+    def get_head(self):
+        return Symbol(self.get_name())
+
+    @property
+    def head(self):
+        return self.get_head()
+
+    @head.setter
+    def head(self, value):
+        raise ValueError("BoxConstruct.head is write protected.")
+
+    @property
+    def leaves(self):
+        return self._leaves
+
+    @leaves.setter
+    def leaves(self, value):
+        raise ValueError("BoxConstruct.leaves is write protected.")
+
+    # I need to repeat this, because this is not
+    # an expression...
+    def has_form(self, heads, *leaf_counts):
+        """
+        leaf_counts:
+            (,):        no leaves allowed
+            (None,):    no constraint on number of leaves
+            (n, None):  leaf count >= n
+            (n1, n2, ...):    leaf count in {n1, n2, ...}
+        """
+
+        head_name = self.get_name()
+        if isinstance(heads, (tuple, list, set)):
+            if head_name not in [ensure_context(h) for h in heads]:
+                return False
+        else:
+            if head_name != ensure_context(heads):
+                return False
+        if not leaf_counts:
+            return False
+        if leaf_counts and leaf_counts[0] is not None:
+            count = len(self._leaves)
+            if count not in leaf_counts:
+                if (
+                    len(leaf_counts) == 2
+                    and leaf_counts[1] is None  # noqa
+                    and count >= leaf_counts[0]
+                ):
+                    return True
+                else:
+                    return False
+        return True
+
+    def flatten_pattern_sequence(self, evaluation) -> "BoxConstruct":
+        return self
+
+    def get_option_values(self, leaves, **options):
+        evaluation = options.get("evaluation", None)
+        if evaluation:
+            default = evaluation.definitions.get_options(self.get_name()).copy()
+            options = Expression("List", *leaves).get_option_values(evaluation)
+            default.update(options)
+        else:
+            from mathics.core.parser import parse_builtin_rule
+
+            default = {}
+            for option, value in self.options.items():
+                option = ensure_context(option)
+                default[option] = parse_builtin_rule(value)
         return default
 
     def boxes_to_text(self, leaves, **options) -> str:
@@ -621,7 +714,7 @@ def __init__(self, name, count, expected):
         super().__init__(None, None)
 
 
-class PatternObject(InstancableBuiltin, Pattern):
+class PatternObject(InstanceableBuiltin, Pattern):
     needs_verbatim = True
 
     arg_counts: typing.List[int] = []