python-jsonlogic 0.0.1__tar.gz → 0.1.0__tar.gz

python_jsonlogic-0.1.0/PKG-INFO

@@ -0,0 +1,141 @@
+Metadata-Version: 2.1
+Name: python-jsonlogic
+Version: 0.1.0
+Summary: An extensible and sane implementation of JsonLogic
+Author-email: Victorien <contact@vctrn.dev>
+License: MIT License
+        
+        Copyright (c) 2024 Victorien
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Classifier: Development Status :: 4 - Beta
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: typing-extensions>=4.10.0; python_version < "3.13"
+
+================
+python-jsonlogic
+================
+
+|Pythons| |PyPI| |Ruff|
+
+.. |Pythons| image:: https://img.shields.io/pypi/pyversions/python-jsonlogic.svg
+  :alt: Supported Python versions
+  :target: https://pypi.org/project/python-jsonlogic/
+
+.. |PyPI| image:: https://img.shields.io/pypi/v/python-jsonlogic.svg
+  :alt: PyPI - Version
+  :target: https://pypi.org/project/python-jsonlogic/
+
+.. |Ruff| image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json
+  :alt: PyPI - Version
+  :target: https://github.com/astral-sh/ruff
+
+``python-jsonlogic`` is an extensible and sane implementation of `JsonLogic`_, making use of the `JSON Schema`_ specification.
+
+.. _`JSON Schema`: https://json-schema.org/
+
+Motivation
+----------
+
+While the `JsonLogic`_ format can be great to serialize logic, it lacks a formal specification
+and some aspects are unclear/unspecified:
+
+* `operators <https://jsonlogic.com/operations.html>`_ arguments can take any value. For instance,
+  `comparison operators <https://jsonlogic.com/operations.html#---and->`_ are said to work with "numeric" values,
+  however the `JavaScript playground <https://jsonlogic.com/play.html>`_ doesn't validate inputs. It is
+  also convenient to allow such comparison operators for date and datetime objects as well.
+* Operators `accessing data <https://jsonlogic.com/operations.html#accessing-data>`_ use a dot-like notation,
+  which is ambiguous when dealing with keys such as ``my.key``.
+* Operators such as `map <https://jsonlogic.com/operations.html#map-reduce-and-filter>`_ provides their own data scope,
+  making it impossible to access higher-level data inside the operator expression.
+
+For these reasons, ``python-jsonlogic`` provides a way to typecheck your JSON Logic expressions at "compile" time,
+before applying input data to them.
+
+.. _`JsonLogic`: https://jsonlogic.com/
+
+Installation
+------------
+
+From PyPI:
+
+.. code:: bash
+
+    pip install python-jsonlogic
+
+The library can be imported from the ``jsonlogic`` module.
+
+Usage
+-----
+
+.. code-block:: python
+
+    # 1. Create or use an already existing operator registry:
+    from jsonlogic.operators import operator_registry
+
+    # 2. Parse the JSON Logic expression:
+    from jsonlogic import JSONLogicExpression
+
+    expr = JSONLogicExpression.from_json({"map": [
+        [1, 2],
+        {"*": [{"var": ""}, {"var": "/my_int@1"}]},
+    ]})
+
+    # 3. Create an operator tree:
+    root_op = expr.as_operator_tree(operator_registry)
+
+    # 4. Typecheck the expression:
+    from jsonlogic.typechecking import typecheck
+
+    typ, diagnostics = typecheck(
+        root_op,
+        data_schema={
+          "type": "object",
+          "properties": {
+                "my_int": {"type": "integer"}
+            },
+        }
+    )
+    print(typ)
+    #> ArrayType(IntegerType())
+
+    # 5. Evaluate with data:
+    from jsonlogic.evaluation import evaluate
+    value = evaluate(
+        root_op,
+        data={"my_int": 2},
+        data_schema=None,
+    )
+    print(value)
+    #> [2, 4]

python_jsonlogic-0.1.0/README.rst

