metaprogramming to generate all no-method classes.

Author: rocky

mathics/builtin/atomic/symbols.py

@@ -51,7 +51,7 @@
 )
 
 
-def _get_usage_string(symbol, evaluation, is_long_form: bool, htmlout=False):
+def _get_usage_string(symbol, evaluation, is_long_form: bool):
     """
     Returns a python string with the documentation associated to a given symbol.
     """
@@ -78,16 +78,13 @@ def _get_usage_string(symbol, evaluation, is_long_form: bool, htmlout=False):
     if bio is not None:
         if not is_long_form and hasattr(bio.builtin.__class__, "summary_text"):
             return bio.builtin.__class__.summary_text
-        from mathics.doc.common_doc import XMLDoc
+        from mathics.doc.common_doc import XMLDOC
 
         docstr = bio.builtin.__class__.__doc__
         title = bio.builtin.__class__.__name__
         if docstr is None:
             return None
-        if htmlout:
-            usagetext = XMLDoc(docstr, title).html()
-        else:
-            usagetext = XMLDoc(docstr, title).text(0)
+        usagetext = XMLDOC(docstr, title).text(0)
         usagetext = re.sub(r"\$([0-9a-zA-Z]*)\$", r"\1", usagetext)
         return usagetext
     return None

mathics/builtin/no_meaning.py

@@ -6,46 +6,49 @@
 You can use these operators as a way to build up your own notation within Mathics3.
 """
 
-from inspect import getmembers, isclass
-from sys import modules
-
-from mathics.core.builtin import OPERATOR_DATA, NoMeaningInfixOperator
-
-# Note: classes in this file must *only* be "no-meaning"
-# builtin operator classes.
-
-
-class Because(NoMeaningInfixOperator):
-    r"""This text is replaced! But it needs to be here for documentation detection."""
-
-
-class Cap(NoMeaningInfixOperator):
-    r"""This text is replaced! But it needs to be here for documentation detection."""
-
-
-class CenterDot(NoMeaningInfixOperator):
-    r"""This text is replaced! But it needs to be here for documentation detection."""
-
-
-class Star(NoMeaningInfixOperator):
-    r"""This text is replaced! But it needs to be here for documentation detection."""
+# WARNING: This module uses fancy MetaProgramming to create the Mathics3 Builtin classes for the
+# operators in that have no pre-defined meaning. This is tricky and probably fragile code.
+# We use the type() function to create the class, and setattr, to include this class inside
+# this module.
 
+from sys import modules
 
-# Generate Builtin No-meaning Builtin Infix operators, using
-# the Operator name and Operator Unicode found by reading
-# the operators JSON file.
-for name, operator_class in getmembers(modules[__name__]):
-    if isclass(operator_class):
-        operator_name = operator_class.__name__
-        operator_string = OPERATOR_DATA["no-meaning-infix-operators"].get(operator_name)
-        if operator_string is not None:
-            operator_class.operator = operator_string
-            operator_class.__doc__ = NoMeaningInfixOperator.__doc_pattern__.format(
-                operator_name=operator_name, operator_string=operator_string
-            )
-        operator_class.summary_text = f"""{operator_name} infix operator "{operator_string}" (no pre-set meaning attached)"""
-        operator_class.formats = {
-            (("InputForm", "OutputForm", "StandardForm"), f"{operator_name}[args__]"): (
-                ('Infix[{args}, "%s"]' % operator_string)
-            )
-        }
+from mathics.core.builtin import (
+    OPERATOR_DATA,
+    NoMeaningInfixOperator,
+    NoMeaningPostfixOperator,
+    NoMeaningPrefixOperator,
+)
+
+# Generate no-meaning Mathics3 Builtin class from the operator name,
+# affix, and Operator Unicode values found read from the JSON operators
+# file.
+for affix, format_fn, operator_base_class in (
+    ("infix", "Infix", NoMeaningInfixOperator),
+    ("postfix", "Postfix", NoMeaningPostfixOperator),
+    ("prefix", "Prefix", NoMeaningPrefixOperator),
+):
+    for operator_name, operator_string in OPERATOR_DATA[
+        f"no-meaning-{affix}-operators"
+    ].items():
+        # Create the Mathics3 Builtin class...
+        generated_operator_class = type(
+            operator_name,
+            (operator_base_class,),
+            {
+                "__doc__": operator_base_class.__doc_pattern__.format(
+                    operator_name=operator_name, operator_string=operator_string
+                ),
+                "operator": operator_string,
+                "summary_text": f"""{operator_name} {affix} operator "{operator_string}" (no pre-set meaning attached)""",
+                "formats": {
+                    (
+                        ("InputForm", "OutputForm", "StandardForm"),
+                        f"{operator_name}[args__]",
+                    ): (('%s[{args}, "%s"]' % (format_fn, operator_string)))
+                },
+            },
+        )
+
+        # Put the newly-created Builtin class inside this module.
+        setattr(modules[__name__], operator_name, generated_operator_class)

mathics/core/builtin.py

@@ -1159,7 +1159,7 @@ def eval_multi(self, expr, first, sequ, evaluation):
         return to_expression(name, to_expression(name, expr, *sequ), first)
 
 
-class Operator(Builtin, ABC):
+class Operator(Builtin):
     """
     Base Class for operators: binary, unary, nullary, prefix postfix, ...
     """
@@ -1192,7 +1192,9 @@ def get_operator_display(self) -> Optional[str]:
             return self.operator
 
 
-class InfixOperator(Operator, ABC):
+# Note: Metaprogramming in mathics.builtin.no_meaning fails if
+# we inherit from ABC
+class InfixOperator(Operator):
     """
     Class for Mathics3 built-in Infix Operators. Infix operators are
     represented with an operator in between each argument. A common
