Add CI job for mypy (#1150)

I've fixed up the remaining mypy errors outside of:

- `mathics.builtin` and `mathics.eval`: these still have quite a few
errors, but are going to be a bigger job to go through than the core
modules, and are probably easier to just knock off one by one
incrementally
- `test/` which I'd say are lower priority for type checking
- `mathics/benchmark.py`: is this still used? It just crashes when I try
to run it

For now I've just set the mypy config to ignore these directories so we
can run a CI job to ensure that the other core modules continue to
typecheck, but might be better to be a bit more selective.

There were also a couple bits of code I've commented out as they
appeared to be dead as best I could tell, but tell me if I'm mistaken.

Author: davidar

.github/workflows/mypy.yml

@@ -0,0 +1,40 @@
+name: Mathics3 (Type checking)
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ['3.12']
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        sudo apt update -qq && sudo apt install llvm-dev remake
+        python -m pip install --upgrade pip
+        # We can comment out after next Mathics-Scanner release
+        # python -m pip install -e git+https://github.com/Mathics3/mathics-scanner#egg=Mathics-Scanner[full]
+        git clone https://github.com/Mathics3/mathics-scanner.git
+        cd mathics-scanner/
+        pip install -e .
+        cd ..
+
+    - name: Install Mathics with minimum dependencies
+      run: |
+        make develop
+    - name: Run mypy
+      run: |
+        pip install mypy==1.13 sympy==1.12
+        touch ./mathics-scanner/mathics_scanner/py.typed
+        pip install ./mathics-scanner/
+        mypy --install-types --non-interactive mathics

mathics/__init__.py

@@ -3,7 +3,7 @@
 import platform
 import sys
 from importlib import import_module
-from typing import Dict
+from typing import Dict, Tuple
 
 from mpmath import __version__ as mpmath_version
 from numpy import __version__ as numpy_version
@@ -26,7 +26,7 @@
 
 # optional_software contains a list of Python packages
 # that add functionality but are optional
-optional_software: Dict[str, str] = (
+optional_software: Tuple[str, ...] = (
     "cython",
     "lxml",
     "matplotlib",

mathics/builtin/box/graphics.py

@@ -7,6 +7,7 @@
 
 
 from math import atan2, ceil, cos, degrees, floor, log10, pi, sin
+from typing import Optional
 
 from mathics.builtin.box.expression import BoxExpression
 from mathics.builtin.colors.color_directives import (
@@ -48,7 +49,7 @@
 
 # Note: has to come before _ArcBox
 class _RoundBox(_GraphicsElementBox):
-    face_element = None
+    face_element: Optional[bool] = None
 
     def init(self, graphics, style, item):
         super(_RoundBox, self).init(graphics, item, style)

mathics/builtin/quantum_mechanics/angular.py

@@ -106,10 +106,10 @@ class PauliMatrix(SympyFunction):
     >> PauliMatrix[1] . PauliMatrix[2] == I PauliMatrix[3]
      = True
 
-    >> MatrixExp[I \[Phi]/2 PauliMatrix[3]]
+    >> MatrixExp[I \\[Phi]/2 PauliMatrix[3]]
      = {{E ^ (I / 2 ϕ), 0}, {0, E ^ ((-I / 2) ϕ)}}
 
-    >> % /. \[Phi] -> 2 Pi
+    >> % /. \\[Phi] -> 2 Pi
      = {{-1, 0}, {0, -1}}
     """
 

mathics/core/atoms.py

@@ -6,7 +6,7 @@
 import re
 from typing import Any, Dict, Generic, Optional, Tuple, TypeVar, Union
 
-import mpmath  # type: ignore[import-untyped]
+import mpmath
 import sympy
 
 from mathics.core.element import BoxElementMixin, ImmutableValueMixin

mathics/core/builtin.py

@@ -26,7 +26,7 @@
     cast,
 )
 
-import mpmath  # type: ignore[import-untyped]
+import mpmath
 import pkg_resources
 import sympy
 
@@ -517,6 +517,8 @@ def is_literal(self) -> bool:
 
 
 class BuiltinElement(Builtin, BaseElement):
+    options: Dict[str, Any]
+
     def __new__(cls, *args, **kwargs):
         new_kwargs = kwargs.copy()
         # In a Builtin element, we never return an Expression object,
@@ -1212,6 +1214,7 @@ class PatternObject(BuiltinElement, BasePattern):
     needs_verbatim = True
 
     arg_counts: List[int] = []
+    options: Dict[str, Any]
 
     def init(self, expr: Expression, evaluation: Optional[Evaluation] = None):
         super().init(expr, evaluation=evaluation)

mathics/core/convert/mpmath.py

@@ -3,7 +3,7 @@
 from functools import lru_cache
 from typing import Optional, Union
 
-import mpmath  # type: ignore[import-untyped]
+import mpmath
 import sympy
 
 from mathics.core.atoms import Complex, MachineReal, MachineReal0, PrecisionReal

mathics/core/element.py

@@ -208,8 +208,9 @@ class BaseElement(KeyComparable, ABC):
     Some important subclasses: Atom and Expression.
     """
 
-    options: dict
+    options: Optional[Dict[str, Any]]
     last_evaluated: Any
+    unevaluated: bool
     # this variable holds a function defined in mathics.core.expression that creates an expression
     create_expression: Any
 

mathics/core/evaluation.py

@@ -172,7 +172,7 @@ def __init__(
         self.out: List[_Out] = []
         self.output = output if output else Output()
         self.listeners: Dict[str, List[Callable]] = {}
-        self.options: Optional[tuple] = None
+        self.options: Optional[Dict[str, Any]] = None
         self.predetermined_out = None
 
         self.quiet_all = False

mathics/core/expression.py

@@ -13,8 +13,8 @@
     List,
     Optional,
     Sequence,
+    Set,
     Tuple,
-    Type,
     Union,
 )
 
@@ -273,7 +273,7 @@ class Expression(BaseElement, NumericOperators, EvalMixin):
     _sequences: Any
     _cache: Optional[ExpressionCache]
     elements_properties: Optional[ElementsProperties]
-    options: Optional[tuple]
+    options: Optional[Dict[str, Any]]
     pattern_sequence: bool
 
     def __init__(
@@ -535,11 +535,11 @@ def evaluate(
         if evaluation.timeout:
             return None
 
-        expr = self
+        expr: Optional[BaseElement] = self
         reevaluate = True
         limit = None
         iteration = 1
-        names = set()
+        names: Set[str] = set()
         definitions = evaluation.definitions
 
         old_options = evaluation.options
@@ -553,6 +553,8 @@ def evaluate(
         try:
             # Evaluation loop:
             while reevaluate:
+                assert isinstance(expr, EvalMixin)
+
                 # If definitions have not changed in the last evaluation,
                 # then evaluating again will produce the same result
                 if not expr.is_uncertain_final_definitions(definitions):
@@ -702,16 +704,20 @@ def flatten_with_respect_to_head(
         sub_level = level - 1
         do_flatten = False
         for element in self._elements:
-            if element.get_head().sameQ(head) and (
-                not pattern_only or element.pattern_sequence
+            if (
+                isinstance(element, Expression)
+                and element.get_head().sameQ(head)
+                and (not pattern_only or element.pattern_sequence)
             ):
                 do_flatten = True
                 break
         if do_flatten:
-            new_elements = []
+            new_elements: List[BaseElement] = []
             for element in self._elements:
-                if element.get_head().sameQ(head) and (
-                    not pattern_only or element.pattern_sequence
+                if (
+                    isinstance(element, Expression)
+                    and element.get_head().sameQ(head)
+                    and (not pattern_only or element.pattern_sequence)
                 ):
                     new_element = element.flatten_with_respect_to_head(
                         head, pattern_only, callback, level=sub_level
@@ -953,14 +959,16 @@ def get_sort_key(self, pattern_sort=False) -> tuple:
             3: tuple:        list of Elements
             4: 1:        No clue...
             """
-            exps: Dict[str, float] = {}
+            exps: Dict[str, Union[float, complex]] = {}
             head = self._head
             if head is SymbolTimes:
                 for element in self.elements:
                     name = element.get_name()
                     if element.has_form("Power", 2):
                         var = element.get_element(0).get_name()
-                        exp = element.get_element(1).round_to_float()
+                        expr = element.get_element(1)
+                        assert isinstance(expr, (Expression, NumericOperators))
+                        exp = expr.round_to_float()
                         if var and exp is not None:
                             exps[var] = exps.get(var, 0) + exp
                     elif name:
@@ -1042,6 +1050,7 @@ def is_uncertain_final_definitions(self, definitions) -> bool:
 
         if cache.symbols is None:
             cache = self._rebuild_cache()
+            assert cache is not None
 
         return definitions.is_uncertain_final_value(time, cache.symbols)
 
@@ -1123,7 +1132,7 @@ def restructure(self, head, elements, evaluation, structure_cache=None, deps=Non
         s = structure(head, deps, evaluation, structure_cache=structure_cache)
         return s(list(elements))
 
-    def rewrite_apply_eval_step(self, evaluation) -> Tuple["Expression", bool]:
+    def rewrite_apply_eval_step(self, evaluation) -> Tuple[BaseElement, bool]:
         """Perform a single rewrite/apply/eval step of the bigger
         Expression.evaluate() process.
 
@@ -1162,6 +1171,7 @@ def rewrite_apply_eval_step(self, evaluation) -> Tuple["Expression", bool]:
 
         if self.elements_properties is None:
             self._build_elements_properties()
+            assert self.elements_properties is not None
 
         # @timeit
         def eval_elements():
@@ -1804,14 +1814,15 @@ def thread(self, evaluation, head=None) -> Tuple[bool, "Expression"]:
         if head is None:
             head = SymbolList
 
-        items = []
+        prefix: List[BaseElement] = []
+        items: List[List[BaseElement]]
         dim = None
         for element in self._elements:
             if element.get_head().sameQ(head):
                 if dim is None:
                     dim = len(element.get_elements())
                     items = [
-                        (items + [innerelement])
+                        (prefix + [innerelement])
                         for innerelement in element.get_elements()
                     ]
                 elif len(element._elements) != dim:
@@ -1822,7 +1833,7 @@ def thread(self, evaluation, head=None) -> Tuple[bool, "Expression"]:
                         items[index].append(element._elements[index])
             else:
                 if dim is None:
-                    items.append(element)
+                    prefix.append(element)
                 else:
                     for item in items:
                         item.append(element)
@@ -2040,6 +2051,7 @@ def convert_expression_elements(
             elements_properties.is_flat = False
             if converted_elt.elements_properties is None:
                 converted_elt._build_elements_properties()
+                assert converted_elt.elements_properties is not None
 
             if elements_properties.elements_fully_evaluated:
                 elements_properties.elements_fully_evaluated = (