@@ -0,0 +1,96 @@
+================
+python-jsonlogic
+================
+
+|Pythons| |PyPI| |Ruff|
+
+.. |Pythons| image:: https://img.shields.io/pypi/pyversions/python-jsonlogic.svg
+  :alt: Supported Python versions
+  :target: https://pypi.org/project/python-jsonlogic/
+
+.. |PyPI| image:: https://img.shields.io/pypi/v/python-jsonlogic.svg
+  :alt: PyPI - Version
+  :target: https://pypi.org/project/python-jsonlogic/
+
+.. |Ruff| image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json
+  :alt: PyPI - Version
+  :target: https://github.com/astral-sh/ruff
+
+``python-jsonlogic`` is an extensible and sane implementation of `JsonLogic`_, making use of the `JSON Schema`_ specification.
+
+.. _`JSON Schema`: https://json-schema.org/
+
+Motivation
+----------
+
+While the `JsonLogic`_ format can be great to serialize logic, it lacks a formal specification
+and some aspects are unclear/unspecified:
+
+* `operators <https://jsonlogic.com/operations.html>`_ arguments can take any value. For instance,
+  `comparison operators <https://jsonlogic.com/operations.html#---and->`_ are said to work with "numeric" values,
+  however the `JavaScript playground <https://jsonlogic.com/play.html>`_ doesn't validate inputs. It is
+  also convenient to allow such comparison operators for date and datetime objects as well.
+* Operators `accessing data <https://jsonlogic.com/operations.html#accessing-data>`_ use a dot-like notation,
+  which is ambiguous when dealing with keys such as ``my.key``.
+* Operators such as `map <https://jsonlogic.com/operations.html#map-reduce-and-filter>`_ provides their own data scope,
+  making it impossible to access higher-level data inside the operator expression.
+
+For these reasons, ``python-jsonlogic`` provides a way to typecheck your JSON Logic expressions at "compile" time,
+before applying input data to them.
+
+.. _`JsonLogic`: https://jsonlogic.com/
+
+Installation
+------------
+
+From PyPI:
+
+.. code:: bash
+
+    pip install python-jsonlogic
+
+The library can be imported from the ``jsonlogic`` module.
+
+Usage
+-----
+
+.. code-block:: python
+
+    # 1. Create or use an already existing operator registry:
+    from jsonlogic.operators import operator_registry
+
+    # 2. Parse the JSON Logic expression:
+    from jsonlogic import JSONLogicExpression
+
+    expr = JSONLogicExpression.from_json({"map": [
+        [1, 2],
+        {"*": [{"var": ""}, {"var": "/my_int@1"}]},
+    ]})
+
+    # 3. Create an operator tree:
+    root_op = expr.as_operator_tree(operator_registry)
+
+    # 4. Typecheck the expression:
+    from jsonlogic.typechecking import typecheck
+
+    typ, diagnostics = typecheck(
+        root_op,
+        data_schema={
+          "type": "object",
+          "properties": {
+                "my_int": {"type": "integer"}
+            },
+        }
+    )
+    print(typ)
+    #> ArrayType(IntegerType())
+
+    # 5. Evaluate with data:
+    from jsonlogic.evaluation import evaluate
+    value = evaluate(
+        root_op,
+        data={"my_int": 2},
+        data_schema=None,
+    )
+    print(value)
+    #> [2, 4]

{python-jsonlogic-0.0.1 → python_jsonlogic-0.1.0}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "python-jsonlogic"
 description = "An extensible and sane implementation of JsonLogic"