@@ -1254,14 +1256,14 @@ def __init__(self, *args, **kwargs):
             self.rules = default_rules
 
 
-class NoMeaningInfixOperator(InfixOperator, ABC):
+class NoMeaningInfixOperator(InfixOperator):
     """
     Operators that have no pre-defined meaning are derived from this class.
     """
 
     # This will be used to create a docstring
     __doc_pattern__ = r"""
-    {operator_name} <url>
+    <url>
     :WML link:
     https://reference.wolfram.com/language/ref/{operator_name}.html</url>
 
@@ -1277,6 +1279,13 @@ class NoMeaningInfixOperator(InfixOperator, ABC):
      = a {operator_string} b
 
     """
+    __formats_pattern__ = r"""{lbrace}
+                    (
+                           ("InputForm", "OutputForm", "StandardForm"),
+                        f"{operator_name}[args__]",
+                    ): (('Infix[{lbrace}args{rbrace}, {operator_string}"]'))
+                {rbrace}"""
+
     attributes = A_NO_ATTRIBUTES
     default_formats = False  # Don't use any default format rules. Instead, see below.
 
@@ -1296,8 +1305,10 @@ def get_functions(self, prefix="eval", is_pymodule=False) -> List[Callable]:
         return functions
 
 
-# Has to come before PostFixOperator and PrefixOperator
-class UnaryOperator(Operator, ABC):
+# Has to come before PostfixOperator and PrefixOperator
+# Note: Metaprogramming in mathics.builtin.no_meaning fails if
+# we inherit from ABC
+class UnaryOperator(Operator):
     """
     Class for Unary Operators, (e.g. Not, Factorial)
     """
@@ -1321,7 +1332,9 @@ def __init__(self, format_function, *args, **kwargs):
                     self.formats[op_pattern] = form
 
 
-class PostfixOperator(UnaryOperator, ABC):
+# Note: Metaprogramming in mathics.builtin.no_meaning fails if
+# we inherit from ABC
+class PostfixOperator(UnaryOperator):
     """
     Class for Builtin Postfix Unary Operators, e.g. Factorial (!)
     """
@@ -1330,7 +1343,40 @@ def __init__(self, *args, **kwargs):
         super().__init__("Postfix", *args, **kwargs)
 
 
-class PrefixOperator(UnaryOperator, ABC):
+# Has to be after PostfixOperator
+class NoMeaningPostfixOperator(PostfixOperator):
+    """
+    Postfix Operators that have no pre-defined meaning are derived from this class.
+    """
+
+    # This will be used to create a docstring
+    __doc_pattern__ = r"""
+    <url>
+    :WML link:
+    https://reference.wolfram.com/language/ref/{operator_name}.html</url>
+
+    <dl>
+      <dt>'{operator_name}[$x$]'
+      <dd>displays $x$ {operator_string}
+    </dl>
+
+    >> {operator_name}[x]
+     = x {operator_string}
+
+    >> x \[{operator_name}]
+     = x {operator_string}
+
+    """
+    attributes = A_NO_ATTRIBUTES
+    default_formats = False  # Don't use any default format rules. Instead, see below.
+
+    operator = "This should be overwritten"
+    summary_text = "This should be overwritten"
+
+
+# Note: Metaprogramming in mathics.builtin.no_meaning fails if
+# we inherit from ABC
+class PrefixOperator(UnaryOperator):
     """
     Class for Builtin Prefix Unary Operators, e.g. Not ("¬")
     """
@@ -1339,6 +1385,37 @@ def __init__(self, *args, **kwargs):
         super().__init__("Prefix", *args, **kwargs)
 
 
+# Has to be after PrefixOperator
+class NoMeaningPrefixOperator(PrefixOperator):
+    """
+    Prefix Operators that have no pre-defined meaning are derived from this class.
+    """
+
+    # This will be used to create a docstring
+    __doc_pattern__ = r"""
+    <url>
+    :WML link:
+    https://reference.wolfram.com/language/ref/{operator_name}.html</url>
+
+    <dl>
+      <dt>'{operator_name}[$x$]'
+      <dd>displays {operator_string} $x$
+    </dl>
+
+    >> {operator_name}[x]
+     = {operator_string}x
+
+    >> \[{operator_name}]x
+     = {operator_string}x
+
+    """
+    attributes = A_NO_ATTRIBUTES
+    default_formats = False  # Don't use any default format rules. Instead, see below.
+
+    operator = "This should be overwritten"
+    summary_text = "This should be overwritten"
+
+
 class PatternObject(BuiltinElement, BasePattern):
     needs_verbatim = True
 

test/builtin/test_datentime.py

@@ -136,13 +136,13 @@ def test_private_doctests_datetime(str_expr, msgs, str_expected, fail_msg):
     [
         ##
         (
-            "TimeConstrained[Integrate[Sin[x]^100,x],.1.1]",
+            "TimeConstrained[Integrate[Sin[x]^100,x],1.1]",
             None,
             "$Aborted",
             "TimeConstrained with two arguments",
         ),
         (
-            "TimeConstrained[Integrate[Sin[x]^100,x],.1.1, Integrate[Cos[x],x]]",
+            "TimeConstrained[Integrate[Sin[x]^100,x],1.1, Integrate[Cos[x],x]]",
             None,
             "Sin[x]",
             "TimeConstrained with three arguments",