mathjson-solver 1.17.0__tar.gz → 1.18.0__tar.gz

{mathjson_solver-1.17.0/src/mathjson_solver.egg-info → mathjson_solver-1.18.0}/PKG-INFO

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

{mathjson_solver-1.17.0 → mathjson_solver-1.18.0}/setup.cfg

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

{mathjson_solver-1.17.0 → mathjson_solver-1.18.0}/setup.py

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

{mathjson_solver-1.17.0 → mathjson_solver-1.18.0}/src/mathjson_solver/__main__.py

@@ -17,6 +17,22 @@ except ImportError:
 NoneType = type(None)
 
 
+def _try_parse_datetime(value):
+    """Try to parse a string as datetime or date. Returns original value if not parseable."""
+    if isinstance(value, (datetime.datetime, datetime.date)):
+        return value
+    if isinstance(value, str):
+        try:
+            return datetime.datetime.fromisoformat(value)
+        except ValueError:
+            pass
+        try:
+            return datetime.date.fromisoformat(value)
+        except ValueError:
+            pass
+    return value
+
+
 # def find_interpolation_bounds(
 #     l: list, target: int | float
 # ) -> Union[Union[int, float], tuple[Union[int, float], Union[int, float]]]:
@@ -294,16 +310,19 @@ def create_mathjson_solver(solver_parameters):
                     if i == 0:
                         tmp = res
                     else:
+                        # Handle datetime string + timedelta
+                        if isinstance(res, datetime.timedelta):
+                            tmp = _try_parse_datetime(tmp)
+                        elif isinstance(tmp, datetime.timedelta):
+                            res = _try_parse_datetime(res)
                         try:
                             tmp = tmp + res
                         except TypeError:
                             pass
 
-                    # if isinstance(res, list):
-                    #     l_res.append(sum([xx for xx in res[1:]]))
-                    # else:
-                    #     l_res.append(res)
-
+                # Convert datetime result back to string
+                if isinstance(tmp, (datetime.datetime, datetime.date)):
+                    return tmp.isoformat()
                 return tmp
 
                 # tmp = 0
@@ -334,6 +353,22 @@ def create_mathjson_solver(solver_parameters):
                         l_res.append(res)
                 return Add(l_res)
 
+            def Subtract(s):
+                values = [f(x, c) for x in s[1:]]
+                # Convert datetime strings if we're dealing with timedelta
+                converted = []
+                for i, v in enumerate(values):
+                    if isinstance(v, datetime.timedelta):
+                        converted.append(v)
+                    elif any(isinstance(other, datetime.timedelta) for other in values):
+                        converted.append(_try_parse_datetime(v))
+                    else:
+                        converted.append(v)
+                result = reduce(lambda a, b: a - b, converted)
+                if isinstance(result, (datetime.datetime, datetime.date)):
+                    return result.isoformat()
+                return result
+
             def Max(s):
                 if isinstance(s[1], str):
                     return max([f(x, c) for x in f(s[1], c) if is_numeric(f(x, c))])
@@ -370,10 +405,16 @@ def create_mathjson_solver(solver_parameters):
                     return len([x for x in s[1][1:]])
 
             def Any(s):
-                return any([f(x, c) for x in s[1][1:]])
+                evaluated = f(s[1], c)
+                if isinstance(evaluated, list) and evaluated[0] == "Array":
+                    return any([f(x, c) for x in evaluated[1:]])
+                raise ValueError("Parameter 1 must be an array.")
 
             def All(s):
-                return all([f(x, c) for x in s[1][1:]])
+                evaluated = f(s[1], c)
+                if isinstance(evaluated, list) and evaluated[0] == "Array":
+                    return all([f(x, c) for x in evaluated[1:]])
+                raise ValueError("Parameter 1 must be an array.")
 
             def Int(s):
                 try:
@@ -572,18 +613,18 @@ def create_mathjson_solver(solver_parameters):
             def Strptime(s):
                 datetime_str = f(s[1], c)
                 parameters = f(s[2], c)
