Fix mypy errors

mathics/builtin/atomic/numbers.py

@@ -668,7 +668,7 @@ class MaxPrecision(Predefined):
      = 3.141592654
     """
 
-    is_numeric = False
+    _is_numeric = False
     messages = {
         "precset": "Cannot set `1` to `2`; value must be a positive number or Infinity.",
         "preccon": "Cannot set `1` such that $MaxPrecision < $MinPrecision.",
@@ -702,7 +702,7 @@ class MachineEpsilon_(Predefined):
      = {0., 0., 2.22045×10^-16}
     """
 
-    is_numeric = True
+    _is_numeric = True
     name = "$MachineEpsilon"
 
     summary_text = "the difference between 1.0 and the next-nearest number representable as a machine-precision number"
@@ -729,7 +729,7 @@ class MachinePrecision_(Predefined):
     summary_text = (
         "the number of decimal digits of precision for machine-precision numbers"
     )
-    is_numeric = True
+    _is_numeric = True
     rules = {
         "$MachinePrecision": "N[MachinePrecision]",
     }
@@ -749,7 +749,7 @@ class MachinePrecision(Predefined):
      = 15.9545897701910033463281614204
     """
 
-    is_numeric = True
+    _is_numeric = True
     rules = {
         "N[MachinePrecision, prec_]": (
             "N[Log[10, 2] * %i, prec]" % FP_MANTISA_BINARY_DIGITS
@@ -786,7 +786,7 @@ class MinPrecision(Builtin):
     }
 
     name = "$MinPrecision"
-    is_numeric = True
+    _is_numeric = True
     rules = {
         "$MinPrecision": "0",
     }

mathics/builtin/box/expression.py

@@ -1,6 +1,8 @@
 # This is never intended to go in Mathics3 docs
 no_doc = True
 
+from typing import Optional, Sequence, Union
+
 from mathics.core.attributes import A_PROTECTED, A_READ_PROTECTED
 from mathics.core.builtin import BuiltinElement
 from mathics.core.element import BoxElementMixin
@@ -109,8 +111,8 @@ def get_head_name(self):
     def get_lookup_name(self):
         return self.get_name()
 
-    def get_sort_key(self) -> tuple:
-        return self.to_expression().get_sort_key()
+    def get_sort_key(self, pattern_sort=False) -> tuple:
+        return self.to_expression().get_sort_key(pattern_sort)
 
     def get_string_value(self):
         return "-@" + self.get_head_name() + "@-"
@@ -119,7 +121,13 @@ def get_string_value(self):
     def head(self):
         return self.get_head()
 
-    def has_form(self, heads, *element_counts):
+    @head.setter
+    def head(self, value):
+        raise ValueError("BoxExpression.head is write protected.")
+
+    def has_form(
+        self, heads: Union[Sequence[str], str], *element_counts: Optional[int]
+    ) -> bool:
         """
         element_counts:
             (,):        no elements allowed
@@ -133,9 +141,13 @@ def has_form(self, heads, *element_counts):
         if isinstance(heads, (tuple, list, set)):
             if head_name not in [ensure_context(h) for h in heads]:
                 return False
-        else:
+        elif isinstance(heads, str):
             if head_name != ensure_context(heads):
                 return False
+        else:
+            raise TypeError(
+                f"Heads must be a string or a sequence of strings, not {type(heads)}"
+            )
         if not element_counts:
             return False
         if element_counts and element_counts[0] is not None:
@@ -151,10 +163,6 @@ def has_form(self, heads, *element_counts):
                     return False
         return True
 
-    @head.setter
-    def head(self, value):
-        raise ValueError("BoxExpression.head is write protected.")
-
     @property
     def is_literal(self) -> bool:
         """

mathics/builtin/list/constructing.py

@@ -8,6 +8,7 @@
 See also Constructing Vectors.
 """
 
+import typing
 from itertools import permutations
 
 from mathics.builtin.box.layout import RowBox
@@ -20,7 +21,7 @@
 from mathics.core.evaluation import Evaluation
 from mathics.core.expression import Expression, structure
 from mathics.core.list import ListExpression
-from mathics.core.symbols import Atom
+from mathics.core.symbols import Atom, Symbol
 from mathics.core.systemsymbols import SymbolNormal
 from mathics.eval.lists import get_tuples, list_boxes
 
@@ -268,9 +269,9 @@ def eval(self, imin, imax, di, evaluation: Evaluation):
             and isinstance(di, Integer)
         ):
             pm = 1 if di.value >= 0 else -1
-            result = [Integer(i) for i in range(imin.value, imax.value + pm, di.value)]
             return ListExpression(
-                *result, elements_properties=range_list_elements_properties
+                *[Integer(i) for i in range(imin.value, imax.value + pm, di.value)],
+                elements_properties=range_list_elements_properties,
             )
 
         imin = imin.to_sympy()
@@ -349,7 +350,7 @@ def eval_n(self, li, n, evaluation: Evaluation):
             py_n = min(n.get_int_value(), len(li.elements))
         elif n.has_form("List", 1) and isinstance(n.elements[0], Integer):
             py_n = n.elements[0].get_int_value()
-            rs = (py_n,)
+            rs = [py_n]
         elif (
             n.has_form("DirectedInfinity", 1) and n.elements[0].get_int_value() == 1
         ) or n.get_name() == "System`All":
