mathai 2.4.7__tar.gz → 2.4.8__tar.gz

{mathai-2.4.7 → mathai-2.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 2.4.7
+Version: 2.4.8
 Summary: Mathematics solving Ai tailored to NCERT
 Home-page: https://github.com/infinity390/mathai
 Requires-Python: >=3.7

{mathai-2.4.7 → mathai-2.4.8}/mathai/__init__.py

@@ -1,5 +1,3 @@
-from .benchmark import load_sequences, strategy_tree, execute_parallel
-
 from .ode import diffsolve as ode_solve
 from .ode import diffsolve_sep as ode_shift_term
 

{mathai-2.4.7 → mathai-2.4.8}/mathai/benchmark.py

@@ -1,6 +1,4 @@
-import atexit
 import copy
-import multiprocessing
 from pathlib import Path
 
 from .simplify import simplify
@@ -175,138 +173,23 @@ def print_tree(node, depth=0):
 
 
 # ---------------------------------------------------------------------------
-# Parallel execution
-#
-# Design: nothing heavy is pickled per call.
-#   - Each worker builds the tree once, from the dataset name, at pool start.
-#   - Terminal conditions are looked up by name in TERMINAL_CONDITIONS, so no
-#     function object is ever sent to a worker.
-#   - Pools persist across calls, so spawn/import cost is paid once.
-#   - Per task, only (branch index, equation, condition name, generation)
-#     is sent.
+# Serial Execution Entry Point
 # ---------------------------------------------------------------------------
 
-# Register terminal conditions here. Workers re-import this module and find
-# them by name.
-TERMINAL_CONDITIONS = {
-    "no_integrate": lambda eq: not contain2(eq, "f_integrate"),
-}
 
-_TREES = {}  # data_name -> root Node (cached per process)
-_POOLS = {}  # (data_name, n_cores) -> (pool, generation counter)
-
-# Worker-process globals, set once by _init_worker
-_W_BRANCHES = None
-_W_GEN = None
-
-
-def _get_tree(data_name):
-    if data_name not in _TREES:
-        _TREES[data_name] = strategy_tree(load_sequences(data_name))
-    return _TREES[data_name]
-
-
-def _init_worker(data_name, gen):
-    global _W_BRANCHES, _W_GEN
-    _W_BRANCHES = list(_get_tree(data_name).children.values())
-    _W_GEN = gen
-
-
-def _worker(task):
-    idx, equation, cond_name, my_gen = task
-
-    # Stale task left over from a call that already finished: skip it.
-    if _W_GEN.value != my_gen:
-        return []
-
-    cond = TERMINAL_CONDITIONS[cond_name] if cond_name else None
-    try:
-        return _W_BRANCHES[idx].execute(equation, [], cond)
-    except Exception:
-        # A failing branch must not discard results from other branches.
-        return []
-
-
-def _first_match(results, cond):
-    for eq, seq in results:
-        if cond is None or cond(eq):
-            return [(eq, seq)]
-    return None
-
-
-def _execute_sequential(data_name, equation, cond_name):
-    cond = TERMINAL_CONDITIONS[cond_name] if cond_name else None
-
-    for child in _get_tree(data_name).children.values():
+def execute_serial(tree, equation, terminal_condition=None):
+    """
+    Executes the strategy tree serially and returns at most one 
+    matching path as a list of tuples: [(equation, sequence)].
+    """
+    for child in tree.children.values():
         try:
-            results = child.execute(copy.deepcopy(equation), [], cond)
+            results = child.execute(copy.deepcopy(equation), [], terminal_condition)
         except Exception:
-            continue  # same semantics as the workers
+            continue
 
-        match = _first_match(results, cond)
-        if match is not None:
-            return match
+        for eq, seq in results:
+            if terminal_condition is None or terminal_condition(eq):
+                return [(eq, seq)]
 
     return []
-
-
-def _get_pool(data_name, n_cores):
-    key = (data_name, n_cores)
-
-    if key not in _POOLS:
-        gen = multiprocessing.Value("i", 0, lock=False)
-        pool = multiprocessing.Pool(
-            n_cores, initializer=_init_worker, initargs=(data_name, gen)
-        )
-        _POOLS[key] = (pool, gen)
-
-    return _POOLS[key]
-
-
-def shutdown_pools():
-    for pool, _ in _POOLS.values():
-        pool.terminate()
-        pool.join()
-    _POOLS.clear()
-
-
-atexit.register(shutdown_pools)
-
-
-def execute_parallel(data_name, equation, n_cores=None, condition_name=None):
-    """
-    Run the strategy tree for `data_name` against `equation` and return at
-    most one result as a one-item list [(equation, sequence)].
-
-    condition_name: key into TERMINAL_CONDITIONS, or None.
-
-    On Windows/macOS (spawn start method) callers using n_cores > 1 must be
-    guarded by ``if __name__ == "__main__":``.
-    """
-    n_branches = len(_get_tree(data_name).children)
-    if n_branches == 0:
-        return []
-
-    if n_cores is None:
-        n_cores = multiprocessing.cpu_count()
-    # Never more processes than branches, never fewer than one
-    n_cores = max(1, min(n_cores, n_branches))
-
-    if n_cores == 1:
-        return _execute_sequential(data_name, equation, condition_name)
-
-    cond = TERMINAL_CONDITIONS[condition_name] if condition_name else None
-    pool, gen = _get_pool(data_name, n_cores)
-
-    my_gen = gen.value + 1
-    gen.value = my_gen
-    tasks = [(i, equation, condition_name, my_gen) for i in range(n_branches)]
-
-    try:
-        for branch_results in pool.imap_unordered(_worker, tasks):
-            match = _first_match(branch_results, cond)
-            if match is not None:
-                return match
-        return []
-    finally:
-        gen.value = my_gen + 1  # cancels any still-queued tasks

{mathai-2.4.7 → mathai-2.4.8}/mathai/decision.py

@@ -15,7 +15,7 @@ from .factor import factor2, factor
 from .limit import limit1, limit5
 from .linear import linear_solve
 from .matrix import matrix_solve, matrix_formula
-from .benchmark import load_sequences, strategy_tree, execute_parallel
+from .benchmark import load_sequences, strategy_tree, execute_serial
 
 def vlist_2(eq):
     out = []
@@ -61,19 +61,21 @@ def solve_subs(q):
     if len(solution.keys()) == 0:
         return orig
     return operation("f_and", [item for item in lst if all(not contain(item, tree_form(key)) for key in solution.keys())] + [TreeNode("f_eq", [tree_form(key), item]) for key, item in solution.items()])
+def _no_integrate_left(eq):
+    return eq.name == "f_range" or eq.name == "s_true" or all(not contain2(eq, "f_"+item) for item in "eq integrate subs limit limitpinf limitninf".split(" "))
 
 
-def god2(string, core=1):
-    out = execute_parallel(
-        "ncert_data", simplify(parse(string)), core, "no_integrate"
+def god2(string):
+    out = execute_serial(
+        strategy_tree(load_sequences("ncert_data")),
+        simplify(parse(string)),
+        _no_integrate_left,
     )
-
     if len(out) >= 1:
         print(string)
         print("=>", out[0][0])
         print(["parse", "simplify"] + out[0][1])
-
-    return out
+    return None
 
 def god(string, debug=True):
     if debug:

{mathai-2.4.7 → mathai-2.4.8}/mathai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mathai
-Version: 2.4.7
+Version: 2.4.8
 Summary: Mathematics solving Ai tailored to NCERT
 Home-page: https://github.com/infinity390/mathai
 Requires-Python: >=3.7

{mathai-2.4.7 → mathai-2.4.8}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="mathai",
-    version="2.4.7",
+    version="2.4.8",
     description="Mathematics solving Ai tailored to NCERT",
     long_description=Path("README.md").read_text(encoding="utf-8"),
     long_description_content_type="text/markdown",