Merge pull request #707 from Mathics3/misc-lint

Ring in 2023!

Author: rocky

mathics/__init__.py

@@ -58,7 +58,7 @@
 
 
 license_string = """\
-Copyright (C) 2011-2022 The Mathics Team.
+Copyright (C) 2011-2023 The Mathics Team.
 This program comes with ABSOLUTELY NO WARRANTY.
 This is free software, and you are welcome to redistribute it
 under certain conditions.

mathics/builtin/assignments/clear.py

@@ -88,7 +88,7 @@ def do_clear(self, definition):
         definition.formatvalues = {}
         definition.nvalues = []
 
-    def apply(self, symbols, evaluation):
+    def eval(self, symbols, evaluation):
         "%(name)s[symbols___]"
         if isinstance(symbols, Symbol):
             symbols = [symbols]
@@ -286,7 +286,7 @@ class Unset(PostfixOperator):
     precedence = 670
     summary_text = "unset a value of the LHS"
 
-    def apply(self, expr, evaluation):
+    def eval(self, expr, evaluation):
         "Unset[expr_]"
 
         head = expr.get_head()

mathics/builtin/atomic/atomic.py

@@ -79,7 +79,7 @@ class Head(Builtin):
 
     summary_text = "find the head of any expression, including an atom"
 
-    def apply(self, expr, evaluation):
+    def eval(self, expr, evaluation):
         "Head[expr_]"
 
         return expr.get_head()

mathics/builtin/atomic/numbers.py

@@ -201,7 +201,7 @@ class Accuracy(Builtin):
 
     summary_text = "find the accuracy of a number"
 
-    def apply(self, z, evaluation):
+    def eval(self, z, evaluation):
         "Accuracy[z_]"
         if isinstance(z, Real):
             if z.is_zero:
@@ -211,8 +211,8 @@ def apply(self, z, evaluation):
             return MachineReal(dps(z.get_precision()) - log10_z)
 
         if isinstance(z, Complex):
-            acc_real = self.apply(z.real, evaluation)
-            acc_imag = self.apply(z.imag, evaluation)
+            acc_real = self.eval(z.real, evaluation)
+            acc_imag = self.eval(z.imag, evaluation)
             if acc_real is SymbolInfinity:
                 return acc_imag
             if acc_imag is SymbolInfinity:
@@ -222,7 +222,7 @@ def apply(self, z, evaluation):
         if isinstance(z, Expression):
             result = None
             for element in z.elements:
-                candidate = self.apply(element, evaluation)
+                candidate = self.eval(element, evaluation)
                 if isinstance(candidate, Real):
                     candidate_f = candidate.to_python()
                     if result is None or candidate_f < result:
@@ -296,7 +296,7 @@ class IntegerExponent(Builtin):
 
     summary_text = "number of trailing 0s in a given base"
 
-    def apply_two_arg_integers(self, n: Integer, b: Integer, evaluation):
+    def eval_two_arg_integers(self, n: Integer, b: Integer, evaluation):
         "IntegerExponent[n_Integer, b_Integer]"
 
         py_n, py_b = n.value, b.value
@@ -313,7 +313,7 @@ def apply_two_arg_integers(self, n: Integer, b: Integer, evaluation):
 
     # FIXME: If WMA supports things other than Integers, the below code might
     # be useful as a starting point.
-    # def apply(self, n: Integer, b: Integer, evaluation):
+    # def eval(self, n: Integer, b: Integer, evaluation):
     #     "IntegerExponent[n_Integer, b_Integer]"
 
     #     py_n, py_b = n.to_python(), b.to_python()
@@ -386,7 +386,7 @@ class IntegerLength(Builtin):
 
     summary_text = "total number of digits in any base"
 
-    def apply(self, n, b, evaluation):
+    def eval(self, n, b, evaluation):
         "IntegerLength[n_, b_]"
 
         n, b = n.get_int_value(), b.get_int_value()
@@ -587,17 +587,17 @@ class RealDigits(Builtin):
 
     summary_text = "digits of a real number"
 
-    def apply_complex(self, n, var, evaluation):
+    def eval_complex(self, n, var, evaluation):
         "%(name)s[n_Complex, var___]"
         return evaluation.message("RealDigits", "realx", n)
 
-    def apply_rational_with_base(self, n, b, evaluation):
+    def eval_rational_with_base(self, n, b, evaluation):
         "%(name)s[n_Rational, b_Integer]"
         # expr = Expression(SymbolRealDigits, n)
         py_n = abs(n.value)
         py_b = b.value
         if check_finite_decimal(n.denominator().get_int_value()) and not py_b % 2:
-            return self.apply_with_base(n, b, evaluation)
+            return self.eval_with_base(n, b, evaluation)
         else:
             exp = int(mpmath.ceil(mpmath.log(py_n, py_b)))
             (head, tails) = convert_repeating_decimal(
@@ -612,12 +612,12 @@ def apply_rational_with_base(self, n, b, evaluation):
             list_expr = ListExpression(*elements)
         return ListExpression(list_expr, Integer(exp))
 
-    def apply_rational_without_base(self, n, evaluation):
+    def eval_rational_without_base(self, n, evaluation):
         "%(name)s[n_Rational]"
 
-        return self.apply_rational_with_base(n, Integer(10), evaluation)
+        return self.eval_rational_with_base(n, Integer(10), evaluation)
 
-    def apply(self, n, evaluation):
+    def eval(self, n, evaluation):
         "%(name)s[n_]"
 
         # Handling the testcases that throw the error message and return the
@@ -626,9 +626,9 @@ def apply(self, n, evaluation):
             return evaluation.message("RealDigits", "ndig", n)
 
         if n.is_numeric(evaluation):
-            return self.apply_with_base(n, from_python(10), evaluation)
+            return self.eval_with_base(n, from_python(10), evaluation)
 
-    def apply_with_base(self, n, b, evaluation, nr_elements=None, pos=None):
+    def eval_with_base(self, n, b, evaluation, nr_elements=None, pos=None):
         "%(name)s[n_?NumericQ, b_Integer]"
 
         expr = Expression(SymbolRealDigits, n)
@@ -739,7 +739,7 @@ def apply_with_base(self, n, b, evaluation, nr_elements=None, pos=None):
         list_expr = ListExpression(*elements)
         return ListExpression(list_expr, Integer(exp))
 
-    def apply_with_base_and_length(self, n, b, length, evaluation, pos=None):
+    def eval_with_base_and_length(self, n, b, length, evaluation, pos=None):
         "%(name)s[n_?NumericQ, b_Integer, length_]"
         elements = []
         if pos is not None:
@@ -748,18 +748,18 @@ def apply_with_base_and_length(self, n, b, length, evaluation, pos=None):
         if not (isinstance(length, Integer) and length.get_int_value() >= 0):
             return evaluation.message("RealDigits", "intnm", expr)
 
-        return self.apply_with_base(
+        return self.eval_with_base(
             n, b, evaluation, nr_elements=length.get_int_value(), pos=pos
         )
 
-    def apply_with_base_length_and_precision(self, n, b, length, p, evaluation):
+    def eval_with_base_length_and_precision(self, n, b, length, p, evaluation):
         "%(name)s[n_?NumericQ, b_Integer, length_, p_]"
         if not isinstance(p, Integer):
             return evaluation.message(
                 "RealDigits", "intm", Expression(SymbolRealDigits, n, b, length, p)
             )
 
-        return self.apply_with_base_and_length(
+        return self.eval_with_base_and_length(
             n, b, length, evaluation, pos=p.get_int_value()
         )
 
@@ -1004,7 +1004,7 @@ class NumericQ(Builtin):
     }
     summary_text = "test whether an expression is a number"
 
-    def apply(self, expr, evaluation):
+    def eval(self, expr, evaluation):
         "NumericQ[expr_]"
         return from_bool(expr.is_numeric(evaluation))
 
@@ -1060,16 +1060,16 @@ class Precision(Builtin):
 
     summary_text = "find the precision of a number"
 
-    def apply(self, z, evaluation):
+    def eval(self, z, evaluation):
         "Precision[z_]"
         if isinstance(z, Real):
             if z.is_zero:
                 return MachineReal0
             return MachineReal(dps(z.get_precision()))
 
         if isinstance(z, Complex):
-            prec_real = self.apply(z.real, evaluation)
-            prec_imag = self.apply(z.imag, evaluation)
+            prec_real = self.eval(z.real, evaluation)
+            prec_imag = self.eval(z.imag, evaluation)
             if prec_real is SymbolInfinity:
                 return prec_imag
             if prec_imag is SymbolInfinity:
@@ -1080,7 +1080,7 @@ def apply(self, z, evaluation):
         if isinstance(z, Expression):
             result = None
             for element in z.elements:
-                candidate = self.apply(element, evaluation)
+                candidate = self.eval(element, evaluation)
                 if isinstance(candidate, Real):
                     candidate_f = candidate.to_python()
                     if result is None or candidate_f < result:

mathics/builtin/base.py

@@ -83,13 +83,13 @@ class Builtin:
     Function application pattern matching
     -------------------------------------
 
-    Method names of a builtin-class that start with the word ``apply`` are evaluation methods that
+    Method names of a builtin-class that start with the word ``eval`` are evaluation methods that
     will get called when the docstring of that method matches the expression to be evaluated.
 
     For example:
 
     ```
-        def apply(x, evaluation):
+        def eval(x, evaluation):
              "F[x_Real]"
              return Expression(Symbol("G"), x*2)
     ```
@@ -102,16 +102,16 @@ def apply(x, evaluation):
     ``x``. The method must also have an evaluation parameter, and may
     have an optional `options` parameter.
 
-    If the ``apply*`` method returns ``None``, the replacement fails, and the expression keeps its original form.
+    If the ``eval*`` method returns ``None``, the replacement fails, and the expression keeps its original form.
 
     For rules including ``OptionsPattern``
     ```
-        def apply_with_options(x, evaluation, options):
+        def eval_with_options(x, evaluation, options):
              '''F[x_Real, OptionsPattern[]]'''
              ...
     ```
     the options are stored as a dictionary in the last parameter. For example, if the rule is applied to ``F[x, Method->Automatic]``
-    the expression is replaced by the output of ``apply_with_options(x, evaluation, {"System`Method": Symbol("Automatic")})
+    the expression is replaced by the output of ``eval_with_options(x, evaluation, {"System`Method": Symbol("Automatic")})
 
     The method ``contribute`` stores the definition of the  ``Builtin`` ` `Symbol`` into a set of ``Definitions``. For example,
 
@@ -417,7 +417,7 @@ def get_option(options, name, evaluation, pop=False):
     def _get_unavailable_function(self) -> Optional[Callable]:
         """
         If some of the required libraries for a symbol are not available,
