mathjson-solver 1.11.0__tar.gz → 1.12.0__tar.gz

mathjson_solver-1.12.0/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.2
+Name: mathjson-solver
+Version: 1.12.0
+Summary: Utilities for MathJSON evaluation
+Home-page: https://github.com/LongenesisLtd/mathjson-solver
+Author: Martins Mednis
+Author-email: mrt@mednis.info
+Project-URL: Bug Tracker, https://github.com/LongenesisLtd/mathjson-solver/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
+
+# MathJSON Solver
+
+[![PyPI](https://img.shields.io/pypi/v/mathjson-solver.svg)](https://pypi.org/project/mathjson-solver/)
+[![PyPI Downloads](https://static.pepy.tech/badge/mathjson-solver/month)](https://pepy.tech/projects/mathjson-solver)
+![Coverage](https://img.shields.io/badge/coverage-93-green)
+
+_MathJSON Solver_ is a Python module to numerically evaluate MathJSON expressions, like `["Add", 1, 2]`. It is developed by [Longenesis](https://longenesis.com/team) to enable numerical evaluation of user provided mathematical expressions in Longenesis digital health products. Its development was inspired by [CortexJS](https://cortexjs.io/compute-engine/) Compute Engine.
+
+Please ask questions and share feedback in our Gitter chat [https://gitter.im/mathjson-solver/community](https://gitter.im/mathjson-solver/community).
+[![Gitter](https://badges.gitter.im/mathjson-solver/community.svg)](https://gitter.im/mathjson-solver/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+
+## How to use
+```python
+from mathjson_solver import create_solver
+
+parameters = {"x": 2, "y": 3}
+expression = ["Add", "x", "y", 4]
+
+solver = create_solver(parameters)
+answer = solver(expression)
+
+print(answer)
+# 9, because 2+3+4=9
+```
+
+## Currently supported constructs
+Find the full list of supported constructs in the [docs/README.md](https://github.com/LongenesisLtd/mathjson-solver/blob/main/docs/README.md).
+
+
+## Exception handling
+
+A `MathJSONException` is raised when expression cannot be evaluated. Import `MathJSONException` to handle it:
+```python
+from mathjson_solver import create_solver, MathJSONException
+
+solver = create_solver({})
+try:
+    solver(["Divide", 1, 0])
+except MathJSONException:
+    pass
+    # invoke your own exception logger here
+```
+
+Left unhandled, the exception will look like `MathJSONException("Problem in Divide. ['Divide', 1, 0]. division by zero")`.
+
+
+## How to run tests
+Make sure you have `pytest` installed. Then `cd` into project directory and run:
+```bash
+pytest
+```
+
+## Contributing Code
+
+We welcome your contributions in the form of pull requests.
+
+1. Fork the repo;
+2. Make improvements;
+3. Make a pull request to share your improvements with the community and to include it into official release.

mathjson_solver-1.12.0/README.md

@@ -0,0 +1,59 @@
+# MathJSON Solver
+
+[![PyPI](https://img.shields.io/pypi/v/mathjson-solver.svg)](https://pypi.org/project/mathjson-solver/)
+[![PyPI Downloads](https://static.pepy.tech/badge/mathjson-solver/month)](https://pepy.tech/projects/mathjson-solver)
+![Coverage](https://img.shields.io/badge/coverage-93-green)
+
+_MathJSON Solver_ is a Python module to numerically evaluate MathJSON expressions, like `["Add", 1, 2]`. It is developed by [Longenesis](https://longenesis.com/team) to enable numerical evaluation of user provided mathematical expressions in Longenesis digital health products. Its development was inspired by [CortexJS](https://cortexjs.io/compute-engine/) Compute Engine.
+
+Please ask questions and share feedback in our Gitter chat [https://gitter.im/mathjson-solver/community](https://gitter.im/mathjson-solver/community).
+[![Gitter](https://badges.gitter.im/mathjson-solver/community.svg)](https://gitter.im/mathjson-solver/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+
+## How to use
+```python
+from mathjson_solver import create_solver
+
+parameters = {"x": 2, "y": 3}
+expression = ["Add", "x", "y", 4]
+
+solver = create_solver(parameters)
+answer = solver(expression)
+
+print(answer)
+# 9, because 2+3+4=9
+```
+
+## Currently supported constructs
+Find the full list of supported constructs in the [docs/README.md](https://github.com/LongenesisLtd/mathjson-solver/blob/main/docs/README.md).
+
+
+## Exception handling
+
+A `MathJSONException` is raised when expression cannot be evaluated. Import `MathJSONException` to handle it:
+```python
+from mathjson_solver import create_solver, MathJSONException
+
+solver = create_solver({})
+try:
+    solver(["Divide", 1, 0])
+except MathJSONException:
+    pass
+    # invoke your own exception logger here
+```
+
+Left unhandled, the exception will look like `MathJSONException("Problem in Divide. ['Divide', 1, 0]. division by zero")`.
+
+
+## How to run tests
+Make sure you have `pytest` installed. Then `cd` into project directory and run:
+```bash
+pytest
+```
+
+## Contributing Code
+
+We welcome your contributions in the form of pull requests.
+
+1. Fork the repo;
+2. Make improvements;
+3. Make a pull request to share your improvements with the community and to include it into official release.

{mathjson_solver-1.11.0 → mathjson_solver-1.12.0}/setup.cfg

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

{mathjson_solver-1.11.0 → mathjson_solver-1.12.0}/setup.py

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

{mathjson_solver-1.11.0 → mathjson_solver-1.12.0}/src/mathjson_solver/__main__.py

@@ -1,4 +1,5 @@
 import numbers
+from types import NoneType
 from typing import Union
 from functools import reduce
 import math
@@ -26,17 +27,17 @@ class MathJSONException(Exception):
         return f"Problem in {self.construct}. {self.expr}. {m}"
 
 
-def requires_array(func):
-    def inner1(*args, **kwargs):
-        try:
-            if args[0][1][0] == "Array" and len(args[0][1]) > 0:
-                return func(*args, **kwargs)
-            else:
-                raise ValueError(f"'{func.__name__}' should receive a list")
-        except TypeError:
-            raise ValueError(f"'{func.__name__}' really should receive a list")
+# def requires_array(func):
+#     def inner1(*args, **kwargs):
+#         try:
+#             if args[0][1][0] == "Array" and len(args[0][1]) > 0:
+#                 return func(*args, **kwargs)
+#             else:
+#                 raise ValueError(f"'{func.__name__}' should receive a list")
+#         except TypeError:
+#             raise ValueError(f"'{func.__name__}' really should receive a list")
 
-    return inner1
+#     return inner1
 
 
 def is_numeric(x):
@@ -92,40 +93,51 @@ def has_matching_sublist(
         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 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 comparison_safe_converter(x):
+    if type(x) in [int, float, str]:
+        return f"{x}"
+    elif type(x) in [bool, NoneType]:
+        if x:
+            return True
+        else:
+            return False
+    return x
 
 
 def create_mathjson_solver(solver_parameters):
@@ -177,14 +189,12 @@ def create_mathjson_solver(solver_parameters):
                         l_res.append(res)
                 return sum(l_res)
 
-            # @requires_array
             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))])
                 else:
                     return max([f(x, c) for x in s[1][1:] if is_numeric(f(x, c))])
 
-            # @requires_array
             def Min(s):
                 if isinstance(s[1], str):
                     return min([f(x, c) for x in f(s[1], c) if is_numeric(f(x, c))])
@@ -203,14 +213,12 @@ def create_mathjson_solver(solver_parameters):
                 except ZeroDivisionError:
                     return None
 
-            # @requires_array
             def Median(s):
                 if isinstance(s[1], str):
                     return median([f(x, c) for x in f(s[1], c) if is_numeric(f(x, c))])
                 else:
                     return median([f(x, c) for x in s[1][1:] if is_numeric(f(x, c))])
 
-            # @requires_array
             def Length(s):
                 if isinstance(s[1], str):
 
@@ -218,11 +226,9 @@ def create_mathjson_solver(solver_parameters):
                 else:
                     return len([x for x in s[1][1:]])
 
-            # @requires_array
             def Any(s):
                 return any([f(x, c) for x in s[1][1:]])
 
-            # @requires_array
             def All(s):
                 return all([f(x, c) for x in s[1][1:]])
 
@@ -397,6 +403,26 @@ def create_mathjson_solver(solver_parameters):
             def TimeDeltaWeeks(s):
                 return datetime.timedelta(weeks=f(s[1], c))
 
+            # def Equal(s):
+            #     a = comparison_safe_converter(f(s[1], c))
+            #     b = comparison_safe_converter(f(s[2], c))
+            #     return a == b
+            #     if type(a) in [int, float, str]:
+            #         a = f"{a}"
+            #     elif type(a) in [bool, NoneType]:
+            #         if a:
+            #             a = True
+            #         else:
+            #             a = None
+
+            #     if is_numeric(a):
+
+            #     lambda s: f"{f(s[1], c)}" == f"{f(s[2], c)}",
+
+            def IsDefined(s):
+                # Todo: This does not work
+                return s[1] in c.keys()
+
             constructs = {
                 "Sum": Sum,
                 "Add": Add,
@@ -419,7 +445,10 @@ def create_mathjson_solver(solver_parameters):
                 "Log": lambda s: math.log(f(s[1], c)),
                 "Log2": lambda s: math.log2(f(s[1], c)),
                 "Log10": lambda s: math.log10(f(s[1], c)),
-                "Equal": lambda s: f(s[1], c) == f(s[2], c),
+                # "Equal": lambda s: f"{f(s[1], c)}" == f"{f(s[2], c)}",
+                "Equal": lambda s: comparison_safe_converter(f(s[1], c))
+                == comparison_safe_converter(f(s[2], c)),
+                "StrictEqual": lambda s: f(s[1], c) == f(s[2], c),
                 "Greater": lambda s: f(s[1], c) > f(s[2], c),
                 "GreaterEqual": lambda s: f(s[1], c) >= f(s[2], c),
                 "Less": lambda s: f(s[1], c) < f(s[2], c),
@@ -452,7 +481,8 @@ def create_mathjson_solver(solver_parameters):
                 "Float": Float,
                 "Str": Str,
                 "Not": Not,
-                "IsDefined": lambda s: s[1] in c,
+                # "IsDefined": lambda s: s[1] in c,
+                "IsDefined": IsDefined,
                 "Map": Map,
                 "HasMatchingSublist": HasMatchingSublist,
                 "Strptime": Strptime,

mathjson_solver-1.12.0/src/mathjson_solver.egg-info/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.2
+Name: mathjson-solver
+Version: 1.12.0
+Summary: Utilities for MathJSON evaluation
+Home-page: https://github.com/LongenesisLtd/mathjson-solver
+Author: Martins Mednis
+Author-email: mrt@mednis.info
+Project-URL: Bug Tracker, https://github.com/LongenesisLtd/mathjson-solver/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
+
+# MathJSON Solver
+
+[![PyPI](https://img.shields.io/pypi/v/mathjson-solver.svg)](https://pypi.org/project/mathjson-solver/)
+[![PyPI Downloads](https://static.pepy.tech/badge/mathjson-solver/month)](https://pepy.tech/projects/mathjson-solver)
+![Coverage](https://img.shields.io/badge/coverage-93-green)
+
+_MathJSON Solver_ is a Python module to numerically evaluate MathJSON expressions, like `["Add", 1, 2]`. It is developed by [Longenesis](https://longenesis.com/team) to enable numerical evaluation of user provided mathematical expressions in Longenesis digital health products. Its development was inspired by [CortexJS](https://cortexjs.io/compute-engine/) Compute Engine.
+
+Please ask questions and share feedback in our Gitter chat [https://gitter.im/mathjson-solver/community](https://gitter.im/mathjson-solver/community).
+[![Gitter](https://badges.gitter.im/mathjson-solver/community.svg)](https://gitter.im/mathjson-solver/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+
+## How to use
+```python
+from mathjson_solver import create_solver
+
+parameters = {"x": 2, "y": 3}
+expression = ["Add", "x", "y", 4]
+
+solver = create_solver(parameters)
+answer = solver(expression)
+
+print(answer)
+# 9, because 2+3+4=9
+```
+
+## Currently supported constructs
+Find the full list of supported constructs in the [docs/README.md](https://github.com/LongenesisLtd/mathjson-solver/blob/main/docs/README.md).
+
+
+## Exception handling
+
+A `MathJSONException` is raised when expression cannot be evaluated. Import `MathJSONException` to handle it:
+```python
+from mathjson_solver import create_solver, MathJSONException
+
+solver = create_solver({})
+try:
+    solver(["Divide", 1, 0])
+except MathJSONException:
+    pass
+    # invoke your own exception logger here
+```
+
+Left unhandled, the exception will look like `MathJSONException("Problem in Divide. ['Divide', 1, 0]. division by zero")`.
+
+
+## How to run tests
+Make sure you have `pytest` installed. Then `cd` into project directory and run:
+```bash
+pytest
+```
+
+## Contributing Code
+
+We welcome your contributions in the form of pull requests.
+
+1. Fork the repo;
+2. Make improvements;
+3. Make a pull request to share your improvements with the community and to include it into official release.

{mathjson_solver-1.11.0 → mathjson_solver-1.12.0}/tests/test_with_pytest.py

@@ -16,6 +16,7 @@ from mathjson_solver import create_solver, MathJSONException, extract_variables
         ({}, ["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"], 2),
         ({"a": ["Array", 1, 1]}, ["Sum", "a", 4, 3], 9),
         ({}, ["Subtract", 10, 5, 2], 3),
         ({}, ["Add", 5, 4, ["Negate", 3]], 6),
@@ -36,6 +37,38 @@ from mathjson_solver import create_solver, MathJSONException, extract_variables
         ({}, ["Equal", 10, 12], False),
         ({}, ["Equal", "aaa", "aaa"], True),
         ({}, ["Equal", "aaa", "baa"], False),
+        ({}, ["Equal", "aaa", 11], False),
+        ({}, ["Equal", None, "1"], False),
+        ({}, ["Equal", 1, "1"], True),
+        ({}, ["Equal", None, False], True),
+
+        ({}, ["StrictEqual", 1, "1"], False),
+        ({}, ["StrictEqual", 10, 10], True),
+        ({}, ["StrictEqual", 10, 12], False),
+        ({}, ["StrictEqual", "aaa", "aaa"], True),
+        ({}, ["StrictEqual", "aaa", "baa"], False),
+        ({}, ["StrictEqual", "aaa", 11], False),
+        ({}, ["StrictEqual", None, "1"], False),
+        ({}, ["Equal", None, False], True),
+
+
+        ({}, ["Greater", 1, 2], False),
+        ({}, ["Greater", 2, -2], True),
+        ({}, ["GreaterEqual", 1, 1], True),
+        ({}, ["GreaterEqual", 2, 1], True),
+        ({}, ["GreaterEqual", 0, 0], True),
+        ({}, ["GreaterEqual", 1, 2], False),
+        ({}, ["Less", 1, 1], False),
+        ({}, ["Less", 1, 2], True),
+        ({}, ["LessEqual", 1, 1], True),
+        ({}, ["LessEqual", 1, 2], True),
+        # NotEqual
+        ({}, ["NotEqual", 1, 1], False),
+        ({}, ["NotEqual", 1, 2], True),
+        ({}, ["NotEqual", "aaa", "bbb"], True),
+        ({}, ["NotEqual", "aaa", 0], True),
+        # ({"a": 12}, ["IsDefined", "a"], True),
+        ({"a": 12}, ["IsDefined", "b"], False),
         ({}, ["Abs", -3.5], 3.5),
         ({}, ["Round", -5.123456, 2], -5.12),
         ({}, ["Round", -5.123456, 0], -5),
@@ -103,6 +136,12 @@ from mathjson_solver import create_solver, MathJSONException, extract_variables
         ({"color": "green"}, ["Switch", "color", 0, ["blue", 10], ["red", 30]], 0),
         ({"color": "green"}, ["Switch", "undefined", 0, ["blue", 10], ["red", 30]], 0),
         ({}, ["If", [["Equal", 1, 0], 10], [["Equal", 2, 2], 20], 9000], 20),
+        # # The following tests that If don't fail on incompatible data types
+        # ({}, ["If", [["Equal", 1, "1"], 10], [["Equal", "1", "1"], 20], -1], 20),
+
+        # ({"a": 1}, ["If", [["Equal", "a", "1"], 10], [["Equal", "a", 1], 20], -1], 20),
+        # ({"a": 1}, ["If", [["Equal", "a", 1], 10], [["Equal", "a", "1"], 20], -1], 10),
+
         ({"a": 10, "b": 10}, ["If", [["Equal", "a", "b"], 10], 9000], 10),
         ({"a": 10, "b": 20}, ["If", [["Equal", "a", "b"], 10], 9000], 9000),
         ({"a": 10}, ["If", [["Equal", "a", "b"], 10], 9000], 9000),
@@ -116,6 +155,7 @@ from mathjson_solver import create_solver, MathJSONException, extract_variables
         ({"a": ["Array", 2, 1, 3, 5, 2]}, ["Min", "a"], 1),
         ({}, ["Median", ["Array", 1, 2, 3, 5, 2]], 2),
         ({"a": ["Array", 1, 2, 3, 5, 2]}, ["Median", "a"], 2),
+        ({}, ["Average", ["Array", 2, "three", 4, "6"]], 4),
         ({}, ["Average", ["Array", 1, 2, 3, 5, 2]], 2.6),
         (
             {},

mathjson_solver-1.11.0/PKG-INFO

@@ -1,274 +0,0 @@
-Metadata-Version: 2.2
-Name: mathjson-solver
-Version: 1.11.0
-Summary: Utilities for MathJSON evaluation
-Home-page: https://github.com/LongenesisLtd/mathjson-solver
-Author: Martins Mednis
-Author-email: mrt@mednis.info
-Project-URL: Bug Tracker, https://github.com/LongenesisLtd/mathjson-solver/issues
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: project-url
-Dynamic: requires-python
-Dynamic: summary
-
-# MathJSON Solver
-
-[![Gitter](https://badges.gitter.im/mathjson-solver/community.svg)](https://gitter.im/mathjson-solver/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
-
-_MathJSON Solver_ is a Python module to numerically evaluate MathJSON expressions. It was created by [Longenesis](https://longenesis.com/team) to add numerical evaluation capability of user generated mathematical expressions in Longenesis digital health products and later released as open source project. Its development was inspired by [CortexJS](https://cortexjs.io/compute-engine/) Compute Engine.
-
-Please ask questions and share feedback in our Gitter chat [https://gitter.im/mathjson-solver/community](https://gitter.im/mathjson-solver/community).
-
-
-## How to use
-```python
-from mathjson_solver import create_solver
-
-parameters = {"x": 2, "y": 3}
-expression = ["Add", "x", "y", 4]
-
-solver = create_solver(parameters)
-answer = solver(expression)
-
-print(answer)
-# 9, because 2+3+4=9
-```
-
-## Currently supported constructs
-* `Add` - Iteratively adds up the given values. Compatible with time delta.
-* `Sum` - Internally uses python's `sum`. Not compatible with time delta.
-* `Subtract` -
-* `Constants` -
-* `Switch` -
-* `If` -
-* `Multiply` -
-* `Divide` -
-* `Negate` -
-* `Power` -
-* `Root` -
-* `Sqrt` -
-* `Square` -
-* `Exp` -
-* `Log` -
-* `Log2` -
-* `Log10` -
-* `Equal` -
-* `Greater` -
-* `GreaterEqual` -
-* `Less` -
-* `LessEqual` -
-* `NotEqual` -
-* `Abs` -
-* `Round` -
-* `Max` -
-* `Min` -
-* `Average` - Internally tries to convert strings to numbers, making calculation of average from `[2, 4 ,"6"]` actually possible. Also, it ignores un-convertible elements so arrays like `[2, "three", 4 ,"6"]` don't crash the solver.
-* `Median` -
-* `Length` -
-* `Any` -
-* `All` -
-* `Array` -
-* `In` -
-* `Not_in` -
-* `Contains_any_of` -
-* `Contains_all_of` -
-* `Contains_none_of` -
-* `NotIn` -
-* `ContainsAnyOf` -
-* `ContainsAllOf` -
-* `ContainsNoneOf` -
-* `Int` -
-* `Float` -
-* `Str` -
-* `Not` -
-* `IsDefined` - Checks if a value is in parameters.
-* `Map` -
-* `HasMatchingSublist` -
-* `Strptime` -
-* `Strftime` -
-* `Today` -
-* `Now` -
-* `TimeDeltaWeeks` -
-* `TimeDeltaHours` -
-* `TimeDeltaMinutes` -
-* `TimeDeltaDays` -
-
-## Examples
-```python
-["Add", 2, 4, 3]                  # 2+4+3=9
-["Subtract", 10, 5, 2]            # 10-5-2=3
-["Add", 5, 4, ["Negate", 3]]      # 5+4+(-3)=6
-["Multiply", 2, 3, 4]             # 2*3*4=24
-["Divide", 10, 5]                 # 10/5=2.0
-["Divide", 10, 4]                 # 10/4=2.5
-["Power", 2, 3]                   # 2^3=8
-["Root", 9, 2]                    # √9=3.0
-["Root", 8, 3]                    # ∛8=2.0
-["Sqrt", 9]                       # √9=3.0
-["Square", 4]                     # 4^2=16
-["Exp", 2]                        # e^2≅7.389
-["Divide", 10, ["Add", 2+3]]      # 10/(2+3)=10/5=2
-["Log", 2.7183]                   # ln(2.7183)≅1.0000
-["Log2", 8]                       # log2(8)=3.0
-["Log10", 1000]                   # log10(1000)=3.0
-["Equal", 10, 10]                 # 10==10 = True
-["Equal", 10, 12]                 # 10==12 = False
-["Abs", -3.5]                     # |-3.5| = 3.5
-["Round", -5.123456, 2]           # -5.12
-["Round", -5.123456, 0]           # -5.0
-["Round", -5.123456]              # -5
-["Array", 1, 2]                   # ["Array", 1, 2]
-
-["Max", ["Array", 1, 2, 3, 5, 2]] # 5
-["Max", ["Array", 1, 2, ["Sum", 2, 4, 3], 5, 2]]  # 9
-["Median", ["Array", 1, 2, 3, 5, 2]]              # 2
-["Average", ["Array", 1, 2, 3, 5, 2]]             # 2.6
-["Average", ["Array"]]                            # None
-
-["Length", ["Array", 1, 2, 3, 5, 2, 9]]           # 6
-["Length", ["Array"]]                             # 0
-["Any", ["Array", 0, 0, False, 0, 0]]             # False
-["Any", ["Array", 0, 1, False, 0, 0]]             # True
-["All", ["Array", 0, 1, False, 0, 0]]             # False
-["All", ["Array", 0, 1, False, "", 0]]            # False
-["All", ["Array", 2, 1, True, "zz", 2]]           # True
-["Int", "12"]                     # 12
-["Int", "12.2"]                   # 12
-["Float", "12.2"]                 # 12.2
-["Str", 12]                       # "12"
-["Str", "12"]                     # "12"
-["Str", "aabb"]                   # "aabb"
-["Not", True]                      # False
-["Not", 0]                         # True
-
-["In", 2, ["Array", 1, 2, 3]]     # True
-["In", 4, ["Array", 1, 2, 3]]     # False
-["ContainsAnyOf", ["Array", 1, 2, 3], ["Array", 3, 4, 5, 6]]     # True
-["ContainsAnyOf", ["Array", 1, 2, 3], ["Array", 4, 5, 6]]        # False
-["ContainsAllOf", ["Array", 1, 2, 3], ["Array", 1, 2, 3]]        # True
-["ContainsAllOf", ["Array", 1, 2], ["Array", 1, 2, 3]]           # False
-```
-
-### Constants
-```
-[
-    "Constants",
-    ["constant_name1", <expression>],
-    ["constant_name2", <expression>],
-    ["constant_name3", <expression>],
-    ...,
-    <expression>
-]
-```
-
-`Constants` construct consists of keyword "Constants" followed by arbitrary number of name&value pairs. The last element in `Constants` construct is the expression to calculate using the defined constants.
-
-The following example has two constants defined - `x=10` and `y=20`. Then the sum of these two constants is calculated and returned.
-
-
-```python
-[
-    "Constants",
-    ["x", 10],
-    ["y", 20],
-    ["Add","x", "y"]
-]
-```
-
-
-### If statement
-```
-[
-    "If",
-    [
-        <true-or-false-expression>,
-        <expression-to-calculate>
-    ],
-    [
-        <elseif-true-or-false-expression>,
-        <expression-to-calculate>
-    ],
-    ...,
-    <else-expression-to-calculate>
-]
-```
-
-Example
-```python
-[
-    "If",
-    [
-        ["Equal", 1, 0],
-        10
-    ],
-    [
-        ["Equal", 2, 2],
-        20
-    ],
-    9000
-]
-```
-This construct translates to:
-```
-if   1 == 0 then 10
-elif 2 == 2 then 20
-else 9000
-```
-
-`If` expressions do not need to be strictly _boolean_. Any value that is not _false_ are considered _true_.
-
-### Switch-Case statement
-```
-["Switch", <on-expression>, <default-result-expression>, [<case1-expression>, <result-expression>], ...],
-```
-
-`Switch` construct consists of keyword "Switch" followed by expression whose value will be compared to _Cases'_ values. Then comes the default value. Then follows arbitrary number of _Cases_.
-
-Example  
-```python
-["Switch", "color", 100, ["red", 10], ["blue", 20], ["green", 30]],
-```
-The expression in this example will make solver to look for a constant (or a parameter) with the name "color". If "color" is "red", expression evaluates to 10, if "blue" - to 20, if "green" - to 30. Otherwise to 100. Please note that "color" here is a valid expression that evaluates to the actual value of "color" whether it is a parameter or constant.
-
-
-## Exception handling
-
-A `MathJSONException` is raised when expression cannot be evaluated. Import `MathJSONException` to handle it:
-```python
-from mathjson_solver import create_solver, MathJSONException
-
-solver = create_solver({})
-try:
-    solver(["Divide", 1, 0])
-except MathJSONException:
-    pass
-    # invoke your own exception logger here
-```
-
-Left unhandled, the exception will look like `MathJSONException("Problem in Divide. ['Divide', 1, 0]. division by zero")`.
-
-
-## How to run tests
-Make sure you have `pytest` installed. Then `cd` into project directory and run:
-```bash
-pytest
-```
-
-## Contributing Code
-
-We welcome your contributions in the form of pull requests.
-
-1. Fork the repo;
-2. Make improvements;
-3. Make a pull request to share your improvements with the community and to include it into official release.

mathjson_solver-1.11.0/README.md

@@ -1,250 +0,0 @@
-# MathJSON Solver
-
-[![Gitter](https://badges.gitter.im/mathjson-solver/community.svg)](https://gitter.im/mathjson-solver/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
-
-_MathJSON Solver_ is a Python module to numerically evaluate MathJSON expressions. It was created by [Longenesis](https://longenesis.com/team) to add numerical evaluation capability of user generated mathematical expressions in Longenesis digital health products and later released as open source project. Its development was inspired by [CortexJS](https://cortexjs.io/compute-engine/) Compute Engine.
-
-Please ask questions and share feedback in our Gitter chat [https://gitter.im/mathjson-solver/community](https://gitter.im/mathjson-solver/community).
-
-
-## How to use
-```python
-from mathjson_solver import create_solver
-
-parameters = {"x": 2, "y": 3}
-expression = ["Add", "x", "y", 4]
-
-solver = create_solver(parameters)
-answer = solver(expression)
-
-print(answer)
-# 9, because 2+3+4=9
-```
-
-## Currently supported constructs
-* `Add` - Iteratively adds up the given values. Compatible with time delta.
-* `Sum` - Internally uses python's `sum`. Not compatible with time delta.
-* `Subtract` -
-* `Constants` -
-* `Switch` -
-* `If` -
-* `Multiply` -
-* `Divide` -
-* `Negate` -
-* `Power` -
-* `Root` -
-* `Sqrt` -
-* `Square` -
-* `Exp` -
-* `Log` -
-* `Log2` -
-* `Log10` -
-* `Equal` -
-* `Greater` -
-* `GreaterEqual` -
-* `Less` -
-* `LessEqual` -
-* `NotEqual` -
-* `Abs` -
-* `Round` -
-* `Max` -
-* `Min` -
-* `Average` - Internally tries to convert strings to numbers, making calculation of average from `[2, 4 ,"6"]` actually possible. Also, it ignores un-convertible elements so arrays like `[2, "three", 4 ,"6"]` don't crash the solver.
-* `Median` -
-* `Length` -
-* `Any` -
-* `All` -
-* `Array` -
-* `In` -
-* `Not_in` -
-* `Contains_any_of` -
-* `Contains_all_of` -
-* `Contains_none_of` -
-* `NotIn` -
-* `ContainsAnyOf` -
-* `ContainsAllOf` -
-* `ContainsNoneOf` -
-* `Int` -
-* `Float` -
-* `Str` -
-* `Not` -
-* `IsDefined` - Checks if a value is in parameters.
-* `Map` -
-* `HasMatchingSublist` -
-* `Strptime` -
-* `Strftime` -
-* `Today` -
-* `Now` -
-* `TimeDeltaWeeks` -
-* `TimeDeltaHours` -
-* `TimeDeltaMinutes` -
-* `TimeDeltaDays` -
-
-## Examples
-```python
-["Add", 2, 4, 3]                  # 2+4+3=9
-["Subtract", 10, 5, 2]            # 10-5-2=3
-["Add", 5, 4, ["Negate", 3]]      # 5+4+(-3)=6
-["Multiply", 2, 3, 4]             # 2*3*4=24
-["Divide", 10, 5]                 # 10/5=2.0
-["Divide", 10, 4]                 # 10/4=2.5
-["Power", 2, 3]                   # 2^3=8
-["Root", 9, 2]                    # √9=3.0
-["Root", 8, 3]                    # ∛8=2.0
-["Sqrt", 9]                       # √9=3.0
-["Square", 4]                     # 4^2=16
-["Exp", 2]                        # e^2≅7.389
-["Divide", 10, ["Add", 2+3]]      # 10/(2+3)=10/5=2
-["Log", 2.7183]                   # ln(2.7183)≅1.0000
-["Log2", 8]                       # log2(8)=3.0
-["Log10", 1000]                   # log10(1000)=3.0
-["Equal", 10, 10]                 # 10==10 = True
-["Equal", 10, 12]                 # 10==12 = False
-["Abs", -3.5]                     # |-3.5| = 3.5
-["Round", -5.123456, 2]           # -5.12
-["Round", -5.123456, 0]           # -5.0
-["Round", -5.123456]              # -5
-["Array", 1, 2]                   # ["Array", 1, 2]
-
-["Max", ["Array", 1, 2, 3, 5, 2]] # 5
-["Max", ["Array", 1, 2, ["Sum", 2, 4, 3], 5, 2]]  # 9
-["Median", ["Array", 1, 2, 3, 5, 2]]              # 2
-["Average", ["Array", 1, 2, 3, 5, 2]]             # 2.6
-["Average", ["Array"]]                            # None
-
-["Length", ["Array", 1, 2, 3, 5, 2, 9]]           # 6
-["Length", ["Array"]]                             # 0
-["Any", ["Array", 0, 0, False, 0, 0]]             # False
-["Any", ["Array", 0, 1, False, 0, 0]]             # True
-["All", ["Array", 0, 1, False, 0, 0]]             # False
-["All", ["Array", 0, 1, False, "", 0]]            # False
-["All", ["Array", 2, 1, True, "zz", 2]]           # True
-["Int", "12"]                     # 12
-["Int", "12.2"]                   # 12
-["Float", "12.2"]                 # 12.2
-["Str", 12]                       # "12"
-["Str", "12"]                     # "12"
-["Str", "aabb"]                   # "aabb"
-["Not", True]                      # False
-["Not", 0]                         # True
-
-["In", 2, ["Array", 1, 2, 3]]     # True
-["In", 4, ["Array", 1, 2, 3]]     # False
-["ContainsAnyOf", ["Array", 1, 2, 3], ["Array", 3, 4, 5, 6]]     # True
-["ContainsAnyOf", ["Array", 1, 2, 3], ["Array", 4, 5, 6]]        # False
-["ContainsAllOf", ["Array", 1, 2, 3], ["Array", 1, 2, 3]]        # True
-["ContainsAllOf", ["Array", 1, 2], ["Array", 1, 2, 3]]           # False
-```
-
-### Constants
-```
-[
-    "Constants",
-    ["constant_name1", <expression>],
-    ["constant_name2", <expression>],
-    ["constant_name3", <expression>],
-    ...,
-    <expression>
-]
-```
-
-`Constants` construct consists of keyword "Constants" followed by arbitrary number of name&value pairs. The last element in `Constants` construct is the expression to calculate using the defined constants.
-
-The following example has two constants defined - `x=10` and `y=20`. Then the sum of these two constants is calculated and returned.
-
-
-```python
-[
-    "Constants",
-    ["x", 10],
-    ["y", 20],
-    ["Add","x", "y"]
-]
-```
-
-
-### If statement
-```
-[
-    "If",
-    [
-        <true-or-false-expression>,
-        <expression-to-calculate>
-    ],
-    [
-        <elseif-true-or-false-expression>,
-        <expression-to-calculate>
-    ],
-    ...,
-    <else-expression-to-calculate>
-]
-```
-
-Example
-```python
-[
-    "If",
-    [
-        ["Equal", 1, 0],
-        10
-    ],
-    [
-        ["Equal", 2, 2],
-        20
-    ],
-    9000
-]
-```
-This construct translates to:
-```
-if   1 == 0 then 10
-elif 2 == 2 then 20
-else 9000
-```
-
-`If` expressions do not need to be strictly _boolean_. Any value that is not _false_ are considered _true_.
-
-### Switch-Case statement
-```
-["Switch", <on-expression>, <default-result-expression>, [<case1-expression>, <result-expression>], ...],
-```
-
-`Switch` construct consists of keyword "Switch" followed by expression whose value will be compared to _Cases'_ values. Then comes the default value. Then follows arbitrary number of _Cases_.
-
-Example  
-```python
-["Switch", "color", 100, ["red", 10], ["blue", 20], ["green", 30]],
-```
-The expression in this example will make solver to look for a constant (or a parameter) with the name "color". If "color" is "red", expression evaluates to 10, if "blue" - to 20, if "green" - to 30. Otherwise to 100. Please note that "color" here is a valid expression that evaluates to the actual value of "color" whether it is a parameter or constant.
-
-
-## Exception handling
-
-A `MathJSONException` is raised when expression cannot be evaluated. Import `MathJSONException` to handle it:
-```python
-from mathjson_solver import create_solver, MathJSONException
-
-solver = create_solver({})
-try:
-    solver(["Divide", 1, 0])
-except MathJSONException:
-    pass
-    # invoke your own exception logger here
-```
-
-Left unhandled, the exception will look like `MathJSONException("Problem in Divide. ['Divide', 1, 0]. division by zero")`.
-
-
-## How to run tests
-Make sure you have `pytest` installed. Then `cd` into project directory and run:
-```bash
-pytest
-```
-
-## Contributing Code
-
-We welcome your contributions in the form of pull requests.
-
-1. Fork the repo;
-2. Make improvements;
-3. Make a pull request to share your improvements with the community and to include it into official release.

mathjson_solver-1.11.0/src/mathjson_solver.egg-info/PKG-INFO

@@ -1,274 +0,0 @@
-Metadata-Version: 2.2
-Name: mathjson-solver
-Version: 1.11.0
-Summary: Utilities for MathJSON evaluation
-Home-page: https://github.com/LongenesisLtd/mathjson-solver
-Author: Martins Mednis
-Author-email: mrt@mednis.info
-Project-URL: Bug Tracker, https://github.com/LongenesisLtd/mathjson-solver/issues
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: project-url
-Dynamic: requires-python
-Dynamic: summary
-
-# MathJSON Solver
-
-[![Gitter](https://badges.gitter.im/mathjson-solver/community.svg)](https://gitter.im/mathjson-solver/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
-
-_MathJSON Solver_ is a Python module to numerically evaluate MathJSON expressions. It was created by [Longenesis](https://longenesis.com/team) to add numerical evaluation capability of user generated mathematical expressions in Longenesis digital health products and later released as open source project. Its development was inspired by [CortexJS](https://cortexjs.io/compute-engine/) Compute Engine.
-
-Please ask questions and share feedback in our Gitter chat [https://gitter.im/mathjson-solver/community](https://gitter.im/mathjson-solver/community).
-
-
-## How to use
-```python
-from mathjson_solver import create_solver
-
-parameters = {"x": 2, "y": 3}
-expression = ["Add", "x", "y", 4]
-
-solver = create_solver(parameters)
-answer = solver(expression)
-
-print(answer)
-# 9, because 2+3+4=9
-```
-
-## Currently supported constructs
-* `Add` - Iteratively adds up the given values. Compatible with time delta.
-* `Sum` - Internally uses python's `sum`. Not compatible with time delta.
-* `Subtract` -
-* `Constants` -
-* `Switch` -
-* `If` -
-* `Multiply` -
-* `Divide` -
-* `Negate` -
-* `Power` -
-* `Root` -
-* `Sqrt` -
-* `Square` -
-* `Exp` -
-* `Log` -
-* `Log2` -
-* `Log10` -
-* `Equal` -
-* `Greater` -
-* `GreaterEqual` -
-* `Less` -
-* `LessEqual` -
-* `NotEqual` -
-* `Abs` -
-* `Round` -
-* `Max` -
-* `Min` -
-* `Average` - Internally tries to convert strings to numbers, making calculation of average from `[2, 4 ,"6"]` actually possible. Also, it ignores un-convertible elements so arrays like `[2, "three", 4 ,"6"]` don't crash the solver.
-* `Median` -
-* `Length` -
-* `Any` -
-* `All` -
-* `Array` -
-* `In` -
-* `Not_in` -
-* `Contains_any_of` -
-* `Contains_all_of` -
-* `Contains_none_of` -
-* `NotIn` -
-* `ContainsAnyOf` -
-* `ContainsAllOf` -
-* `ContainsNoneOf` -
-* `Int` -
-* `Float` -
-* `Str` -
-* `Not` -
-* `IsDefined` - Checks if a value is in parameters.
-* `Map` -
-* `HasMatchingSublist` -
-* `Strptime` -
-* `Strftime` -
-* `Today` -
-* `Now` -
-* `TimeDeltaWeeks` -
-* `TimeDeltaHours` -
-* `TimeDeltaMinutes` -
-* `TimeDeltaDays` -
-
-## Examples
-```python
-["Add", 2, 4, 3]                  # 2+4+3=9
-["Subtract", 10, 5, 2]            # 10-5-2=3
-["Add", 5, 4, ["Negate", 3]]      # 5+4+(-3)=6
-["Multiply", 2, 3, 4]             # 2*3*4=24
-["Divide", 10, 5]                 # 10/5=2.0
-["Divide", 10, 4]                 # 10/4=2.5
-["Power", 2, 3]                   # 2^3=8
-["Root", 9, 2]                    # √9=3.0
-["Root", 8, 3]                    # ∛8=2.0
-["Sqrt", 9]                       # √9=3.0
-["Square", 4]                     # 4^2=16
-["Exp", 2]                        # e^2≅7.389
-["Divide", 10, ["Add", 2+3]]      # 10/(2+3)=10/5=2
-["Log", 2.7183]                   # ln(2.7183)≅1.0000
-["Log2", 8]                       # log2(8)=3.0
-["Log10", 1000]                   # log10(1000)=3.0
-["Equal", 10, 10]                 # 10==10 = True
-["Equal", 10, 12]                 # 10==12 = False
-["Abs", -3.5]                     # |-3.5| = 3.5
-["Round", -5.123456, 2]           # -5.12
-["Round", -5.123456, 0]           # -5.0
-["Round", -5.123456]              # -5
-["Array", 1, 2]                   # ["Array", 1, 2]
-
-["Max", ["Array", 1, 2, 3, 5, 2]] # 5
-["Max", ["Array", 1, 2, ["Sum", 2, 4, 3], 5, 2]]  # 9
-["Median", ["Array", 1, 2, 3, 5, 2]]              # 2
-["Average", ["Array", 1, 2, 3, 5, 2]]             # 2.6
-["Average", ["Array"]]                            # None
-
-["Length", ["Array", 1, 2, 3, 5, 2, 9]]           # 6
-["Length", ["Array"]]                             # 0
-["Any", ["Array", 0, 0, False, 0, 0]]             # False
-["Any", ["Array", 0, 1, False, 0, 0]]             # True
-["All", ["Array", 0, 1, False, 0, 0]]             # False
-["All", ["Array", 0, 1, False, "", 0]]            # False
-["All", ["Array", 2, 1, True, "zz", 2]]           # True
-["Int", "12"]                     # 12
-["Int", "12.2"]                   # 12
-["Float", "12.2"]                 # 12.2
-["Str", 12]                       # "12"
-["Str", "12"]                     # "12"
-["Str", "aabb"]                   # "aabb"
-["Not", True]                      # False
-["Not", 0]                         # True
-
-["In", 2, ["Array", 1, 2, 3]]     # True
-["In", 4, ["Array", 1, 2, 3]]     # False
-["ContainsAnyOf", ["Array", 1, 2, 3], ["Array", 3, 4, 5, 6]]     # True
-["ContainsAnyOf", ["Array", 1, 2, 3], ["Array", 4, 5, 6]]        # False
-["ContainsAllOf", ["Array", 1, 2, 3], ["Array", 1, 2, 3]]        # True
-["ContainsAllOf", ["Array", 1, 2], ["Array", 1, 2, 3]]           # False
-```
-
-### Constants
-```
-[
-    "Constants",
-    ["constant_name1", <expression>],
-    ["constant_name2", <expression>],
-    ["constant_name3", <expression>],
-    ...,
-    <expression>
-]
-```
-
-`Constants` construct consists of keyword "Constants" followed by arbitrary number of name&value pairs. The last element in `Constants` construct is the expression to calculate using the defined constants.
-
-The following example has two constants defined - `x=10` and `y=20`. Then the sum of these two constants is calculated and returned.
-
-
-```python
-[
-    "Constants",
-    ["x", 10],
-    ["y", 20],
-    ["Add","x", "y"]
-]
-```
-
-
-### If statement
-```
-[
-    "If",
-    [
-        <true-or-false-expression>,
-        <expression-to-calculate>
-    ],
-    [
-        <elseif-true-or-false-expression>,
-        <expression-to-calculate>
-    ],
-    ...,
-    <else-expression-to-calculate>
-]
-```
-
-Example
-```python
-[
-    "If",
-    [
-        ["Equal", 1, 0],
-        10
-    ],
-    [
-        ["Equal", 2, 2],
-        20
-    ],
-    9000
-]
-```
-This construct translates to:
-```
-if   1 == 0 then 10
-elif 2 == 2 then 20
-else 9000
-```
-
-`If` expressions do not need to be strictly _boolean_. Any value that is not _false_ are considered _true_.
-
-### Switch-Case statement
-```
-["Switch", <on-expression>, <default-result-expression>, [<case1-expression>, <result-expression>], ...],
-```
-
-`Switch` construct consists of keyword "Switch" followed by expression whose value will be compared to _Cases'_ values. Then comes the default value. Then follows arbitrary number of _Cases_.
-
-Example  
-```python
-["Switch", "color", 100, ["red", 10], ["blue", 20], ["green", 30]],
-```
-The expression in this example will make solver to look for a constant (or a parameter) with the name "color". If "color" is "red", expression evaluates to 10, if "blue" - to 20, if "green" - to 30. Otherwise to 100. Please note that "color" here is a valid expression that evaluates to the actual value of "color" whether it is a parameter or constant.
-
-
-## Exception handling
-
-A `MathJSONException` is raised when expression cannot be evaluated. Import `MathJSONException` to handle it:
-```python
-from mathjson_solver import create_solver, MathJSONException
-
-solver = create_solver({})
-try:
-    solver(["Divide", 1, 0])
-except MathJSONException:
-    pass
-    # invoke your own exception logger here
-```
-
-Left unhandled, the exception will look like `MathJSONException("Problem in Divide. ['Divide', 1, 0]. division by zero")`.
-
-
-## How to run tests
-Make sure you have `pytest` installed. Then `cd` into project directory and run:
-```bash
-pytest
-```
-
-## Contributing Code
-
-We welcome your contributions in the form of pull requests.
-
-1. Fork the repo;
-2. Make improvements;
-3. Make a pull request to share your improvements with the community and to include it into official release.