maykin-json-logic-py

json-logic-py

This parser accepts JsonLogic <http://jsonlogic.com>__ rules and executes them in Python.

This is a fork of json-logic-py <https://github.com/nadirizr/json-logic-py>__ by nadir.izr <https://github.com/nadirizr>, which is a Python porting of the GitHub project by jwadhams <https://github.com/jwadhams> for JavaScript: json-logic-js <https://github.com/jwadhams/json-logic-js>__.

The JsonLogic format is designed to allow you to share rules (logic) between front-end and back-end code (regardless of language difference), even to store logic along with a record in a database. JsonLogic is documented extensively at JsonLogic.com <http://jsonlogic.com>, including examples of every supported operation <http://jsonlogic.com/operations.html> and a place to try out rules in your browser <http://jsonlogic.com/play.html>__.

The same format can also be executed in PHP by the library json-logic-php <https://github.com/jwadhams/json-logic-php/>__

Examples

Simple

.. code:: python

    from json_logic import jsonLogic
    jsonLogic( { "==" : [1, 1] } )
    # True

This is a simple test, equivalent to ``1 == 1``. A few things about the
format:

1. The operator is always in the "key" position. There is only one key
   per JsonLogic rule.
2. The values are typically an array.
3. Each value can be a string, number, boolean, array (non-associative),
   or null

Compound

Here we're beginning to nest rules.

.. code:: python

jsonLogic(
  {"and" : [
    { ">" : [3,1] },
    { "<" : [1,3] }
  ] }
)
# True

In an infix language (like Python) this could be written as:

.. code:: python

( (3 > 1) and (1 < 3) )

Data-Driven

Obviously these rules aren't very interesting if they can only take
static literal data. Typically ``jsonLogic`` will be called with a rule
object and a data object. You can use the ``var`` operator to get
attributes of the data object:

.. code:: python

    jsonLogic(
      { "var" : ["a"] }, # Rule
      { a : 1, b : 2 }   # Data
    )
    # 1

If you like, we support `syntactic
sugar <https://en.wikipedia.org/wiki/Syntactic_sugar>`__ on unary
operators to skip the array around values:

.. code:: python

    jsonLogic(
      { "var" : "a" },
      { a : 1, b : 2 }
    )
    # 1

You can also use the ``var`` operator to access an array by numeric
index:

.. code:: python

    jsonLogic(
      {"var" : 1 },
      [ "apple", "banana", "carrot" ]
    )
    # "banana"

Here's a complex rule that mixes literals and data. The pie isn't ready
to eat unless it's cooler than 110 degrees, *and* filled with apples.

.. code:: python

    rules = { "and" : [
      {"<" : [ { "var" : "temp" }, 110 ]},
      {"==" : [ { "var" : "pie.filling" }, "apple" ] }
    ] }

    data = { "temp" : 100, "pie" : { "filling" : "apple" } }

    jsonLogic(rules, data)
    # True

Dates
~~~~~

You can use the ``date`` operator to include dates in the json logic. The dates are internally converted to ``datetime.date``
objects, and then the comparison is performed.

.. code:: python

    rule = {"<=": [{"date": {"var": "testDate"}}, {"date": "2021-01-01"}]}
    data = {"testDate": "2020-01-01"}

    jsonLogic(rule, data)
    # True


The operator ``{"today": []}`` gets the current date. It is also possible to add/subtract years to a date. This makes use
of ``relativedelta`` from ``dateutils``.

.. code:: python

    rule = {"-": [{"date": "2021-01-01"}, {"years": 18}]}

    jsonLogic(rule)
    # date(2003, 1, 1)


Datetimes
~~~~~~~~~

You can use the ``datetime`` operator to include datetimes in the json logic. The datetimes are internally converted to ``datetime.datetime``
objects, and then the comparison is performed.

.. code:: python

    rule = {
        "<=": [
            {"datetime": {"var": "testDatetime"}},
            {"datetime": "2022-12-01T10:00:00.000+02:00"},
        ]
    }
    data = {"testDatetime": "2022-11-01T10:00:00.000+02:00"}

    jsonLogic(rule, data)
    # True

Always and Never

Sometimes the rule you want to process is "Always" or "Never." If the first parameter passed to jsonLogic is a non-object, non-associative-array, it is returned immediately.

.. code:: python

#Always
jsonLogic(True, data_will_be_ignored);
# True

#Never
jsonLogic(False, i_wasnt_even_supposed_to_be_here);
# False

Installation

The best way to install this library is via PIP <https://pypi.python.org/pypi/>__:

.. code:: bash

pip install json-logic

If that doesn't suit you, and you want to manage updates yourself, the entire library is self-contained in json_logic.py and you can download it straight into your project as you see fit.

.. code:: bash

curl -O https://raw.githubusercontent.com/nadirizr/json-logic-py/master/json_logic.py