mathjson-solver 2.1.1__tar.gz → 2.2.0__tar.gz

{mathjson_solver-2.1.1 → mathjson_solver-2.2.0}/CHANGELOG.md

@@ -5,6 +5,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/).
 
+## [2.2.0] - 2026-09-08
+
+### Added
+
+- **Migration helper for 1.x users:** `translate_v1_mathjson(expr)` rewrites the one breaking change from 2.0.0 (`["Log", x]`, previously natural log) to its 2.x equivalent (`["Ln", x]`), leaving everything else untouched. `create_solver(parameters, legacy_v1=True)` applies this automatically, so existing 1.x expressions keep evaluating to the same results on 2.x without hand-editing, while still gaining access to functions added in 2.x.
+
+[2.2.0]: https://github.com/LongenesisLtd/mathjson-solver/compare/v2.1.1...v2.2.0
+
 ## [2.1.1] - 2026-08-19
 
 ### Fixed

{mathjson_solver-2.1.1 → mathjson_solver-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mathjson-solver
-Version: 2.1.1
+Version: 2.2.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
@@ -18,7 +18,7 @@ Description-Content-Type: text/markdown
 [![PyPI Downloads](https://static.pepy.tech/badge/mathjson-solver/month)](https://pepy.tech/projects/mathjson-solver)
 [![Python 3.7+](https://img.shields.io/badge/python-3.7+-blue.svg)](https://www.python.org/downloads/)
 
-> **Heads up:** Version 2 introduces a few breaking changes (see [CHANGELOG.md](CHANGELOG.md)) as part of steering back towards greater compatibility with [CortexJS MathJSON](https://cortexjs.io/compute-engine/). If you need to stay on the old behavior, bugfix releases for the 1.x line continue on the [`1.x` branch](https://github.com/LongenesisLtd/mathjson-solver/tree/1.x).
+> **Heads up:** Version 2 introduces a breaking change (see [CHANGELOG.md](CHANGELOG.md)) as part of steering back towards greater compatibility with [CortexJS MathJSON](https://cortexjs.io/compute-engine/): `Log` is now log base 10 instead of natural log. Stuck on pre-2.0.0 expressions but want the functions added in 2.x? Pass `legacy_v1=True` to `create_solver()` (see [Migrating from 1.x](#migrating-from-1x)) instead of hand-migrating every expression. Bugfix releases for the 1.x line also continue on the [`1.x` branch](https://github.com/LongenesisLtd/mathjson-solver/tree/1.x).
 
 A reliable Python library for numerically evaluating mathematical expressions in MathJSON format. Perfect for applications that need to safely execute user-provided formulas, calculate dynamic equations, or process mathematical data.
 
@@ -27,12 +27,14 @@ A reliable Python library for numerically evaluating mathematical expressions in
 ## Table of Contents
 - [Installation](#installation)
 - [Quick Start](#quick-start)
+- [Migrating from 1.x](#migrating-from-1x)
 - [Supported Operations](#supported-operations)
 - [Error Handling](#error-handling)
 - [Use Cases](#use-cases)
 - [Testing](#testing)
 - [Community](#community)
 - [Contributing](#contributing)
+- [Related Projects](#related-projects)
 
 ## Installation
 
@@ -82,6 +84,27 @@ solver(["Map", ["Array", 1, 2, 3, 4], ["Function", ["Multiply", "_", 2]]])  # [2
 solver(["Reduce", ["Array", 1, 2, 3, 4], ["Add"]])                          # 10
 ```
 
+## Migrating from 1.x
+
+Version 2.0.0's only breaking change is `Log`: pre-2.0.0 it was always natural log, `["Log", x]` == `math.log(x)`. From 2.0.0 on it matches [CortexJS](https://cortexjs.io/compute-engine/) — `["Log", x]` is log base 10, `["Log", x, b]` is log base `b` — and natural log moved to `Ln`.
+
+If you have existing expressions built for 1.x and don't want to hand-edit every `Log` node just to pick up functions added in 2.x (`Product`, the CortexJS forms of `If`/`Map`/`Filter`/`Reduce`, the new aliases, etc.), pass `legacy_v1=True` when creating the solver. It rewrites every `["Log", x]` to `["Ln", x]` before evaluating, so old expressions keep producing the same results without modification:
+
+```python
+solver = create_solver(parameters, legacy_v1=True)
+solver(["Log", 8])  # 2.0794... (natural log, matching pre-2.0.0 behavior)
+```
+
+You can also run the rewrite yourself and inspect or store the translated expression:
+
+```python
+from mathjson_solver import translate_v1_mathjson
+
+translate_v1_mathjson(["Add", ["Log", 8], 1])  # ["Add", ["Ln", 8], 1]
+```
+
+`legacy_v1=True` only affects `Log`. Every other 1.x expression already evaluates identically on 2.x without any translation.
+
 ## Supported Operations
 
 The library supports a comprehensive set of mathematical operations:
@@ -161,6 +184,9 @@ We welcome contributions! Please feel free to:
 - Report bugs or request features via [GitHub Issues](https://github.com/LongenesisLtd/mathjson-solver/issues)
 - Submit pull requests with improvements
 
+## Related Projects
+
+We also created [`londec`](https://pypi.org/project/londec/) — evaluate tree-structured conditions against an ordered history of events. It uses mathjson-solver internally.
 
 ## License
 
@@ -168,7 +194,9 @@ We welcome contributions! Please feel free to:
 
 ## References
 
-This implementation was inspired by the [CortexJS Compute Engine](https://cortexjs.io/compute-engine/), though designed as an independent implementation focused on our specific use cases.
+This library implements the [MathJSON](https://cortexjs.io/mathjson/) format as defined by the [CortexJS Compute Engine](https://cortexjs.io/compute-engine/). Since 2.0.0, mathjson-solver has been steering towards greater compatibility with CortexJS's calling conventions and function set — while remaining an independent Python implementation, not a port or dependency of CortexJS.
+
+**Scope:** mathjson-solver targets compatibility with CortexJS's array-form calling conventions and standard function names — not the full [Compute Engine](https://cortexjs.io/compute-engine/), which is a symbolic CAS.
 
 ---
 

{mathjson_solver-2.1.1 → mathjson_solver-2.2.0}/README.md

@@ -4,7 +4,7 @@
 [![PyPI Downloads](https://static.pepy.tech/badge/mathjson-solver/month)](https://pepy.tech/projects/mathjson-solver)
 [![Python 3.7+](https://img.shields.io/badge/python-3.7+-blue.svg)](https://www.python.org/downloads/)
 
-> **Heads up:** Version 2 introduces a few breaking changes (see [CHANGELOG.md](CHANGELOG.md)) as part of steering back towards greater compatibility with [CortexJS MathJSON](https://cortexjs.io/compute-engine/). If you need to stay on the old behavior, bugfix releases for the 1.x line continue on the [`1.x` branch](https://github.com/LongenesisLtd/mathjson-solver/tree/1.x).
+> **Heads up:** Version 2 introduces a breaking change (see [CHANGELOG.md](CHANGELOG.md)) as part of steering back towards greater compatibility with [CortexJS MathJSON](https://cortexjs.io/compute-engine/): `Log` is now log base 10 instead of natural log. Stuck on pre-2.0.0 expressions but want the functions added in 2.x? Pass `legacy_v1=True` to `create_solver()` (see [Migrating from 1.x](#migrating-from-1x)) instead of hand-migrating every expression. Bugfix releases for the 1.x line also continue on the [`1.x` branch](https://github.com/LongenesisLtd/mathjson-solver/tree/1.x).
 
 A reliable Python library for numerically evaluating mathematical expressions in MathJSON format. Perfect for applications that need to safely execute user-provided formulas, calculate dynamic equations, or process mathematical data.
 
@@ -13,12 +13,14 @@ A reliable Python library for numerically evaluating mathematical expressions in
 ## Table of Contents
 - [Installation](#installation)
 - [Quick Start](#quick-start)
+- [Migrating from 1.x](#migrating-from-1x)
 - [Supported Operations](#supported-operations)
 - [Error Handling](#error-handling)
 - [Use Cases](#use-cases)
 - [Testing](#testing)
 - [Community](#community)
 - [Contributing](#contributing)
+- [Related Projects](#related-projects)
 
 ## Installation
 
@@ -68,6 +70,27 @@ solver(["Map", ["Array", 1, 2, 3, 4], ["Function", ["Multiply", "_", 2]]])  # [2
 solver(["Reduce", ["Array", 1, 2, 3, 4], ["Add"]])                          # 10
 ```
 
+## Migrating from 1.x
+
+Version 2.0.0's only breaking change is `Log`: pre-2.0.0 it was always natural log, `["Log", x]` == `math.log(x)`. From 2.0.0 on it matches [CortexJS](https://cortexjs.io/compute-engine/) — `["Log", x]` is log base 10, `["Log", x, b]` is log base `b` — and natural log moved to `Ln`.
+
+If you have existing expressions built for 1.x and don't want to hand-edit every `Log` node just to pick up functions added in 2.x (`Product`, the CortexJS forms of `If`/`Map`/`Filter`/`Reduce`, the new aliases, etc.), pass `legacy_v1=True` when creating the solver. It rewrites every `["Log", x]` to `["Ln", x]` before evaluating, so old expressions keep producing the same results without modification:
+
+```python
+solver = create_solver(parameters, legacy_v1=True)
+solver(["Log", 8])  # 2.0794... (natural log, matching pre-2.0.0 behavior)
+```
+
+You can also run the rewrite yourself and inspect or store the translated expression:
+
+```python
+from mathjson_solver import translate_v1_mathjson
+
+translate_v1_mathjson(["Add", ["Log", 8], 1])  # ["Add", ["Ln", 8], 1]
+```
+
+`legacy_v1=True` only affects `Log`. Every other 1.x expression already evaluates identically on 2.x without any translation.
+
 ## Supported Operations
 
 The library supports a comprehensive set of mathematical operations:
@@ -147,6 +170,9 @@ We welcome contributions! Please feel free to:
 - Report bugs or request features via [GitHub Issues](https://github.com/LongenesisLtd/mathjson-solver/issues)
 - Submit pull requests with improvements
 
+## Related Projects
+
+We also created [`londec`](https://pypi.org/project/londec/) — evaluate tree-structured conditions against an ordered history of events. It uses mathjson-solver internally.
 
 ## License
 
@@ -154,7 +180,9 @@ We welcome contributions! Please feel free to:
 
 ## References
 
-This implementation was inspired by the [CortexJS Compute Engine](https://cortexjs.io/compute-engine/), though designed as an independent implementation focused on our specific use cases.
+This library implements the [MathJSON](https://cortexjs.io/mathjson/) format as defined by the [CortexJS Compute Engine](https://cortexjs.io/compute-engine/). Since 2.0.0, mathjson-solver has been steering towards greater compatibility with CortexJS's calling conventions and function set — while remaining an independent Python implementation, not a port or dependency of CortexJS.
+
+**Scope:** mathjson-solver targets compatibility with CortexJS's array-form calling conventions and standard function names — not the full [Compute Engine](https://cortexjs.io/compute-engine/), which is a symbolic CAS.
 
 ---
 

{mathjson_solver-2.1.1 → mathjson_solver-2.2.0}/pyproject.toml

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

{mathjson_solver-2.1.1 → mathjson_solver-2.2.0}/src/mathjson_solver/__init__.py

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

{mathjson_solver-2.1.1 → mathjson_solver-2.2.0}/src/mathjson_solver/__main__.py

@@ -294,7 +294,29 @@ def comparison_safe_converter_for_pairs(
     return v1, v2
 
 
-def create_mathjson_solver(solver_parameters):
+def translate_v1_mathjson(expr):
+    """
+    Rewrite a MathJSON expression written for mathjson-solver < 2.0.0 so it
+    evaluates to the same result on >= 2.0.0.
+
+    The only breaking change introduced in 2.0.0 is "Log": before 2.0.0 it
+    always meant natural log (`["Log", x]` == `math.log(x)`); from 2.0.0 on
+    it matches CortexJS (`["Log", x]` is log base 10, `["Log", x, b]` is log
+    base `b`), and natural log moved to "Ln". Since the pre-2.0.0 "Log" only
+    ever took one argument, every legacy `["Log", x]` node has exactly one
+    correct translation: `["Ln", x]`. This function walks the expression
+    tree and applies that rewrite, leaving everything else untouched, so
+    existing expressions don't need to be hand-migrated to keep working
+    while still gaining access to functions added in 2.x.
+    """
+    if isinstance(expr, list):
+        if len(expr) == 2 and expr[0] == "Log":
+            return ["Ln", translate_v1_mathjson(expr[1])]
+        return [translate_v1_mathjson(item) for item in expr]
+    return expr
+
+
+def create_mathjson_solver(solver_parameters, legacy_v1=False):
     def f(s, *args):
         if args:
             c = deepcopy(args[0])
@@ -1510,6 +1532,13 @@ def create_mathjson_solver(solver_parameters):
             # raise KeyError(f"Parameter '{s}' is not defined")
             return s
 
+    if legacy_v1:
+
+        def legacy_v1_f(s, *args):
+            return f(translate_v1_mathjson(s), *args)
+
+        return legacy_v1_f
+
     return f
 
 

mathjson_solver-2.2.0/tests/test_legacy_compat.py

@@ -0,0 +1,73 @@
+import sys
+import os
+import math
+import pytest
+
+sys.path.append(os.path.join(os.path.dirname(__file__), "../src/"))
+
+from mathjson_solver import create_solver, translate_v1_mathjson
+
+
+@pytest.mark.parametrize(
+    "expression, expected_translation",
+    [
+        # The only rewrite: legacy 1-arg ["Log", x] -> ["Ln", x].
+        (["Log", 8], ["Ln", 8]),
+        (["Log", "x"], ["Ln", "x"]),
+        # Nested occurrences are rewritten too.
+        (["Add", ["Log", 8], 1], ["Add", ["Ln", 8], 1]),
+        (["Log", ["Log", 8]], ["Ln", ["Ln", 8]]),
+        # The 2.x 2-arg form is left alone (it never existed pre-2.0.0, so a
+        # legacy expression can never contain it).
+        (["Log", 8, 2], ["Log", 8, 2]),
+        # Everything else passes through unchanged.
+        (["Add", 1, 2], ["Add", 1, 2]),
+        (5, 5),
+        ("x", "x"),
+        ([], []),
+    ],
+)
+def test_translate_v1_mathjson(expression, expected_translation):
+    assert translate_v1_mathjson(expression) == expected_translation
+
+
+def test_translate_v1_mathjson_does_not_mutate_input():
+    expression = ["Add", ["Log", 8], 1]
+    original = ["Add", ["Log", 8], 1]
+    translate_v1_mathjson(expression)
+    assert expression == original
+
+
+@pytest.mark.parametrize(
+    "parameters, expression, expected_result",
+    [
+        ({}, ["Log", 8], math.log(8)),
+        ({}, ["Add", ["Log", 8], 1], math.log(8) + 1),
+        # New (2.x-only) functions remain usable alongside legacy expressions.
+        ({}, ["Product", ["Array", 2, 3, 4]], 24),
+    ],
+)
+def test_create_solver_legacy_v1_mode(parameters, expression, expected_result):
+    solver = create_solver(parameters, legacy_v1=True)
+    assert solver(expression) == pytest.approx(expected_result)
+
+
+def test_create_solver_legacy_v1_mode_matches_pre_2_0_0_log_semantics():
+    # Pre-2.0.0, ["Log", x] was always natural log - the exact behavior
+    # legacy_v1=True must reproduce for existing expressions.
+    solver = create_solver({}, legacy_v1=True)
+    assert solver(["Log", 8]) == pytest.approx(math.log(8))
+
+
+def test_create_solver_non_legacy_v1_mode_uses_2_x_log_semantics():
+    # Without legacy_v1=True, current (2.x) semantics apply: base 10.
+    solver = create_solver({})
+    assert solver(["Log", 1000]) == pytest.approx(3)
+
+
+def test_create_solver_legacy_v1_mode_with_parameter_reference():
+    # The translation happens on the whole expression tree up front, so a
+    # ["Log", x] whose argument is a solver parameter (not a literal) is
+    # rewritten and resolved correctly too.
+    solver = create_solver({"x": 8}, legacy_v1=True)
+    assert solver(["Log", "x"]) == pytest.approx(math.log(8))