-version = "0.0.1"
+version = "0.1.0"
 readme = "README.rst"
 authors = [
     {name = "Victorien", email = "contact@vctrn.dev"}
@@ -28,7 +28,7 @@ classifiers = [
 license = {file = "LICENSE"}
 requires-python = ">=3.8"
 dependencies = [
-    "typing-extensions>=4.6.0; python_version < '3.12'",
+    "typing-extensions>=4.10.0; python_version < '3.13'",
 ]
 
 [tool.setuptools]
@@ -46,6 +46,7 @@ src = ["src"]
 target-version = "py38"
 
 [tool.ruff.lint]
+typing-modules = ["_compat"]
 preview = true
 explicit-preview-rules = true
 select = [
@@ -61,14 +62,19 @@ select = [
     "B",      # flake8-bugbear
     "C4",     # flake8-comprehensions
     "T10",    # flake8-debugger
+    "FA",     # flake8-future-annotations
     "PIE",    # flake8-pie
     "T20",    # flake8-print
     "RSE",    # flake8-raise
     "PTH",    # flake8-use-pathlib
 ]
 ignore = [
-    "PLR2004"
+    "PLR2004",
+    "PLR0911",
 ]
 
 [tool.ruff.lint.isort]
 known-first-party = ["jsonlogic"]
+
+[tool.pytest.ini_options]
+pythonpath = "src"

python_jsonlogic-0.1.0/src/jsonlogic/__init__.py

@@ -0,0 +1,3 @@
+from .core import JSONLogicExpression, JSONLogicSyntaxError, Operator
+
+__all__ = ("JSONLogicExpression", "JSONLogicSyntaxError", "Operator")

python_jsonlogic-0.1.0/src/jsonlogic/_compat.py

@@ -0,0 +1,12 @@
+import sys
+
+if sys.version_info >= (3, 13):
+    from types import NoneType
+    from typing import Self, TypeAlias, TypeIs, TypeVarTuple, Unpack
+else:
+    from typing_extensions import Self, TypeAlias, TypeIs, TypeVarTuple, Unpack
+
+    NoneType = type(None)
+
+
+__all__ = ("NoneType", "Self", "TypeAlias", "TypeIs", "TypeVarTuple", "Unpack")

python_jsonlogic-0.1.0/src/jsonlogic/core.py

@@ -0,0 +1,132 @@
+"""Base structures of the library. The two classes defined, :class:`Operator` and :class:`JSONLogicExpression`,
+can be extended to provide extra functionality.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+from ._compat import Self, TypeAlias
+from .json_schema.types import AnyType, JSONSchemaType
+from .typing import JSON, JSONLogicPrimitive, JSONObject, OperatorArgument
+
+if TYPE_CHECKING:
+    # This is a hack to make Pylance think `TypeAlias` comes from `typing`
+    from typing import TypeAlias
+
+    from .evaluation import EvaluationContext
+    from .registry import OperatorRegistry
+    from .typechecking import TypecheckContext
+
+
+@dataclass
+class Operator(ABC):
+    """The base class for all operators."""
+
+    operator: str = field(repr=False)
+    """The string representation of the operator."""
+
+    # metadata: Any | None = None
+    # """Extra metadata for this operator.
+
+    # For any exception encountered, this will be included.
+    # """
+
+    @classmethod
+    @abstractmethod
+    def from_expression(cls, operator: str, arguments: list[OperatorArgument]) -> Self:
+        """Return an instance of the operator from the list of provided arguments.
+
+        Args:
+            operator: The ID of the operator, as provided by the :class:`~jsonlogic.registry.OperatorRegistry`.
+            arguments: The list of the arguments for this operator. Subclasses are responsible
+                for checking the correct number of arguments and optionally the types.
+        """
+
+    @abstractmethod
+    def evaluate(self, context: EvaluationContext) -> Any:
+        """Evaluate the operator with the provided data."""
+
+    def typecheck(self, context: TypecheckContext) -> JSONSchemaType:
+        """Typecheck the operator (and all children) given the data schema."""
+
+        return AnyType()
+
+
+class JSONLogicSyntaxError(Exception):
+    """A syntax error when building an operator tree from a :class:`JSONLogicExpression`."""
+
+    def __init__(self, message: str, /) -> None:
+        self.message = message
+
+
+ExprArgument: TypeAlias = "JSONLogicPrimitive | JSONLogicExpression | list[ExprArgument]"
+
+NormalizedExpression: TypeAlias = "dict[str, list[ExprArgument]]"
+
+
+@dataclass
+class JSONLogicExpression:
+    """A parsed and normalized JSON Logic expression.
+
+    The underlying structure of an expression is a single item dictionary,
+    mapping the operator key to a list of arguments.
+
+    All JSON Logic expressions should be instantiated using the :meth:`from_json` constructor::
+
+        expr = JSONLogicExpression.from_json({"op": ...})
+    """
+
+    expression: NormalizedExpression
+
+    @classmethod
+    def _parse_impl(cls, json: JSON) -> ExprArgument:
+        if isinstance(json, dict):
+            return cls.from_json(json)
+        if isinstance(json, list):
+            return [cls._parse_impl(s) for s in json]
+        return json
+
+    @classmethod
+    def from_json(cls, json: JSONObject) -> Self:
+        """Build a JSON Logic expression from JSON data.
+
+        Operator arguments are recursively normalized to a :class:`list`::
+
+            expr = JSONLogicExpression.from_json({"var": "varname"})
+            assert expr.expression == {"var": ["varname"]}
+        """
+        if not isinstance(json, dict):
+            raise ValueError("The root node of the expression must be a dict")
+
+        operator, op_args = next(iter(json.items()))
+        if not isinstance(op_args, list):
+            op_args = [op_args]
+
+        return cls({operator: [cls._parse_impl(arg) for arg in op_args]})
+
+    def _as_op_impl(self, op_arg: ExprArgument, operator_registry: OperatorRegistry) -> OperatorArgument:
+        if isinstance(op_arg, JSONLogicExpression):
+            return op_arg.as_operator_tree(operator_registry)
+        if isinstance(op_arg, list):
+            return [self._as_op_impl(sub_arg, operator_registry) for sub_arg in op_arg]
+        return op_arg
+
+    def as_operator_tree(self, operator_registry: OperatorRegistry) -> Operator:
+        """Return a recursive tree of operators, using the provided registry as a reference.
+
+        Args:
+            operator_registry: The registry to use to resolve operator IDs.
+
+        Returns:
+            An :class:`Operator` instance.
+        """
+        if not isinstance(self.expression, dict):
+            return self.expression
+
+        op_id, op_args = next(iter(self.expression.items()))
+        OperatorCls = operator_registry.get(op_id)
+
+        return OperatorCls.from_expression(op_id, [self._as_op_impl(op_arg, operator_registry) for op_arg in op_args])

python_jsonlogic-0.1.0/src/jsonlogic/evaluation/__init__.py

@@ -0,0 +1,5 @@
+from .evaluation_context import EvaluationContext
+from .evaluation_settings import EvaluationSettings
+from .utils import evaluate, get_value
+
+__all__ = ("EvaluationContext", "EvaluationSettings", "evaluate", "get_value")

python_jsonlogic-0.1.0/src/jsonlogic/evaluation/evaluation_context.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from typing import Any, Literal, overload
+
+from jsonlogic.json_schema import cast_from_schema
+from jsonlogic.resolving import resolve_data, resolve_json_schema
+from jsonlogic.typing import JSON
+from jsonlogic.utils import DataStack
+
+from .evaluation_settings import EvaluationSettings, EvaluationSettingsDict
+
+
+class EvaluationContext:
+    """A context object used when evaluating operators.
+
+    When evaluating an :class:`~jsonlogic.core.Operator`, an instance of this
+    class should be used.
+
+    .. code-block:: pycon
+
+        >>> expr = JSONLogicExpression.from_json({"var": "/a_date"})
+        >>> root_op = expr.as_operator_tree(operator_registry)
+        >>> context = EvaluationContext(
+        ...     data={"a_date": "1970-01-01"},
+        ...     data_schema={
+        ...         "type": "object",
+        ...         "properties": {
+        ...             "a_date": {"type": "string", "format": "date"},
+        ...         },
+        ...     },
+        ... )
+        >>> root_op.evaluate(context)
+        datetime.date(1970, 1, 1)
+
+    Args:
+        root_data: The root data available during evaluation.
+        data_schema: The matching JSON Schema describing the root data. This should be the same JSON Schema
+            used during typechecking (see :paramref:`~jsonlogic.typechecking.TypecheckContext.root_data_schema`).
+        settings: Settings to be used when evaluating an :class:`~jsonlogic.core.Operator`.
+            See :class:`EvaluationSettings` for the available settings and default values.
+    """
+
+    def __init__(
+        self, root_data: JSON, data_schema: dict[str, Any] | None = None, settings: EvaluationSettingsDict | None = None
+    ) -> None:
+        self.data_stack = DataStack((root_data, data_schema))
+        self.settings = EvaluationSettings.from_dict(settings) if settings is not None else EvaluationSettings()
+
+    @overload
+    def resolve_variable(self, reference: str, *, bare: Literal[True]) -> JSON: ...
+
+    @overload
+    def resolve_variable(self, reference: str, *, bare: Literal[False] = ...) -> Any: ...
+
+    def resolve_variable(self, reference: str, *, bare: bool = False) -> JSON | Any:
+        """Resolve a variable given the string reference pointing to it.
+
+        The format of the reference should match the reference parser defined
+        in the :class:`EvaluationSettings`.
+
+        Args:
+            reference: The string reference of the variable.
+            bare: Whether the resolved value should be casted to a specific Python
+                type according to the matching JSON Schema. Note that this will only
+                be possible if a :paramref:`~EvaluationContext.data_schema` was provided.
+        """
+        parsed_reference, scope = self.settings.reference_parser(reference)
+        root_data, root_schema = self.data_stack.get(scope)
+        bare_value = resolve_data(parsed_reference, root_data)
+        if bare or root_schema is None:
+            return bare_value
+
+        schema = resolve_json_schema(parsed_reference, root_schema)
+        return cast_from_schema(bare_value, schema, self.settings.variable_casts)

python_jsonlogic-0.1.0/src/jsonlogic/evaluation/evaluation_settings.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import date, datetime
+from typing import Any, Callable, TypedDict
+
+from jsonlogic._compat import Self
+from jsonlogic.resolving import PointerReferenceParser, ReferenceParser
+
+
+def _d_variable_casts() -> dict[str, Callable[[str], Any]]:
+    return {
+        "date": date.fromisoformat,
+        "date-time": datetime.fromisoformat,
+    }
+
+
+@dataclass
+class EvaluationSettings:
+    """Settings used when evaluating an :class:`~jsonlogic.core.Operator`."""
+
+    reference_parser: ReferenceParser = field(default_factory=PointerReferenceParser)
+    """A reference parser instance to use when resolving variables.
+
+    Default: :class:`~jsonlogic.resolving.PointerReferenceParser`.
+    """
+
+    variable_casts: dict[str, Callable[[str], Any]] = field(default_factory=_d_variable_casts)
+    """A mapping between `JSON Schema formats`_ and their corresponding conversion callable.
+
+    When an operator reads variables from the provided data (such as the ``"var"`` operator),
+    such variables of type :class:`str` may be converted to a specific Python type if
+    the corresponding JSON Schema of the data was provided during evaluation.
+
+    This setting is analogous to the :attr:`~jsonlogic.typechecking.TypecheckSettings.variable_casts`
+    configuration of the :class:`~jsonlogic.typechecking.TypecheckSettings` class.
+
+    Default: :python:`{"date": date.fromisoformat, "date-time": datetime.fromisoformat}`.
+
+    .. _JSON Schema formats: https://json-schema.org/understanding-json-schema/reference/string#built-in-formats
+    """
+
+    literal_casts: list[Callable[[str], Any]] = field(default_factory=list)
+    """A list of conversion callables to try when encountering a literal string value during evaluation.
+
+    When a literal string value is encountered in a JSON Logic expression, it might be
+    beneficial to convert it to a specific Python type.
+
+    This setting is analogous to the :attr:`~jsonlogic.typechecking.TypecheckSettings.literal_casts`
+    configuration of the :class:`~jsonlogic.typechecking.TypecheckSettings` class.
+
+    Default: :python:`[]` (no cast).
+
+    .. warning::
+
+        The order in which the conversion callables are defined matters. Each
+        callable will be applied one after the other until no exception is raised.
+    """
+
+    @classmethod
+    def from_dict(cls, dct: EvaluationSettingsDict, /) -> Self:
+        return cls(**dct)
+
+
+class EvaluationSettingsDict(TypedDict, total=False):
+    """Settings used when evaluating an :class:`~jsonlogic.core.Operator`."""
+
+    reference_parser: ReferenceParser
+    """A reference parser instance to use when resolving variables.
+
+    Default: :class:`~jsonlogic.resolving.PointerReferenceParser`.
+    """
+
+    variable_casts: dict[str, Callable[[str], Any]]
+    """A mapping between `JSON Schema formats`_ and their corresponding conversion callable.
+
+    When an operator reads variables from the provided data (such as the ``"var"`` operator),
+    such variables of type :class:`str` may be converted to a specific Python type if
+    the corresponding JSON Schema of the data was provided during evaluation.
+
+    This setting is analogous to the :attr:`~jsonlogic.typechecking.TypecheckSettings.variable_casts`
+    configuration of the :class:`~jsonlogic.typechecking.TypecheckSettings` class.
+
+    Default: :python:`{"date": date.fromisoformat, "date-time": datetime.fromisoformat}`.
+
+    .. _JSON Schema formats: https://json-schema.org/understanding-json-schema/reference/string#built-in-formats
+    """
+
+    literal_casts: list[Callable[[str], Any]]
+    """A list of conversion callables to try when encountering a literal string value during evaluation.
+
+    When a literal string value is encountered in a JSON Logic expression, it might be
+    beneficial to convert it to a specific Python type.
+
+    This setting is analogous to the :attr:`~jsonlogic.typechecking.TypecheckSettings.literal_casts`
+    configuration of the :class:`~jsonlogic.typechecking.TypecheckSettings` class.
+
+    Default: :python:`[]` (no cast).
+
+    .. warning::
+
+        The order in which the conversion callables are defined matters. Each
+        callable will be applied one after the other until no exception is raised.
+    """

python_jsonlogic-0.1.0/src/jsonlogic/evaluation/utils.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from typing import Any, Callable
+
+from jsonlogic.core import Operator
+from jsonlogic.typing import JSON, JSONLogicPrimitive, OperatorArgument
+
+from .evaluation_context import EvaluationContext
+from .evaluation_settings import EvaluationSettingsDict
+
+
+def evaluate(
+    operator: Operator, data: JSON, data_schema: dict[str, Any] | None, settings: EvaluationSettingsDict | None = None
+) -> Any:
+    """Helper function to evaluate an :class:`~jsonlogic.core.Operator`.
+
+    Args:
+        operator: The operator to evaluate.
+        data: The root data available during evaluation.
+        data_schema: The matching JSON Schema describing the root data. This should be the same JSON Schema
+            used during typechecking (see :paramref:`~jsonlogic.typechecking.TypecheckContext.root_data_schema`).
+        settings: Settings to be used when evaluating an :class:`~jsonlogic.core.Operator`.
+            See :class:`EvaluationSettings` for the available settings and default values.
+    Returns:
+        The evaluated value.
+    """
+    context = EvaluationContext(data, data_schema, settings)
+    return operator.evaluate(context)
+
+
+# Function analogous to :func:`jsonlogic.json_schema.from_value`
+def _cast_value(value: JSONLogicPrimitive, literal_casts: list[Callable[[str], Any]]) -> Any:
+    if isinstance(value, str):
+        for func in literal_casts:
+            try:
+                casted_value = func(value)
+            except Exception:
+                pass
+            else:
+                return casted_value
+
+    if not isinstance(value, list):
+        return value
+
+    return [_cast_value(subval, literal_casts) for subval in value]
+
+
+def get_value(obj: OperatorArgument, context: EvaluationContext) -> Any:
+    """Get the value of an operator argument.
+
+    Args:
+        obj: the object to evaluate. If this is an :class:`~jsonlogic.core.Operator`,
+            it is evaluated and the value is returned. Otherwise, it must be a
+            :data:`~jsonlogic.typing.JSONLogicPrimitive`, and the type is inferred from
+            the actual value according to the :attr:`~TypecheckSettings.literal_casts` setting.
+        context: The typecheck context.
+    """
+    if isinstance(obj, Operator):
+        return obj.evaluate(context)
+    if isinstance(obj, list):
+        return [get_value(sub_obj, context) for sub_obj in obj]
+    return _cast_value(obj, context.settings.literal_casts)