mathjson-solver 1.19.0__tar.gz → 1.20.0__tar.gz

{mathjson_solver-1.19.0 → mathjson_solver-1.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathjson-solver
-Version: 1.19.0
+Version: 1.20.0
 Summary: Utilities for MathJSON evaluation
 Project-URL: Homepage, https://github.com/LongenesisLtd/mathjson-solver
 Project-URL: Bug Tracker, https://github.com/LongenesisLtd/mathjson-solver/issues

{mathjson_solver-1.19.0 → mathjson_solver-1.20.0}/docs/README.md

@@ -309,6 +309,26 @@ The following example has two constants defined - `x=10` and `y=20`. Then the su
 ]
 ```
 
+#### Null propagation
+
+If a constant definition raises an exception (e.g. because a referenced parameter is missing), that constant is set to `None` instead of crashing the entire expression. This allows `If` to select the valid branch at runtime:
+
+```python
+# With parameters = {"new_val": 22.5}   (old_val is missing)
+[
+    "Constants",
+    ["c_old", ["Divide", "old_val", 2]],   # raises → None
+    ["c_new", ["Divide", "new_val", 2]],   # 11.25
+    ["If",
+        [["Greater", "c_new", 0], "c_new"],
+        "c_old"
+    ]
+]
+# Result: 11.25  (c_old was never needed)
+```
+
+A constant that failed to compute can be detected with `["Equal", "c_old", None]`.
+
 ### If Statement
 ```
 [
@@ -779,13 +799,33 @@ Converts a value to a string representation.
 ```
 
 ### IsDefined
-**Note: This is a placeholder function for future implementation.** Supposed to check if a parameter name exists in the parameters dictionary.
+Returns `True` if the given name exists as a solver parameter or as a `Constants`-defined constant, `False` otherwise.
 
 ```python
 # With parameters = {"a": 12}
+["IsDefined", "a"]                # True
 ["IsDefined", "b"]                # False
+
+# Inside Constants
+["Constants", ["x", 5], ["IsDefined", "x"]]   # True
+["Constants", ["x", 5], ["IsDefined", "y"]]   # False
+```
+
+### IsUndefined
+The logical complement of `IsDefined`. Returns `True` if the name is not defined, `False` if it is.
+
+```python
+# With parameters = {"a": 12}
+["IsUndefined", "a"]              # False
+["IsUndefined", "b"]              # True
+
+# Inside Constants
+["Constants", ["x", 5], ["IsUndefined", "x"]]   # False
+["Constants", ["x", 5], ["IsUndefined", "y"]]   # True
 ```
 
+Note: when a `Constants` definition raises an exception, that constant is set to `None` (see null-propagation below). In that case `IsUndefined` still returns `False` — the name is defined, just with a `None` value. Use `["Equal", "val", None]` to test for that explicitly.
+
 ---
 
 ## Date and Time Functions
@@ -1166,6 +1206,7 @@ Finds the interval index where a value falls within a sorted array of bounds. Re
 - [Float](#float) - Convert to float
 - [Str](#str) - Convert to string
 - [IsDefined](#isdefined) - Check if defined
+- [IsUndefined](#isundefined) - Check if not defined
 
 ### Date and Time Functions
 - [Today](#today) - Current date (ISO string)

{mathjson_solver-1.19.0 → mathjson_solver-1.20.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mathjson-solver"
-version = "1.19.0"
+version = "1.20.0"
 authors = [{name = "Martins Mednis", email = "mrt@mednis.info"}]
 description = "Utilities for MathJSON evaluation"
 readme = "README.md"

{mathjson_solver-1.19.0 → mathjson_solver-1.20.0}/src/mathjson_solver/__main__.py

@@ -430,7 +430,10 @@ def create_mathjson_solver(solver_parameters):
 
             def Constants(s):
                 for x in s[1:-1]:
-                    c[x[0]] = f(x[1], c)
+                    try:
+                        c[x[0]] = f(x[1], c)
+                    except Exception:
+                        c[x[0]] = None
                 return f(s[-1], c)
 
             def Switch(s):
@@ -652,8 +655,10 @@ def create_mathjson_solver(solver_parameters):
             #     lambda s: f"{f(s[1], c)}" == f"{f(s[2], c)}",
 
             def IsDefined(s):
-                # Todo: This does not work
-                return s[1] in c.keys()
+                return s[1] in solver_parameters or s[1] in c
+
+            def IsUndefined(s):
+                return not IsDefined(s)
 
             def Greater(s):
                 v1, v2 = comparison_safe_converter_for_pairs(f(s[1], c), f(s[2], c))
@@ -1101,6 +1106,7 @@ def create_mathjson_solver(solver_parameters):
                 "Not": Not,
                 # "IsDefined": lambda s: s[1] in c,
                 "IsDefined": IsDefined,
+                "IsUndefined": IsUndefined,
                 "Map": Map,
                 "StrictMap": StrictMap,
                 "Filter": Filter,
@@ -1230,6 +1236,7 @@ def extract_variables(s: Union[list, int, float, str], li: set, ignore_list: set
         "Str",
         "Not",
         "IsDefined",
+        "IsUndefined",
         "Map",
         "HasMatchingSublist",
         "Strptime",

{mathjson_solver-1.19.0 → mathjson_solver-1.20.0}/tests/test_with_pytest.py

@@ -11,8 +11,12 @@ from mathjson_solver import create_solver
 @pytest.mark.parametrize(
     "parameters, expression, expected_result",
     [
-        # ({"a": 12}, ["IsDefined", "a"], True),
+        ({"a": 12}, ["IsDefined", "a"], True),
         ({"a": 12}, ["IsDefined", "b"], False),
+        ({}, ["Constants", ["x", 5], ["IsDefined", "x"]], True),
+        ({"a": 12}, ["IsUndefined", "a"], False),
+        ({"a": 12}, ["IsUndefined", "b"], True),
+        ({}, ["Constants", ["x", 5], ["IsUndefined", "x"]], False),
         ({}, ["Abs", -3.5], 3.5),
         ({}, ["Round", -5.123456, 2], -5.12),
         ({}, ["Round", -5.123456, 0], -5),
@@ -21,6 +25,18 @@ from mathjson_solver import create_solver
         ({}, ["Constants", ["a", 1], ["b", 2], "a"], 1),
         ({}, ["Constants", ["a", 1], ["b", 2], ["c", 100], ["Sum", "a", "b"]], 3),
         ({}, ["Constants", ["a", 1], ["b", ["Add", 2, "a"]], "b"], 3),
+        # Constants null-propagation: uncomputable constant becomes None,
+        # allowing If to select the computable branch.
+        (
+            {"x": 10},
+            ["Constants", ["good", "x"], ["bad", ["Divide", "missing", 2]], ["If", [["Greater", "good", 0], "good"], "bad"]],
+            10,
+        ),
+        (
+            {"x": 10},
+            ["Constants", ["bad", ["Divide", "missing", 2]], ["good", "x"], ["If", [["Greater", "good", 0], "good"], "bad"]],
+            10,
+        ),
         ({"x": 1}, ["Add", 2, "x"], 3),
         ({"value": 1}, ["Switch", "value", 0, [1, 11], [2, 22]], 11),
         ({"value": 3}, ["Switch", "value", 0, [1, 11], [2, 22]], 0),