-                return datetime.datetime.strptime(datetime_str, parameters)
+                return datetime.datetime.strptime(datetime_str, parameters).isoformat()
 
             def Strftime(s):
-                dt = f(s[1], c)
+                dt = _try_parse_datetime(f(s[1], c))
                 parameters = f(s[2], c)
                 return dt.strftime(parameters)
 
             def Now(s):
-                return datetime.datetime.now()
+                return datetime.datetime.now().isoformat()
 
             def Today(s):
-                return datetime.date.today()
+                return datetime.date.today().isoformat()
 
             def TimeDeltaDays(s):
                 return datetime.timedelta(days=f(s[1], c))
@@ -994,9 +1035,7 @@ def create_mathjson_solver(solver_parameters):
             constructs = {
                 "Sum": Sum,
                 "Add": Add,
-                "Subtract": lambda s: reduce(
-                    lambda a, b: a - b, [f(x, c) for x in s[1:]]
-                ),
+                "Subtract": Subtract,
                 "Constants": Constants,
                 "Switch": Switch,
                 "StrictSwitch": StrictSwitch,

{mathjson_solver-1.17.0 → mathjson_solver-1.18.0/src/mathjson_solver.egg-info}/PKG-INFO

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

{mathjson_solver-1.17.0 → mathjson_solver-1.18.0}/src/mathjson_solver.egg-info/SOURCES.txt

@@ -12,16 +12,13 @@ src/mathjson_solver.egg-info/top_level.txt
 tests/test_TrapezoidalIntegratel.py
 tests/test_atindex.py
 tests/test_cumulative.py
+tests/test_datetime.py
 tests/test_equal.py
 tests/test_exceptions.py
 tests/test_extract_variables.py
 tests/test_findinterval.py
 tests/test_gail_model.py
-tests/test_gail_model_nci_validated_no_beta.py
-tests/test_gail_model_nci_validated_with_beta.py
 tests/test_interpolate.py
-tests/test_nci_discrete_implementation_no_beta.py
-tests/test_nci_discrete_implementation_with_beta.py
 tests/test_range.py
 tests/test_reduce_simple.py
 tests/test_scalars.py

mathjson_solver-1.18.0/tests/test_datetime.py

@@ -0,0 +1,219 @@
+import sys
+import os
+import pytest
+import datetime
+
+sys.path.append(os.path.join(os.path.dirname(__file__), "../src/"))
+
+from mathjson_solver import create_solver
+
+
+class TestDatetimeReturnTypes:
+    """Test that datetime functions return strings by default."""
+
+    def test_today_returns_string(self):
+        solver = create_solver({})
+        result = solver(["Today"])
+        assert isinstance(result, str)
+        assert result == datetime.date.today().isoformat()
+
+    def test_now_returns_string(self):
+        solver = create_solver({})
+        result = solver(["Now"])
+        assert isinstance(result, str)
+        # Check format is ISO datetime (contains T)
+        assert "T" in result
+
+    def test_strptime_returns_string(self):
+        solver = create_solver({})
+        result = solver(["Strptime", "2025-01-10T10:05", "%Y-%m-%dT%H:%M"])
+        assert isinstance(result, str)
+        assert result == "2025-01-10T10:05:00"
+
+
+class TestDatetimeArithmetic:
+    """Test datetime arithmetic with string inputs/outputs."""
+
+    def test_today_plus_timedelta_returns_string(self):
+        solver = create_solver({})
+        result = solver(["Add", ["Today"], ["TimeDeltaDays", 7]])
+        assert isinstance(result, str)
+        expected = (datetime.date.today() + datetime.timedelta(days=7)).isoformat()
+        # Result includes time component since date becomes datetime after arithmetic
+        assert result.startswith(expected) or "T" in result
+
+    def test_today_minus_timedelta_returns_string(self):
+        solver = create_solver({})
+        result = solver(["Subtract", ["Today"], ["TimeDeltaDays", 3]])
+        assert isinstance(result, str)
+
+    def test_now_plus_timedelta_returns_string(self):
+        solver = create_solver({})
+        result = solver(["Add", ["Now"], ["TimeDeltaHours", 2]])
+        assert isinstance(result, str)
+        assert "T" in result
+
+    def test_strptime_plus_timedelta_days(self):
+        solver = create_solver({})
+        result = solver([
+            "Strftime",
+            ["Add", ["Strptime", "2025-01-10T10:05", "%Y-%m-%dT%H:%M"], ["TimeDeltaDays", 3]],
+            "%d",
+        ])
+        assert result == "13"
+
+    def test_strptime_minus_timedelta_days(self):
+        solver = create_solver({})
+        result = solver([
+            "Strftime",
+            ["Subtract", ["Strptime", "2025-01-10T10:05", "%Y-%m-%dT%H:%M"], ["TimeDeltaDays", 3]],
+            "%d",
+        ])
+        assert result == "07"
+
+    def test_strptime_plus_timedelta_minutes(self):
+        solver = create_solver({})
+        result = solver([
+            "Strftime",
+            ["Add", ["Strptime", "2025-01-10T10:05", "%Y-%m-%dT%H:%M"], ["TimeDeltaMinutes", 5]],
+            "%M",
+        ])
+        assert result == "10"
+
+    def test_strptime_plus_timedelta_hours(self):
+        solver = create_solver({})
+        result = solver([
+            "Strftime",
+            ["Add", ["Strptime", "2025-01-10T10:05", "%Y-%m-%dT%H:%M"], ["TimeDeltaHours", 2]],
+            "%H",
+        ])
+        assert result == "12"
+
+    def test_strptime_plus_timedelta_weeks(self):
+        solver = create_solver({})
+        result = solver([
+            "Strftime",
+            ["Add", ["Strptime", "2025-01-10T10:05", "%Y-%m-%dT%H:%M"], ["TimeDeltaWeeks", 1]],
+            "%d",
+        ])
+        assert result == "17"
+
+
+class TestStrftime:
+    """Test Strftime with various inputs."""
+
+    def test_strftime_with_strptime(self):
+        solver = create_solver({})
+        result = solver(["Strftime", ["Strptime", "2025-01-10T10:05", "%Y-%m-%dT%H:%M"], "%Y"])
+        assert result == "2025"
+
+    def test_strftime_with_today(self):
+        solver = create_solver({})
+        result = solver(["Strftime", ["Today"], "%Y"])
+        assert result == str(datetime.date.today().year)
+
+    def test_strftime_with_now(self):
+        solver = create_solver({})
+        result = solver(["Strftime", ["Now"], "%Y"])
+        assert result == str(datetime.datetime.now().year)
+
+    def test_strftime_accepts_string_datetime(self):
+        """Test that Strftime can parse ISO string input."""
+        solver = create_solver({})
+        result = solver(["Strftime", "2025-06-15T14:30:00", "%Y-%m-%d"])
+        assert result == "2025-06-15"
+
+    def test_strftime_accepts_string_date(self):
+        """Test that Strftime can parse ISO date string input."""
+        solver = create_solver({})
+        result = solver(["Strftime", "2025-06-15", "%Y-%m-%d"])
+        assert result == "2025-06-15"
+
+    def test_strftime_full_format(self):
+        solver = create_solver({})
+        result = solver(["Strftime", "2025-06-15T14:30:45", "%Y-%m-%d %H:%M:%S"])
+        assert result == "2025-06-15 14:30:45"
+
+
+class TestDatetimeChaining:
+    """Test complex datetime operation chains."""
+
+    def test_add_then_strftime(self):
+        solver = create_solver({})
+        result = solver([
+            "Strftime",
+            ["Add", ["Today"], ["TimeDeltaDays", 10]],
+            "%Y-%m-%d",
+        ])
+        expected = (datetime.date.today() + datetime.timedelta(days=10)).strftime("%Y-%m-%d")
+        assert result == expected
+
+    def test_subtract_then_strftime(self):
+        solver = create_solver({})
+        result = solver([
+            "Strftime",
+            ["Subtract", ["Now"], ["TimeDeltaHours", 5]],
+            "%H",
+        ])
+        # Just verify it returns a valid hour string
+        assert result.isdigit()
+        assert 0 <= int(result) <= 23
+
+    def test_multiple_timedelta_additions(self):
+        solver = create_solver({})
+        result = solver([
+            "Strftime",
+            ["Add", ["Add", ["Strptime", "2025-01-01T00:00", "%Y-%m-%dT%H:%M"], ["TimeDeltaDays", 1]], ["TimeDeltaHours", 12]],
+            "%Y-%m-%d %H:%M",
+        ])
+        assert result == "2025-01-02 12:00"
+
+    def test_datetime_in_conditional(self):
+        """Test using datetime comparison in If statement."""
+        solver = create_solver({})
+        # This tests that string datetimes work in other constructs
+        today = solver(["Today"])
+        assert isinstance(today, str)
+
+
+class TestTimeDeltaFunctions:
+    """Test TimeDelta functions."""
+
+    def test_timedelta_days(self):
+        solver = create_solver({})
+        result = solver(["Add", "2025-01-10", ["TimeDeltaDays", 5]])
+        assert "2025-01-15" in result
+
+    def test_timedelta_hours(self):
+        solver = create_solver({})
+        result = solver(["Add", "2025-01-10T10:00:00", ["TimeDeltaHours", 3]])
+        assert "13:00:00" in result
+
+    def test_timedelta_minutes(self):
+        solver = create_solver({})
+        result = solver(["Add", "2025-01-10T10:00:00", ["TimeDeltaMinutes", 30]])
+        assert "10:30:00" in result
+
+    def test_timedelta_weeks(self):
+        solver = create_solver({})
+        result = solver(["Add", "2025-01-10", ["TimeDeltaWeeks", 2]])
+        assert "2025-01-24" in result
+
+    def test_negative_timedelta(self):
+        solver = create_solver({})
+        result = solver(["Add", "2025-01-10", ["TimeDeltaDays", -5]])
+        assert "2025-01-05" in result
+
+
+class TestDatetimeWithVariables:
+    """Test datetime operations with variables."""
+
+    def test_today_in_variable(self):
+        solver = create_solver({})
+        result = solver(["Constants", ["d", ["Today"]], ["Strftime", "d", "%Y-%m-%d"]])
+        assert result == datetime.date.today().strftime("%Y-%m-%d")
+
+    def test_datetime_string_in_parameters(self):
+        solver = create_solver({"start_date": "2025-06-01"})
+        result = solver(["Strftime", ["Add", "start_date", ["TimeDeltaDays", 10]], "%Y-%m-%d"])
+        assert result == "2025-06-11"

{mathjson_solver-1.17.0 → mathjson_solver-1.18.0}/tests/test_gail_model.py

@@ -18,7 +18,7 @@ from mathjson_solver import create_solver
 
 
 @pytest.mark.skipif(not NUMPY_AVAILABLE, reason="NumPy not available")
-def test_gail_model1():
+def test_1989_gail_model1():
     parameters = {
         "AGEMEN": 1,  # Age at menarche (12-13 years)
         "NBIOPS": 1,  # 1 previous biopsy

{mathjson_solver-1.17.0 → mathjson_solver-1.18.0}/tests/test_state_tuples_reduce.py

@@ -26,19 +26,21 @@ def test_simple_state_tuple_accumulation():
 
     expression = [
         "Reduce",
-        ["Array", 1, 2, 3, 4],                    # Input array
-        ["Array", 0, 0],                          # Initial state: [sum=0, count=0]
+        ["Array", 1, 2, 3, 4],  # Input array
+        ["Array", 0, 0],  # Initial state: [sum=0, count=0]
         # Build a new array with updated values
-        ["Appended",
-            ["Appended",
+        [
+            "Appended",
+            [
+                "Appended",
                 ["Array"],  # Start with empty array
-                ["Add", ["AtIndex", "accumulator", 0], "current_item"]  # Add new sum
+                ["Add", ["AtIndex", "accumulator", 0], "current_item"],  # Add new sum
             ],
-            ["Add", ["AtIndex", "accumulator", 1], 1]  # Add new count
+            ["Add", ["AtIndex", "accumulator", 1], 1],  # Add new count
         ],
         ["Variable", "accumulator"],
         ["Variable", "current_item"],
-        ["Variable", "index"]
+        ["Variable", "index"],
     ]
 
     solver = create_solver({})
@@ -62,19 +64,29 @@ def test_running_sum_and_product():
 
     expression = [
         "Reduce",
-        ["Array", 2, 3, 4],                       # Input array
-        ["Array", 0, 1],                          # Initial state: [sum=0, product=1]
+        ["Array", 2, 3, 4],  # Input array
+        ["Array", 0, 1],  # Initial state: [sum=0, product=1]
         # Build new state using nested Appended pattern
-        ["Appended",
-            ["Appended",
+        [
+            "Appended",
+            [
+                "Appended",
                 ["Array"],
-                ["Add", ["AtIndex", "accumulator", 0], "current_item"]        # new_sum = old_sum + item
+                [
+                    "Add",
+                    ["AtIndex", "accumulator", 0],
+                    "current_item",
+                ],  # new_sum = old_sum + item
             ],
-            ["Multiply", ["AtIndex", "accumulator", 1], "current_item"]    # new_product = old_product * item
+            [
+                "Multiply",
+                ["AtIndex", "accumulator", 1],
+                "current_item",
+            ],  # new_product = old_product * item
         ],
         ["Variable", "accumulator"],
         ["Variable", "current_item"],
-        ["Variable", "index"]
+        ["Variable", "index"],
     ]
 
     solver = create_solver({})
@@ -92,19 +104,28 @@ def test_simple_dual_accumulation():
 
     expression = [
         "Reduce",
-        ["Array", 3, 1, 4, 2],                    # Input array
-        ["Array", 0, 0],                          # Initial state: [sum=0, max=0]
+        ["Array", 3, 1, 4, 2],  # Input array
+        ["Array", 0, 0],  # Initial state: [sum=0, max=0]
         # Build new state using nested Appended pattern
-        ["Appended",
-            ["Appended",
+        [
+            "Appended",
+            [
+                "Appended",
                 ["Array"],
-                ["Add", ["AtIndex", "accumulator", 0], "current_item"]        # new_sum = old_sum + item
+                [
+                    "Add",
+                    ["AtIndex", "accumulator", 0],
+                    "current_item",
+                ],  # new_sum = old_sum + item
             ],
-            ["Max", ["Array", ["AtIndex", "accumulator", 1], "current_item"]]  # new_max = max(old_max, item)
+            [
+                "Max",
+                ["Array", ["AtIndex", "accumulator", 1], "current_item"],
+            ],  # new_max = max(old_max, item)
         ],
         ["Variable", "accumulator"],
         ["Variable", "current_item"],
-        ["Variable", "index"]
+        ["Variable", "index"],
     ]
 
     solver = create_solver({})
@@ -122,31 +143,38 @@ def test_extract_final_value_from_state_tuple():
 
     expression = [
         "Constants",
-
         # Use Reduce to accumulate state tuple [sum, product]
-        ["state_result", [
-            "Reduce",
-            ["Array", 2, 3, 4],
-            ["Array", 0, 1],  # [sum=0, product=1]
-            # Build new state using nested Appended pattern
-            ["Appended",
-                ["Appended",
-                    ["Array"],
-                    ["Add", ["AtIndex", "accumulator", 0], "current_item"]        # sum
+        [
+            "state_result",
+            [
+                "Reduce",
+                ["Array", 2, 3, 4],
+                ["Array", 0, 1],  # [sum=0, product=1]
+                # Build new state using nested Appended pattern
+                [
+                    "Appended",
+                    [
+                        "Appended",
+                        ["Array"],
+                        ["Add", ["AtIndex", "accumulator", 0], "current_item"],  # sum
+                    ],
+                    [
+                        "Multiply",
+                        ["AtIndex", "accumulator", 1],
+                        "current_item",
+                    ],  # product
                 ],
-                ["Multiply", ["AtIndex", "accumulator", 1], "current_item"]    # product
+                ["Variable", "accumulator"],
+                ["Variable", "current_item"],
+                ["Variable", "index"],
             ],
-            ["Variable", "accumulator"],
-            ["Variable", "current_item"],
-            ["Variable", "index"]
-        ]],
-
+        ],
         # Extract just the sum (index 0) - this is what we'll do for NCI risk
-        ["AtIndex", "state_result", 0]
+        ["AtIndex", "state_result", 0],
     ]
 
     solver = create_solver({})
     result = solver(expression)
 
     # Should return just the sum: 2 + 3 + 4 = 9
-    assert result == 9, f"Expected 9, got {result}"
+    assert result == 9, f"Expected 9, got {result}"

{mathjson_solver-1.17.0 → mathjson_solver-1.18.0}/tests/test_with_pytest.py

@@ -179,6 +179,16 @@ from mathjson_solver import create_solver
             ["Sum", ["Map", ["Array", 1, 2, 3, 4, 1, 1, 0, 1], ["GreaterEqual"], 2]],
             3,
         ),
+        (
+            {},
+            ["All", ["Map", ["Array", 1, 2, 3, 4, 1, 1, 0, 1], ["GreaterEqual"], 2]],
+            False,
+        ),
+        (
+            {},
+            ["Any", ["Map", ["Array", 1, 2, 3, 4, 1, 1, 0, 1], ["GreaterEqual"], 2]],
+            True,
+        ),
         ({}, ["Sum", ["Array", True, False, True, False, False]], 2),
         # ["HasMatchingSublist", list, required_match_count, position, contiguous, function, more parameters]
         (
@@ -259,78 +269,6 @@ from mathjson_solver import create_solver
             ],
             False,
         ),
-        (
-            {},
-            ["Strftime", ["Strptime", "2025-01-10T10:05", "%Y-%m-%dT%H:%M"], "%Y"],
-            "2025",
-        ),
-        ({}, ["Strftime", ["Today"], "%Y"], "2025"),
-        ({}, ["Strftime", ["Now"], "%Y"], "2025"),
-        (
-            {},
-            [
-                "Strftime",
-                [
-                    "Add",
-                    ["Strptime", "2025-01-10T10:05", "%Y-%m-%dT%H:%M"],
-                    ["TimeDeltaDays", 3],
-                ],
-                "%d",
-            ],
-            "13",
-        ),
-        (
-            {},
-            [
-                "Strftime",
-                [
-                    "Subtract",
-                    ["Strptime", "2025-01-10T10:05", "%Y-%m-%dT%H:%M"],
-                    ["TimeDeltaDays", 3],
-                ],
-                "%d",
-            ],
-            "07",
-        ),
-        (
-            {},
-            [
-                "Strftime",
-                [
-                    "Add",
-                    ["Strptime", "2025-01-10T10:05", "%Y-%m-%dT%H:%M"],
-                    ["TimeDeltaMinutes", 5],
-                ],
-                "%M",
-            ],
-            "10",
-        ),
-        (
-            {},
-            [
-                "Strftime",
-                [
-                    "Add",
-                    ["Strptime", "2025-01-10T10:05", "%Y-%m-%dT%H:%M"],
-                    ["TimeDeltaHours", 2],
-                ],
-                "%H",
-            ],
-            "12",
-        ),
-        (
-            {},
-            [
-                "Strftime",
-                [
-                    "Add",
-                    ["Strptime", "2025-01-10T10:05", "%Y-%m-%dT%H:%M"],
-                    ["TimeDeltaWeeks", 1],
-                ],
-                "%d",
-            ],
-            "17",
-        ),
     ],
 )
 def test_solver_simple(parameters, expression, expected_result):