-        returns a default function that override the ``apply_`` methods
+        returns a default function that override the ``eval_`` methods
         of the class. Otherwise, returns ``None``.
         """
 
@@ -487,7 +487,7 @@ class AtomBuiltin(Builtin):
     have the Builtin function/variable/object properties.
     """
 
-    # allows us to define apply functions, rules, messages, etc. for Atoms
+    # allows us to define eval functions, rules, messages, etc. for Atoms
     # which are by default not in the definitions' contribution pipeline.
     # see Image[] for an example of this.
 
@@ -613,7 +613,7 @@ def __init__(self, *args, **kwargs):
 
 
 class Test(Builtin):
-    def apply(self, expr, evaluation) -> Optional[Symbol]:
+    def eval(self, expr, evaluation) -> Optional[Symbol]:
         "%(name)s[expr_]"
         test_expr = self.test(expr)
         return None if test_expr is None else from_bool(bool(test_expr))
@@ -633,7 +633,7 @@ def eval(self, z, evaluation):
         # Note: we omit a docstring here, so as not to confuse
         # function signature collector ``contribute``.
 
-        # Generic apply method that uses the class sympy_name.
+        # Generic eval method that uses the class sympy_name.
         # to call the corresponding sympy function. Arguments are
         # converted to python and the result is converted from sympy
         #

mathics/builtin/files_io/importexport.py

@@ -1250,7 +1250,7 @@ class URLFetch(Builtin):
     # = ...
     """
 
-    summary_text = "fetch data form an URL"
+    summary_text = "fetch data from a URL"
     messages = {
         "httperr": "`1` could not be retrieved; `2`.",
     }

mathics/doc/latex/Makefile

@@ -1,4 +1,4 @@
-.PHONY: all clean doc doc-data latex texdoc
+.PHONY: all clean doc doc-data latex pdf texdoc
 
 PYTHON ?= python
 XETEX ?= xelatex
@@ -37,7 +37,7 @@ documentation.tex: $(DOC_TEX_DATA_PCL)
 	$(PYTHON) ./doc2latex.py
 
 #: Same as mathics.pdf
-latex: mathics.pdf
+pdf latex: mathics.pdf
 
 #: Remove all auto-generated files
 clean: