mathjson-solver 1.6.1__tar.gz → 1.8.0__tar.gz

{mathjson-solver-1.6.1/src/mathjson_solver.egg-info → mathjson_solver-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mathjson-solver
-Version: 1.6.1
+Version: 1.8.0
 Summary: Utilities for MathJSON evaluation
 Home-page: https://github.com/LongenesisLtd/mathjson-solver
 Author: Martins Mednis

{mathjson-solver-1.6.1 → mathjson_solver-1.8.0}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = mathjson-solver
-version = 1.6.1
+version = 1.8.0
 author = Martins Mednis
 author_email = mrt@mednis.info
 description = Utilities for MathJSON evaluation

{mathjson-solver-1.6.1 → mathjson_solver-1.8.0}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setuptools.setup(
     name="mathjson-solver",
-    version="1.6.1",
+    version="1.8.0",
     author="Martins Mednis",
     author_email="mrt@mednis.info",
     description="Utilities for MathJSON evaluation",

{mathjson-solver-1.6.1 → mathjson_solver-1.8.0}/src/mathjson_solver/__init__.py

@@ -1,2 +1,2 @@
 from .__main__ import create_mathjson_solver as create_solver
-from .__main__ import MathJSONException
+from .__main__ import MathJSONException, extract_variables

{mathjson-solver-1.6.1 → mathjson_solver-1.8.0}/src/mathjson_solver/__main__.py

@@ -1,8 +1,11 @@
 import numbers
+from typing import Union
 from functools import reduce
 import math
 from copy import deepcopy
 from statistics import median
+import logging
+import traceback
 
 
 class MathJSONException(Exception):
@@ -58,36 +61,52 @@ def create_mathjson_solver(solver_parameters):
             def Arr(s):
                 return s
 
-            @requires_array
+            # @requires_array
             def Max(s):
-                return max([f(x, c) for x in s[1][1:]])
+                if isinstance(s[1], str):
+                    return max([f(x, c) for x in f(s[1], c) if is_numeric(f(x, c))])
+                else:
+                    return max([f(x, c) for x in s[1][1:] if is_numeric(f(x, c))])
 
-            @requires_array
+            # @requires_array
             def Min(s):
-                return min([f(x, c) for x in s[1][1:]])
+                if isinstance(s[1], str):
+                    return min([f(x, c) for x in f(s[1], c) if is_numeric(f(x, c))])
+                else:
+                    return min([f(x, c) for x in s[1][1:] if is_numeric(f(x, c))])
 
-            @requires_array
             def Average(s):
-                s_ = [float(f(x, c)) for x in s[1][1:] if is_numeric(f(x, c))]
+                if isinstance(s[1], str):
+                    # A reference to "answer" has been passed
+                    s_ = [float(f(x, c)) for x in f(s[1], c) if is_numeric(f(x, c))]
+                else:
+                    s_ = [float(f(x, c)) for x in s[1][1:] if is_numeric(f(x, c))]
                 # print(f"{s_} {sum(s_)}/{len(s_)}")
                 try:
                     return sum(s_) / len(s_)
                 except ZeroDivisionError:
                     return None
 
-            @requires_array
+            # @requires_array
             def Median(s):
-                return median([f(x, c) for x in s[1][1:]])
+                if isinstance(s[1], str):
+                    return median([f(x, c) for x in f(s[1], c) if is_numeric(f(x, c))])
+                else:
+                    return median([f(x, c) for x in s[1][1:] if is_numeric(f(x, c))])
 
-            @requires_array
+            # @requires_array
             def Length(s):
-                return len([f(x, c) for x in s[1][1:]])
+                if isinstance(s[1], str):
 
-            @requires_array
+                    return len([x for x in f(s[1], c)][1:])
+                else:
+                    return len([x for x in s[1][1:]])
+
+            # @requires_array
             def Any(s):
                 return any([f(x, c) for x in s[1][1:]])
 
-            @requires_array
+            # @requires_array
             def All(s):
                 return all([f(x, c) for x in s[1][1:]])
 
@@ -110,7 +129,7 @@ def create_mathjson_solver(solver_parameters):
                 for x in s[3:]:
                     if len(x) != 2:
                         raise ValueError(
-                            f"Case of 'Switch' should have exactly two parameters"
+                            "Case of 'Switch' should have exactly two parameters"
                         )
                     if expression == f(x[0], c):
                         return f(x[1], c)
@@ -119,39 +138,50 @@ def create_mathjson_solver(solver_parameters):
 
             def If(s):
                 if len(s) < 3:
-                    raise ValueError(f"Wrong parameters for 'If'")
+                    raise ValueError("Wrong parameters for 'If'")
                 for x in s[1:-1]:
                     if len(x) != 2:
-                        raise ValueError(f"Wrong if or elif in 'If'")
-                    if f(x[0], c):
-                        return f(x[1], c)
+                        raise ValueError("Wrong if or elif in 'If'")
+                    try:
+                        if f(x[0], c):
+                            try:
+                                return f(x[1], c)
+                            except MathJSONException:
+                                logging.error(
+                                    "MathJSONException: %s", traceback.format_exc()
+                                )
+                                continue
+                    except MathJSONException:
+                        logging.error("MathJSONException: %s", traceback.format_exc())
+                        return f(s[-1], c)  # return default value (else)
+
                 return f(s[-1], c)
 
             def In(s):
                 if len(s) != 3:
-                    raise ValueError(f"Wrong parameters for 'In'")
-                if type(s[2]) == list and s[2][0] == "Array":
+                    raise ValueError("Wrong parameters for 'In'")
+                if isinstance(s[2], list) and s[2][0] == "Array":
                     return f(s[1], c) in [f(x, c) for x in s[2][1:]]
 
-                elif type(s[2]) == str:
+                elif isinstance(s[2], str):
                     return f(s[1], c) in f(s[2], c)
                 else:
                     raise ValueError(
-                        f"Wrong parameters for 'In'. Parameter 2 must be a list."
+                        "Wrong parameters for 'In'. Parameter 2 must be a list."
                     )
 
             def Not_in(s):
                 return not In(s)
 
             def Contains_any_of(s):
-                if type(s[1]) == list and s[1][0] == "Array":
+                if isinstance(s[1], list) and s[1][0] == "Array":
                     list1 = [f(x, c) for x in s[1][1:]]
-                elif type(s[1]) == str:
+                elif isinstance(s[1], str):
                     list1 = f(s[1], c)
 
-                if type(s[2]) == list and s[2][0] == "Array":
+                if isinstance(s[2], list) and s[2][0] == "Array":
                     list2 = [f(x, c) for x in s[2][1:]]
-                elif type(s[2]) == str:
+                elif isinstance(s[2], str):
                     list2 = f(s[2], c)
 
                 if any(x in list1 for x in list2):
@@ -159,14 +189,14 @@ def create_mathjson_solver(solver_parameters):
                 return False
 
             def Contains_all_of(s):
-                if type(s[1]) == list and s[1][0] == "Array":
+                if isinstance(s[1], list) and s[1][0] == "Array":
                     list1 = [f(x, c) for x in s[1][1:]]
-                elif type(s[1]) == str:
+                elif isinstance(s[1], str):
                     list1 = f(s[1], c)
 
-                if type(s[2]) == list and s[2][0] == "Array":
+                if isinstance(s[2], list) and s[2][0] == "Array":
                     list2 = [f(x, c) for x in s[2][1:]]
-                elif type(s[2]) == str:
+                elif isinstance(s[2], str):
                     list2 = f(s[2], c)
 
                 if all(x in list1 for x in list2):
@@ -178,7 +208,7 @@ def create_mathjson_solver(solver_parameters):
 
             def Str(s):
                 if len(s) < 2:
-                    raise ValueError(f"Wrong parameters for 'Str'")
+                    raise ValueError("Wrong parameters for 'Str'")
                 return f"{f(s[1])}"
 
             def Not(s):
@@ -213,9 +243,11 @@ def create_mathjson_solver(solver_parameters):
                 "LessEqual": lambda s: f(s[1], c) <= f(s[2], c),
                 "NotEqual": lambda s: f(s[1], c) != f(s[2], c),
                 "Abs": lambda s: abs(f(s[1], c)),
-                "Round": lambda s: round(f(s[1], c), f(s[2], c))
-                if len(s) == 3
-                else int(round(f(s[1], c))),
+                "Round": lambda s: (
+                    round(f(s[1], c), f(s[2], c))
+                    if len(s) == 3
+                    else int(round(f(s[1], c)))
+                ),
                 "Max": Max,
                 "Min": Min,
                 "Average": Average,
@@ -237,6 +269,7 @@ def create_mathjson_solver(solver_parameters):
                 "Float": Float,
                 "Str": Str,
                 "Not": Not,
+                "IsDefined": lambda s: s[1] in c,
             }
             if s[0] in constructs:
                 try:
@@ -253,6 +286,77 @@ def create_mathjson_solver(solver_parameters):
         elif s in c:
             return f(c[s], c)
         else:
+            # raise KeyError(f"Parameter '{s}' is not defined")
             return s
 
     return f
+
+
+def extract_variables(s: Union[list, int, float, str], li: set, ignore_list: set):
+    constructs = [
+        "Add",
+        "Sum",
+        "Subtract",
+        "Constants",
+        "Switch",
+        "If",
+        "Multiply",
+        "Divide",
+        "Negate",
+        "Power",
+        "Root",
+        "Sqrt",
+        "Square",
+        "Exp",
+        "Log",
+        "Log2",
+        "Log10",
+        "Equal",
+        "Greater",
+        "GreaterEqual",
+        "Less",
+        "LessEqual",
+        "NotEqual",
+        "Abs",
+        "Round",
+        "Max",
+        "Min",
+        "Average",
+        "Median",
+        "Length",
+        "Any",
+        "All",
+        "Array",
+        "In",
+        "Not_in",
+        "Contains_any_of",
+        "Contains_all_of",
+        "Contains_none_of",
+        "NotIn",
+        "ContainsAnyOf",
+        "ContainsAllOf",
+        "ContainsNoneOf",
+        "Int",
+        "Float",
+        "Str",
+        "Not",
+        "IsDefined",
+    ]
+    if isinstance(s, str):
+        if s in ignore_list:
+            return li
+        if s not in constructs:
+            li.add(s)
+        return li
+    elif isinstance(s, list):
+        if s[0] == "Constants":
+            for x in s[1:-1]:
+                ignore_list.add(x[0])
+                li.update(extract_variables(x[1], li, ignore_list))
+            li.update(extract_variables(x[-1], li, ignore_list))
+        else:
+            for x in s[1:]:
+                li.update(extract_variables(x, li, ignore_list))
+        return li
+    else:
+        return li

{mathjson-solver-1.6.1 → mathjson_solver-1.8.0/src/mathjson_solver.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mathjson-solver
-Version: 1.6.1
+Version: 1.8.0
 Summary: Utilities for MathJSON evaluation
 Home-page: https://github.com/LongenesisLtd/mathjson-solver
 Author: Martins Mednis

{mathjson-solver-1.6.1 → mathjson_solver-1.8.0}/tests/test_with_pytest.py

@@ -5,7 +5,7 @@ import re
 
 sys.path.append(os.path.join(os.path.dirname(__file__), "../src/"))
 
-from mathjson_solver import create_solver, MathJSONException
+from mathjson_solver import create_solver, MathJSONException, extract_variables
 
 
 @pytest.mark.parametrize(
@@ -45,10 +45,18 @@ from mathjson_solver import create_solver, MathJSONException
         ({"color": "green"}, ["Switch", "color", 0, ["blue", 10], ["red", 30]], 0),
         ({"color": "green"}, ["Switch", "undefined", 0, ["blue", 10], ["red", 30]], 0),
         ({}, ["If", [["Equal", 1, 0], 10], [["Equal", 2, 2], 20], 9000], 20),
+        ({"a": 10, "b": 10}, ["If", [["Equal", "a", "b"], 10], 9000], 10),
+        ({"a": 10, "b": 20}, ["If", [["Equal", "a", "b"], 10], 9000], 9000),
+        ({"a": 10}, ["If", [["Equal", "a", "b"], 10], 9000], 9000),
+        ({"a": 10}, ["If", [["Equal", "a", ["Sum", 1, "b"]], 10], 9000], 9000),
         ({}, ["Array", 1, 2, 3, 5, 2], ["Array", 1, 2, 3, 5, 2]),
         ({}, ["Max", ["Array", 1, 2, 3, 5, 2]], 5),
         ({}, ["Max", ["Array", 1, 2, ["Sum", 2, 4, 3], 5, 2]], 9),
+        ({"a": ["Array", 1, 2, 3, 5, 2]}, ["Max", "a"], 5),
+        ({}, ["Min", ["Array", 1, 2, 3, 5, 2]], 1),
+        ({"a": ["Array", 2, 1, 3, 5, 2]}, ["Min", "a"], 1),
         ({}, ["Median", ["Array", 1, 2, 3, 5, 2]], 2),
+        ({"a": ["Array", 1, 2, 3, 5, 2]}, ["Median", "a"], 2),
         ({}, ["Average", ["Array", 1, 2, 3, 5, 2]], 2.6),
         (
             {},
@@ -76,8 +84,10 @@ from mathjson_solver import create_solver, MathJSONException
             5.0,
         ),
         ({}, ["Average", ["Array"]], None),
+        ({"a": ["Array", 2, 8]}, ["Average", "a"], 5),
         ({"a": 10, "b": 20}, ["Average", ["Array", "a", "b"]], 15),
         ({}, ["Length", ["Array", 1, 2, 3, 5, 2, 9]], 6),
+        ({"a": ["Array", 1, 2, 3, 5, 2, 9]}, ["Length", "a"], 6),
         ({}, ["Length", ["Array"]], 0),
         ({}, ["Int", "12"], 12),
         ({}, ["Int", "12.2"], 12),
@@ -202,3 +212,26 @@ def test_handle_exception():
         assert True
     else:
         assert False
+
+
+@pytest.mark.parametrize(
+    "parameters, expression, expected_result",
+    [
+        ({}, ["Add", 2, 4, 3], set()),
+        ({}, ["Sum", 2, "a", 3], set(["a"])),
+        ({"a": 5}, ["Sum", 2, "a", 3], set()),
+        ({"a": 5, "b": 6}, ["Sum", 2, "a", "c"], set(["c"])),
+        ({}, ["Constants", ["c", 1], ["d", ["Add", 2, "a"]], "d"], set(["a"])),
+        # Now with "ugly" variables that mimic the ones used for deep referencing.
+        (
+            {},
+            ["Add", "[slug1][0][question1]", "y", 4, "[slug1][-3:-1][question1]"],
+            set(["[slug1][0][question1]", "y", "[slug1][-3:-1][question1]"]),
+        ),
+    ],
+)
+def test_extract_variables(parameters, expression, expected_result):
+    assert (
+        extract_variables(expression, set(), set([x for x in parameters.keys()]))
+        == expected_result
+    )