@@ -359,12 +360,12 @@ def eval_n(self, li, n, evaluation: Evaluation):
 
         if py_n is None or py_n < 0:
             evaluation.message(
-                self.get_name(), "nninfseq", Expression(self.get_name(), li, n)
+                self.get_name(), "nninfseq", Expression(Symbol(self.get_name()), li, n)
             )
             return
 
         if rs is None:
-            rs = range(py_n + 1)
+            rs = list(range(py_n + 1))
 
         inner = structure("List", li, evaluation)
         outer = structure("List", inner, evaluation)
@@ -431,7 +432,7 @@ def eval(self, expr, patterns, f, evaluation: Evaluation):
         "Reap[expr_, {patterns___}, f_]"
 
         patterns = patterns.get_sequence()
-        sown = [
+        sown: typing.List[typing.Tuple[BasePattern, list]] = [
             (BasePattern.create(pattern, evaluation=evaluation), [])
             for pattern in patterns
         ]

mathics/builtin/list/rearrange.py

@@ -232,7 +232,7 @@ def eval_zero(self, element, n, evaluation: Evaluation):
             Integer0,
             Integer0,
             evaluation,
-            lambda: Expression(self.get_name(), element, n),
+            lambda: Expression(Symbol(self.get_name()), element, n),
         )
 
     def eval(self, element, n, x, evaluation: Evaluation):
@@ -243,7 +243,7 @@ def eval(self, element, n, x, evaluation: Evaluation):
             x,
             Integer0,
             evaluation,
-            lambda: Expression(self.get_name(), element, n, x),
+            lambda: Expression(Symbol(self.get_name()), element, n, x),
         )
 
     def eval_margin(self, element, n, x, m, evaluation: Evaluation):
@@ -254,7 +254,7 @@ def eval_margin(self, element, n, x, m, evaluation: Evaluation):
             x,
             m,
             evaluation,
-            lambda: Expression(self.get_name(), element, n, x, m),
+            lambda: Expression(Symbol(self.get_name()), element, n, x, m),
         )
 
 
@@ -354,6 +354,8 @@ def _gather(self, keys, values, equivalence):
 class _Rotate(Builtin):
     messages = {"rspec": "`` should be an integer or a list of integers."}
 
+    _sign: int
+
     def _rotate(self, expr, n, evaluation: Evaluation):
         if not isinstance(expr, Expression):
             return expr
@@ -363,7 +365,7 @@ def _rotate(self, expr, n, evaluation: Evaluation):
             return expr
 
         index = (self._sign * n[0]) % len(elements)  # with Python's modulo: index >= 1
-        new_elements = chain(elements[index:], elements[:index])
+        new_elements = list(chain(elements[index:], elements[:index]))
 
         if len(n) > 1:
             new_elements = [

mathics/builtin/numbers/algebra.py

@@ -438,7 +438,9 @@ def eval(self, expr, evaluation):
 
 
 # Get a coefficient of form in an expression
-def _coefficient(name, expr, form, n, evaluation):
+def _coefficient(
+    name: str, expr: Expression, form: Expression, n: Integer, evaluation: Evaluation
+) -> BaseElement:
     if expr is SymbolNull or form is SymbolNull or n is SymbolNull:
         return Integer0
 
@@ -450,18 +452,11 @@ def _coefficient(name, expr, form, n, evaluation):
     sympy_var = form.to_sympy()
     sympy_n = n.to_sympy()
 
-    def combine_exprs(exprs):
-        result = 0
-        for e in exprs:
-            result += e
-        return result
-
     # expand sub expressions if they contain variables
-    sympy_exprs = [
+    sympy_expr: sympy.Expr = sum(
         sympy.expand(e) if sympy_var.free_symbols.issubset(e.free_symbols) else e
         for e in sympy_exprs
-    ]
-    sympy_expr = combine_exprs(sympy_exprs)
+    )
     sympy_result = sympy_expr.coeff(sympy_var, sympy_n)
     return from_sympy(sympy_result)
 
@@ -519,16 +514,18 @@ class Coefficient(Builtin):
 
     summary_text = "coefficient of a monomial in a polynomial expression"
 
-    def eval_noform(self, expr, evaluation):
+    def eval_noform(self, expr: Expression, evaluation: Evaluation):
         "Coefficient[expr_]"
         evaluation.message("Coefficient", "argtu")
 
-    def eval(self, expr, form, evaluation):
+    def eval(self, expr: Expression, form: Expression, evaluation: Evaluation):
         "Coefficient[expr_, form_]"
         return _coefficient(self.__class__.__name__, expr, form, Integer1, evaluation)
 
-    def eval_n(self, expr, form, n, evaluation):
-        "Coefficient[expr_, form_, n_]"
+    def eval_n(
+        self, expr: Expression, form: Expression, n: Integer, evaluation: Evaluation
+    ):
+        "Coefficient[expr_, form_, n_Integer]"
         return _coefficient(self.__class__.__name__, expr, form, n, evaluation)
 
 
@@ -559,9 +556,8 @@ def coeff_power_internal(
 
         # ###### Auxiliary functions #########
         def key_powers(lst: list) -> Union[int, float]:
-            key = Expression(SymbolPlus, *lst)
-            key = key.evaluate(evaluation)
-            if key.is_numeric(evaluation):
+            key = Expression(SymbolPlus, *lst).evaluate(evaluation)
+            if key is not None and key.is_numeric(evaluation):
                 return key.to_python()
             return 0