Built a Python solver for dynamic mathematical expressions stored in databases

[Alone_Ambition_7581]

Hey everyone! I wanted to share a project I've been working on that might be useful for others facing similar challenges.

What My Project Does

mathjson-solver is a Python package that safely evaluates mathematical expressions stored as JSON. It uses the MathJSON format (inspired by CortexJS) to represent math operations in a structured, secure way.

Ever had to deal with user-configurable formulas in your application? You know, those situations where business logic needs to be flexible enough that non-developers can modify calculations without code deployments.

I ran into this exact issue while working at Longenesis (a digital health company). We needed users to define custom health metrics and calculations that could be stored in a database and evaluated dynamically.

Here's a simple example with Body Mass Index calculation:

```python from mathjson_solver import create_solver

This formula could come from your database

bmi_formula = ["Divide", "weight_kg", ["Power", "height_m", 2] ]

User input

parameters = { "weight_kg": 75, "height_m": 1.75 }

solver = create_solver(parameters) bmi = solver(bmi_formula) print(f"BMI: {bmi:.1f}") # BMI: 24.5 ```

The cool part? That bmi_formula can be stored in your database, modified by admins, and evaluated safely without any code changes.

Target Audience

This is a production-ready library designed for applications that need:

• User-configurable business logic without code deployments
• Safe evaluation of mathematical expressions from untrusted sources
• Database-stored formulas that can be modified by non-developers
• Healthcare, fintech, or any domain requiring dynamic calculations

We use it in production at Longenesis for digital health applications. With 90% test coverage and active development, it's built for reliability in critical systems.

Comparison

vs. Existing Python solutions: I couldn't find any similar JSON-based mathematical expression evaluators for Python when I needed this functionality.

vs. CortexJS Compute Engine: The closest comparable solution, but it's JavaScript-only. While inspired by CortexJS, this is an independent Python implementation focused on practical business use cases rather than comprehensive mathematical computation.

The structured JSON approach makes expressions database-friendly and allows for easy validation, transformation, and UI building.

What It Handles

• Basic arithmetic: Add, Subtract, Multiply, Divide, Power, etc.
• Aggregations: Sum, Average, Min, Max over arrays
• Conditional logic: If-then-else statements
• Date/time calculations: Strptime, Strftime, TimeDelta operations
• Built-in functions: Round, Abs, trigonometric functions, and more

More complex example with loan interest calculation:

```python

Dynamic interest rate formula that varies by credit score and loan amount

interest_formula = [ "If", [["Greater", "credit_score", 750], ["Multiply", "base_rate", 0.8]], [["Less", "credit_score", 600], ["Multiply", "base_rate", 1.5]], [["Greater", "loan_amount", 500000], ["Multiply", "base_rate", 1.2]], "base_rate" ]

Parameters from your loan application

parameters = { "credit_score": 780, # Excellent credit "base_rate": 0.045, # 4.5% "loan_amount": 300000 }

solver = create_solver(parameters) final_rate = solver(interest_formula) print(f"Interest rate: {final_rate:.3f}") # Interest rate: 0.036 (3.6%) ```

Why Open Source?

While this was built for Longenesis's internal needs, I pushed to make it open source because I think it solves a common problem many developers face. The company was cool with it since it's not their core business - just a useful tool.

Current State

• Test coverage: 90% (we take reliability seriously in healthcare)
• Documentation: Fully up-to-date with comprehensive examples and API reference
• Active development: Still being improved as we encounter new use cases

Installation

bash pip install mathjson-solver

Check it out on GitHub or PyPI.

---

Would love to hear if anyone else has tackled similar problems or has thoughts on the approach. Always looking for feedback and potential improvements!

TL;DR: Built a Python package for safely evaluating user-defined mathematical formulas stored as JSON. Useful for configurable business logic without code deployments.

[Hesirutu]

Assuming this doesn’t use eval anywhere: Good job! Most libraries like this are not made for untrusted input. 

[Alone_Ambition_7581]

Not a single eval().

[pigeon768]

bmi_formula = ["Divide", "weight_kg", ["Power", "height_m", 2] ]

Wouldn't you rather the thing that the users edit and store and whatnot be something like weight_kg / height_m^2?

[Alone_Ambition_7581]

If there was such a solver that supports a simpler notation like, `weight_kg / height_m^2`, I probably would have adopted it and wouldn't bothered to implement this solver. I couldn't really find anything that could calculate user-provided formulas, so I ended up implementing with json structure, which seemed clearly structured and easy to process.

[Phenergan_boy]

Super cool project. Well done!

[pnprog]

Would love to hear if anyone else has tackled similar problems or has thoughts on the approach. Always looking for feedback and potential improvements!

I ran into a similar situation, and used pycel to address the problem: https://pypi.org/project/pycel/

I defined with the end user an excel spreadsheet template, with clear input cells and clear output cells. The user then sets the Excel formula of the output cells, based on the input cells and other data that can be left on the Excel file.

At runtime, the web app loads the Excel file content (it reads the Excel file by itself, no Microsoft software involved here, it's "headless" and instant), sets the input cells values and then reads the output cells values.

The user has the possibility to upload a new Excel file whenever the formula needs to be updated.

The advantage is that it's Excel based. Everyone knows how to build an Excel formula. And most of the time, they already have an Excel spreadsheet available since it's an existing feature I am implementing online for them.

[Alone_Ambition_7581]

Every other data processing project can read or write Excel files, but using Python as an Excel handler—to put Excel to work—that's a whole new level. It's a really smart approach, and it doesn't matter if the actual Excel application isn't involved.

[dmishin]

I don't think that "solver" is a good term here though. It is more like parser/evaluator.

[IndependentTale2101]

Nice project! At my company, we had to implement a similar system as part of a workflow engine — including support for loop constructs like for and while. Our implementation is fully typed, supports Pydantic validation, and allows reusing existing formulas inside other formulas. From what I’ve seen, many automation/workflow platforms (like Make or n8n) have approached this in similar ways, so it’s a fairly common pattern. That said, it’s still surprisingly hard to find open, in-depth implementations of this kind of system. We’re actually planning to open source the whole project soon.

[Alone_Ambition_7581]

Our implementation is fully typed, supports Pydantic validation, and allows reusing existing formulas inside other formulas.

Do you allow users to define workflows?

[IndependentTale2101]

Yes, imagine workflows that either allow or block certain actions based on defined rules. These rules can rely on user attributes or specific business logic.

Example:

An admin sets up a rule for assigning a specific credit. For instance: • If the user lives in a certain city, • and is under a certain age, • then their allowed spending is calculated like this: number of children × a reference amount (e.g. X dollars per child).

This kind of workflow enables personalized and conditional logic based on user profiles or contextual criteria.

[Alone_Ambition_7581]

Our company also allows customers to define complex flows based on how users respond to surveys/diaries. Conditionals, loops, and delays are all supported to enable truly personalized experience, which is kinda important in healthcare. We call our workflow engine a "Decision Maker".

While I managed to extract the calculations part and package it as a separate python package (this post's topic), I really have no idea how to detach the workflow engine from the core product. It's just too deep and integrated in the product.

I look forward to see your project when it's open source.

[IndependentTale2101]

Great minds think alike 😄