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

{mathjson_solver-1.8.0/src/mathjson_solver.egg-info → mathjson_solver-1.9.0}/PKG-INFO

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

{mathjson_solver-1.8.0 → mathjson_solver-1.9.0}/setup.cfg

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

{mathjson_solver-1.8.0 → mathjson_solver-1.9.0}/setup.py

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

{mathjson_solver-1.8.0 → mathjson_solver-1.9.0}/src/mathjson_solver/__main__.py

@@ -47,6 +47,86 @@ def is_numeric(x):
         return True
 
 
+def has_matching_sublist(
+    *,
+    my_list: list,
+    required_match_count: int,
+    position: int,
+    contiguous: bool,
+    conditions: list[bool],
+) -> bool:
+    if contiguous:
+        # Check for contiguous matches based on position
+        if position == 0:
+            # Check if the beginning of the list matches
+            count = sum(
+                1
+                for i in range(min(required_match_count, len(my_list)))
+                if conditions[i]
+            )
+            return count == required_match_count
+        elif position > 0:
+            # Skip the first `position` elements
+            count = sum(
+                1
+                for i in range(position, position + required_match_count)
+                if i < len(my_list) and conditions[i]
+            )
+            return count == required_match_count
+        elif position == -1:
+            # Check if the end of the list matches
+            count = sum(
+                1
+                for i in range(len(my_list) - required_match_count, len(my_list))
+                if conditions[i]
+            )
+            return count == required_match_count
+        elif position < -1:
+            # Skip the last `abs(position)` elements
+            count = sum(1 for i in range(len(my_list) + position) if conditions[i])
+            return count == required_match_count
+    else:
+        # Check for non-contiguous matches
+        count = sum(1 for i in range(len(my_list)) if conditions[i])
+        return count >= required_match_count
+
+
+def has_sublist2(
+    *,
+    my_list: list,
+    required_match_count: int,
+    position: int,
+    contiguous: bool,
+    condition: callable,
+) -> bool:
+    if contiguous:
+        # Check for contiguous matches based on position
+        if position == 0:
+            # Check if the beginning of the list matches
+            count = sum(1 for x in my_list[:required_match_count] if condition(x))
+            return count == required_match_count
+        elif position > 0:
+            # Skip the first `position` elements
+            count = sum(
+                1
+                for x in my_list[position : position + required_match_count]
+                if condition(x)
+            )
+            return count == required_match_count
+        elif position == -1:
+            # Check if the end of the list matches
+            count = sum(1 for x in my_list[-required_match_count:] if condition(x))
+            return count == required_match_count
+        elif position < -1:
+            # Skip the last `abs(position)` elements
+            count = sum(1 for x in my_list[:position] if condition(x))
+            return count == required_match_count
+    else:
+        # Check for non-contiguous matches
+        count = sum(1 for x in my_list if condition(x))
+        return count >= required_match_count
+
+
 def create_mathjson_solver(solver_parameters):
     def f(s, *args):
         if args:
@@ -61,6 +141,16 @@ def create_mathjson_solver(solver_parameters):
             def Arr(s):
                 return s
 
+            def Sum(s):
+                l_res = []
+                for x in s[1:]:
+                    res = f(x, c)
+                    if isinstance(res, list):
+                        l_res.append(sum([xx for xx in res[1:]]))
+                    else:
+                        l_res.append(res)
+                return sum(l_res)
+
             # @requires_array
             def Max(s):
                 if isinstance(s[1], str):
@@ -214,9 +304,48 @@ def create_mathjson_solver(solver_parameters):
             def Not(s):
                 return not f(s[1])
 
+            def Map(s):
+                """
+                ["Map", list, function, more parameters]
+                The `function` must accept at least one parameter. That is for the current loop element.
+                The `more parameters` are for any additional parameters that function might have.
+                """
+                z = f(s[1], c)
+                if isinstance(z, list):
+                    retlist = ["Array"]
+                    for x in z[1:]:
+                        the_function_name = s[2][0]
+                        ss = [the_function_name, x] + s[3:]
+                        retlist.append(f(ss, c))
+                    return retlist
+
+            def HasMatchingSublist(s):
+                """
+                ["HasMatchingSublist", list, required_match_count, position, contiguous, function, more parameters]
+                """
+                the_list = f(s[1], c)[1:]
+                required_match_count = f(s[2], c)
+                position = f(s[3], c)
+                contiguous = f(s[4], c)
+                conditions = []
+
+                for i, x in enumerate(the_list):
+                    the_function_name = s[5][0]
+                    ss = [the_function_name, x] + s[6:]
+                    conditions.append(f(ss, c))
+                    pass
+
+                return has_matching_sublist(
+                    my_list=the_list,
+                    required_match_count=required_match_count,
+                    position=position,
+                    contiguous=contiguous,
+                    conditions=conditions,
+                )
+
             constructs = {
-                "Add": lambda s: sum([f(x, c) for x in s[1:]]),
-                "Sum": lambda s: sum([f(x, c) for x in s[1:]]),
+                "Sum": Sum,
+                "Add": Sum,
                 "Subtract": lambda s: reduce(
                     lambda a, b: a - b, [f(x, c) for x in s[1:]]
                 ),
@@ -270,6 +399,8 @@ def create_mathjson_solver(solver_parameters):
                 "Str": Str,
                 "Not": Not,
                 "IsDefined": lambda s: s[1] in c,
+                "Map": Map,
+                "HasMatchingSublist": HasMatchingSublist,
             }
             if s[0] in constructs:
                 try:
@@ -341,6 +472,8 @@ def extract_variables(s: Union[list, int, float, str], li: set, ignore_list: set
         "Str",
         "Not",
         "IsDefined",
+        "Map",
+        "HasMatchingSublist",
     ]
     if isinstance(s, str):
         if s in ignore_list:

{mathjson_solver-1.8.0 → mathjson_solver-1.9.0/src/mathjson_solver.egg-info}/PKG-INFO

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

{mathjson_solver-1.8.0 → mathjson_solver-1.9.0}/tests/test_with_pytest.py

@@ -13,6 +13,10 @@ from mathjson_solver import create_solver, MathJSONException, extract_variables
     [
         ({}, ["Add", 2, 4, 3], 9),
         ({}, ["Sum", 2, 4, 3], 9),
+        ({}, ["Sum", ["Array", 1, 1], 4, 3], 9),
+        ({}, ["Sum", ["Array", 2, 4, 3]], 9),
+        ({"a": 2}, ["Sum", "a", 4, 3], 9),
+        ({"a": ["Array", 1, 1]}, ["Sum", "a", 4, 3], 9),
         ({}, ["Subtract", 10, 5, 2], 3),
         ({}, ["Add", 5, 4, ["Negate", 3]], 6),
         ({}, ["Multiply", 2, 3, 4], 24),
@@ -168,6 +172,93 @@ from mathjson_solver import create_solver, MathJSONException, extract_variables
         ({}, ["Not", True], False),
         ({}, ["Not", 0], True),
         ({}, ["Not", ["In", 2, ["Array", 1, 2, 3]]], False),
+        ({}, ["Array", 2, 4, 3], ["Array", 2, 4, 3]),
+        ({}, ["Map", ["Array", 1, 2, 3], ["Square"]], ["Array", 1, 4, 9]),
+        ({}, ["Map", ["Array", 1, 2, 3], ["Power"], 2], ["Array", 1, 4, 9]),
+        (
+            {},
+            ["Map", ["Array", 1, 2, 3], ["GreaterEqual"], 2],
+            ["Array", False, True, True],
+        ),
+        # ["HasMatchingSublist", list, required_match_count, position, contiguous, function, more parameters]
+        (
+            {},
+            [
+                "HasMatchingSublist",
+                ["Array", 1, 2, 3, 4, 5, 6],
+                3,
+                0,
+                True,
+                ["GreaterEqual"],
+                1,
+            ],
+            True,  # first 3 elements are greater than 3
+        ),
+        (
+            {},
+            [
+                "HasMatchingSublist",
+                ["Array", 1, 2, 3, 4, 5, 6],
+                3,
+                0,
+                True,
+                ["GreaterEqual"],
+                2,
+            ],
+            False,  # first 3 elements are greater than 3 - False
+        ),
+        (
+            {},
+            [
+                "HasMatchingSublist",
+                ["Array", 1, 2, 3, 4, 5, 6],
+                3,
+                0,
+                False,  # anywhere
+                ["GreaterEqual"],
+                4,
+            ],
+            True,
+        ),
+        (
+            {},
+            [
+                "HasMatchingSublist",
+                ["Array", 1, 2, 3, 4, 5, 6],
+                4,
+                0,
+                False,  # anywhere
+                ["GreaterEqual"],
+                4,
+            ],
+            False,
+        ),
+        (
+            {},
+            [
+                "HasMatchingSublist",
+                ["Array", 1, 2, 3, 4, 5, 6],
+                3,
+                -1,
+                True,
+                ["GreaterEqual"],
+                4,
+            ],
+            True,
+        ),
+        (
+            {},
+            [
+                "HasMatchingSublist",
+                ["Array", 1, 2, 3, 4, 5, 6],
+                5,
+                -1,
+                True,
+                ["GreaterEqual"],
+                4,
+            ],
+            False,
+        ),
     ],
 )
 def test_solver_simple(parameters, expression, expected_result):