python-jsonlogic 0.0.1__tar.gz

python-jsonlogic-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+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.

python-jsonlogic-0.0.1/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.1
+Name: python-jsonlogic
+Version: 0.0.1
+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.6.0; python_version < "3.12"
+
+=========
+jsonlogic
+=========
+
+|Pythons| |PyPI|
+
+.. |Pythons| image:: https://img.shields.io/pypi/pyversions/jsonlogic.svg
+  :alt: Supported Python versions
+  :target: https://pypi.org/project/jsonlogic/
+
+.. |PyPI| image:: https://img.shields.io/pypi/v/jsonlogic.svg
+  :alt: PyPI - Version
+  :target: https://pypi.org/project/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://pypi.org/project/jsonlogic/
+
+``jsonlogic`` is an extensible and sane implementation of `JsonLogic`_.
+
+.. _`JsonLogic`: https://jsonlogic.com/

python-jsonlogic-0.0.1/README.rst

@@ -0,0 +1,21 @@
+=========
+jsonlogic
+=========
+
+|Pythons| |PyPI|
+
+.. |Pythons| image:: https://img.shields.io/pypi/pyversions/jsonlogic.svg
+  :alt: Supported Python versions
+  :target: https://pypi.org/project/jsonlogic/
+
+.. |PyPI| image:: https://img.shields.io/pypi/v/jsonlogic.svg
+  :alt: PyPI - Version
+  :target: https://pypi.org/project/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://pypi.org/project/jsonlogic/
+
+``jsonlogic`` is an extensible and sane implementation of `JsonLogic`_.
+
+.. _`JsonLogic`: https://jsonlogic.com/

python-jsonlogic-0.0.1/pyproject.toml

@@ -0,0 +1,74 @@
+[build-system]
+requires = ["setuptools>=61.0.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "python-jsonlogic"
+description = "An extensible and sane implementation of JsonLogic"
+version = "0.0.1"
+readme = "README.rst"
+authors = [
+    {name = "Victorien", email = "contact@vctrn.dev"}
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Typing :: Typed",
+    "License :: OSI Approved :: MIT License",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+license = {file = "LICENSE"}
+requires-python = ">=3.8"
+dependencies = [
+    "typing-extensions>=4.6.0; python_version < '3.12'",
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"jsonlogic" = ["py.typed"]
+
+[tool.ruff]
+line-length = 120
+src = ["src"]
+target-version = "py38"
+
+[tool.ruff.lint]
+preview = true
+explicit-preview-rules = true
+select = [
+    "E",      # pycodestyle (E)
+    "W",      # pycodestyle (W)
+    "F",      # Pyflakes
+    "UP",     # pyupgrade
+    "I",      # isort
+    "PL",     # Pylint
+    "RUF",    # Ruff
+    "RUF022", # Ruff-preview
+    "YTT",    # flake8-2020
+    "B",      # flake8-bugbear
+    "C4",     # flake8-comprehensions
+    "T10",    # flake8-debugger
+    "PIE",    # flake8-pie
+    "T20",    # flake8-print
+    "RSE",    # flake8-raise
+    "PTH",    # flake8-use-pathlib
+]
+ignore = [
+    "PLR2004"
+]
+
+[tool.ruff.lint.isort]
+known-first-party = ["jsonlogic"]

python-jsonlogic-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

python-jsonlogic-0.0.1/src/jsonlogic/_compat.py

@@ -0,0 +1,8 @@
+import sys
+
+if sys.version_info >= (3, 12):
+    from typing import Self, TypeAlias, TypeAliasType
+else:
+    from typing_extensions import Self, TypeAlias, TypeAliasType
+
+__all__ = ("Self", "TypeAlias", "TypeAliasType")

python-jsonlogic-0.0.1/src/jsonlogic/core.py

@@ -0,0 +1,73 @@
+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, OperatorArgument
+
+if TYPE_CHECKING:
+    # This is a hack to make pyright think `TypeAlias` comes from `typing`
+    from typing import TypeAlias
+
+    from .registry import OperatorRegistry
+
+
+@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."""
+
+    @abstractmethod
+    def apply(self, data: JSON) -> Any:
+        pass
+
+    def typecheck(self, data_schema: dict[str, Any]) -> JSONSchemaType:
+        """Typecheck the operator (and all children) given the data schema."""
+
+        return AnyType()
+
+
+NormalizedExpression: TypeAlias = "dict[str, list[JSONLogicExpression]]"
+
+
+@dataclass
+class JSONLogicExpression:
+    expression: JSONLogicPrimitive | NormalizedExpression
+
+    @classmethod
+    def from_json(cls, json: JSON) -> Self:  # TODO disallow list?
+        if not isinstance(json, dict):
+            return cls(expression=json)
+
+        operator, op_args = next(iter(json.items()))
+        if not isinstance(op_args, list):
+            op_args = [op_args]
+
+        sub_expressions = [cls.from_json(op_arg) for op_arg in op_args]
+
+        return cls({operator: sub_expressions})
+
+    def as_operator_tree(self, operator_registry: OperatorRegistry) -> JSONLogicPrimitive | Operator:
+        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, [op_arg.as_operator_tree(operator_registry) for op_arg in op_args])

python-jsonlogic-0.0.1/src/jsonlogic/json_schema/__init__.py

@@ -0,0 +1,77 @@
+from datetime import date, datetime
+from types import NoneType
+from typing import Any, Callable, cast
+
+from jsonlogic.typing import JSONLogicPrimitive
+
+from .types import (
+    AnyType,
+    BooleanType,
+    DatetimeType,
+    DateType,
+    IntegerType,
+    JSONSchemaType,
+    NullType,
+    NumberType,
+    StringType,
+)
+
+_VALUE_TYPE_MAP: dict[type[Any], JSONSchemaType] = {
+    bool: BooleanType(),
+    float: NumberType(),
+    int: IntegerType(),
+    NoneType: NullType(),
+}
+
+_VALUE_FORMAT_MAP: dict[Callable[[str], Any], JSONSchemaType] = {
+    datetime.fromisoformat: DatetimeType(),
+    date.fromisoformat: DateType(),
+}
+
+
+def from_value(value: JSONLogicPrimitive) -> JSONSchemaType:
+    if type(value) in _VALUE_TYPE_MAP:
+        return _VALUE_TYPE_MAP[type(value)]
+
+    if isinstance(value, str):
+        for func, js_type in _VALUE_FORMAT_MAP.items():
+            try:
+                func(value)
+            except Exception:
+                pass
+            else:
+                return js_type
+
+        return StringType()
+
+    return AnyType()
+
+
+_TYPE_MAP: dict[str, JSONSchemaType] = {
+    "boolean": BooleanType(),
+    "number": NumberType(),
+    "integer": IntegerType(),
+    "null": NullType(),
+}
+
+_FORMAT_MAP: dict[str, JSONSchemaType] = {
+    "date-time": DatetimeType(),
+    "date": DateType(),
+}
+
+
+def from_json_schema(json_schema: dict[str, Any]) -> JSONSchemaType:
+    # TODO support for unions
+    js_type = cast(str | None, json_schema.get("type"))
+    if js_type in _TYPE_MAP:
+        return _TYPE_MAP[js_type]
+
+    if js_type == "string":
+        format = cast(str | None, json_schema.get("format"))
+
+        if format in _FORMAT_MAP:
+            return _FORMAT_MAP[format]
+
+        return StringType()
+
+    return AnyType()

python-jsonlogic-0.0.1/src/jsonlogic/json_schema/resolvers.py

@@ -0,0 +1,51 @@
+from abc import ABC, abstractmethod
+from typing import Any, Generic, TypeVar
+from urllib.parse import unquote
+
+PointerT = TypeVar("PointerT")
+
+
+class Unresolvable(Exception, Generic[PointerT]):
+    """A pointer was unresolvable."""
+
+    # TODO `details` argument, providing more info?
+    def __init__(self, pointer: PointerT, /) -> None:
+        self.pointer = pointer
+
+
+class JSONSchemaResolver(ABC, Generic[PointerT]):
+    """Resolves the (sub) JSON Schema at the given pointer.
+
+    The implementation of the "pointer" is managed by subclasses.
+    """
+
+    def __init__(self, json_schema: dict[str, Any]) -> None:
+        self.json_schema = json_schema
+
+    @abstractmethod
+    def resolve(self, pointer: PointerT) -> dict[str, Any]:
+        pass
+
+
+class JSONSchemaPointerResolver(JSONSchemaResolver[str]):
+    """Resolves the (sub) JSON Schema at the given JSON Pointer, according to RFC 6901."""
+
+    def resolve(self, pointer: str) -> dict[str, Any]:
+        # Implementation inspired from the `referencing` library
+        schema = self.json_schema
+        for segment in unquote(pointer[1:]).split("/"):
+            schema_type = schema.get("type")
+            parsed_segment = segment.replace("~1", "/").replace("~0", "~")
+            if schema_type == "object":
+                try:
+                    schema = schema["properties"][parsed_segment]
+                    continue
+                except KeyError as e:
+                    raise Unresolvable(pointer) from e
+            if schema_type == "array":
+                try:
+                    int(parsed_segment)
+                except ValueError as e:
+                    raise Unresolvable(pointer) from e
+                schema = schema["items"]
+        return schema

python-jsonlogic-0.0.1/src/jsonlogic/json_schema/types.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Literal, TypeAlias, TypeVar, overload
+
+from jsonlogic._compat import Self
+
+JSONSchemaPrimitiveType: TypeAlias = (
+    "AnyType | BooleanType | NumberType | StringType | DatetimeType | DateType | NullType"
+)
+
+JSONSchemaPrimitiveTypeT = TypeVar(
+    "JSONSchemaPrimitiveTypeT",
+    "AnyType",
+    "BooleanType",
+    "NumberType",
+    "IntegerType",
+    "StringType",
+    "DatetimeType",
+    "DateType",
+    "NullType",
+)
+
+
+class JSONSchemaType(ABC):
+    @abstractmethod
+    def comparable_with(self, other: JSONSchemaType) -> bool:
+        pass
+
+    @overload
+    def __or__(self, value: Self, /) -> Self: ...  # type: ignore
+
+    @overload
+    def __or__(self, value: JSONSchemaType, /) -> UnionType: ...
+
+    def __or__(self, value, /):  # type: ignore
+        return UnionType(self, value)
+
+
+class UnionType(JSONSchemaType):
+    types: set[JSONSchemaPrimitiveType]
+
+    @overload
+    def __new__(cls, *types: JSONSchemaPrimitiveTypeT) -> JSONSchemaPrimitiveTypeT: ...
+
+    @overload
+    def __new__(cls, *types: JSONSchemaType) -> Self: ...
+
+    def __new__(cls, *types):
+        if all(isinstance(t, type(types[0])) for t in types):
+            return types[0]
+        self = super().__new__(cls)
+        self.types = set()
+        for typ in types:
+            if isinstance(typ, UnionType):
+                self.types.update(typ.types)
+            else:
+                self.types.add(typ)
+        return self
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__qualname__}({', '.join(str(t) for t in self.types)})"
+
+    def comparable_with(self, other: JSONSchemaType) -> bool:
+        for typ in self.types:
+            if isinstance(other, UnionType):
+                comparable = all(other_typ.comparable_with(typ) for other_typ in other.types)
+            else:
+                comparable = other.comparable_with(typ)
+            if not comparable:
+                return False
+        return True
+
+
+@dataclass(frozen=True)
+class AnyType(JSONSchemaType):
+    def comparable_with(self, other: JSONSchemaType) -> Literal[False]:
+        return False
+
+
+@dataclass(frozen=True)
+class BooleanType(JSONSchemaType):
+    def comparable_with(self, other: JSONSchemaType) -> Literal[False]:
+        return False
+
+
+@dataclass(frozen=True)
+class NumberType(JSONSchemaType):
+    def comparable_with(self, other: JSONSchemaType) -> bool:
+        if isinstance(other, UnionType):
+            return other.comparable_with(self)
+        return isinstance(other, (NumberType, IntegerType))
+
+
+@dataclass(frozen=True)
+class IntegerType(JSONSchemaType):
+    def comparable_with(self, other: JSONSchemaType) -> bool:
+        if isinstance(other, UnionType):
+            return other.comparable_with(self)
+        return isinstance(other, (NumberType, IntegerType))
+
+
+@dataclass(frozen=True)
+class StringType(JSONSchemaType):
+    def comparable_with(self, other: JSONSchemaType) -> Literal[False]:
+        return False
+
+
+@dataclass(frozen=True)
+class DatetimeType(JSONSchemaType):
+    def comparable_with(self, other: JSONSchemaType) -> bool:
+        if isinstance(other, UnionType):
+            return other.comparable_with(self)
+        # Probably doesn't make sense with date?
+        return isinstance(other, DatetimeType)
+
+
+@dataclass(frozen=True)
+class DateType(JSONSchemaType):
+    def comparable_with(self, other: JSONSchemaType) -> bool:
+        if isinstance(other, UnionType):
+            return other.comparable_with(self)
+        return isinstance(other, DateType)
+
+
+@dataclass(frozen=True)
+class NullType(JSONSchemaType):
+    def comparable_with(self, other: JSONSchemaType) -> Literal[False]:
+        return False

python-jsonlogic-0.0.1/src/jsonlogic/operators/__init__.py

@@ -0,0 +1,24 @@
+from jsonlogic.registry import OperatorRegistry
+
+from .operators import (
+    EqualOperator,
+    GreaterThan,
+    GreaterThanOrEqual,
+    IfOperator,
+    LessThan,
+    LessThanOrEqual,
+    NotEqualOperator,
+    Var,
+)
+
+operator_registry = OperatorRegistry()
+"""The operator registry."""
+
+operator_registry.register("var", Var)
+operator_registry.register("==", EqualOperator)
+operator_registry.register("!=", NotEqualOperator)
+operator_registry.register("if", IfOperator)
+operator_registry.register(">", GreaterThan)
+operator_registry.register(">=", GreaterThanOrEqual)
+operator_registry.register("<", LessThan)
+operator_registry.register("<=", LessThanOrEqual)

python-jsonlogic-0.0.1/src/jsonlogic/operators/operators.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+import functools
+import operator
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Callable, ClassVar
+
+from jsonlogic._compat import Self
+from jsonlogic.core import Operator
+from jsonlogic.json_schema import from_json_schema, from_value
+from jsonlogic.json_schema.resolvers import JSONSchemaPointerResolver, JSONSchemaResolver, Unresolvable
+from jsonlogic.json_schema.types import AnyType, BooleanType, JSONSchemaType
+from jsonlogic.typing import OperatorArgument
+from jsonlogic.utils import UNSET, Unset
+
+from .typechecking import TypecheckError, get_type
+
+if TYPE_CHECKING:
+    from _typeshed import SupportsAllComparisons
+
+
+@dataclass
+class Var(Operator):
+    json_schema_resolver: ClassVar[type[JSONSchemaResolver]] = JSONSchemaPointerResolver
+
+    variable_path: str | Operator
+
+    default_value: OperatorArgument | Unset = UNSET
+
+    @classmethod
+    def from_expression(cls, operator: str, arguments: list[OperatorArgument]) -> Self:
+        assert len(arguments) in (1, 2)
+        assert isinstance(arguments[0], (str, Operator))
+        if len(arguments) == 1:
+            return cls(operator=operator, variable_path=arguments[0])
+        return cls(operator=operator, variable_path=arguments[0], default_value=arguments[1])
+
+    def typecheck(self, data_schema: dict[str, Any]) -> JSONSchemaType:
+        if isinstance(self.variable_path, Operator):
+            self.variable_path.typecheck(data_schema)
+            return AnyType()
+
+        resolver = self.json_schema_resolver(data_schema)
+
+        try:
+            js_type = resolver.resolve(self.variable_path)
+            return from_json_schema(js_type)
+        except Unresolvable as e:
+            if isinstance(self.default_value, Unset):
+                raise TypecheckError("Unresolvable reference", self) from e
+            if isinstance(self.default_value, Operator):
+                self.default_value.typecheck(data_schema)
+                return AnyType()
+            return from_value(self.default_value)
+
+
+@dataclass
+class EqualityOperator(Operator):
+    equality_func: ClassVar[Callable[[object, object], bool]]
+
+    left: OperatorArgument
+    right: OperatorArgument
+
+    @classmethod
+    def from_expression(cls, operator: str, arguments: list[OperatorArgument]) -> Self:
+        assert len(arguments) == 2
+        return cls(operator=operator, left=arguments[0], right=arguments[1])
+
+    def typecheck(self, data_schema: dict[str, Any]) -> JSONSchemaType:
+        if isinstance(self.left, Operator):
+            self.left.typecheck(data_schema)
+        if isinstance(self.right, Operator):
+            self.right.typecheck(data_schema)
+        return BooleanType()
+
+
+@dataclass
+class EqualOperator(EqualityOperator):
+    equality_func = operator.eq
+
+
+@dataclass
+class NotEqualOperator(EqualityOperator):
+    equality_func = operator.ne
+
+
+@dataclass
+class IfOperator(Operator):
+    if_elses: list[tuple[OperatorArgument, OperatorArgument]]
+    leading_else: OperatorArgument
+
+    @classmethod
+    def from_expression(cls, operator: str, arguments: list[OperatorArgument]) -> Self:
+        assert len(arguments) % 2 == 1
+        return cls(operator=operator, if_elses=list(zip(arguments[::2], arguments[1::2])), leading_else=arguments[-1])
+
+    def typecheck(self, data_schema: dict[str, Any]) -> JSONSchemaType:
+        for cond, _ in self.if_elses:
+            cond_type = get_type(cond, data_schema)
+            if not isinstance(cond_type, BooleanType):
+                raise TypecheckError("should be boolean", self)
+
+        return functools.reduce(operator.or_, (get_type(rv, data_schema) for _, rv in self.if_elses)) | get_type(
+            self.leading_else, data_schema
+        )
+
+
+@dataclass
+class ComparableOperator(Operator):
+    operator_func: ClassVar[Callable[[SupportsAllComparisons, SupportsAllComparisons], bool]]
+
+    left: OperatorArgument
+    right: OperatorArgument
+
+    @classmethod
+    def from_expression(cls, operator: str, arguments: list[OperatorArgument]) -> Self:
+        assert len(arguments) == 2
+        # TODO validate valid primitives (e.g. array probably not valid)
+        # Maybe not necessary, `typecheck` will handle it
+        return cls(operator=operator, left=arguments[0], right=arguments[1])
+
+    def typecheck(self, data_schema: dict[str, Any]) -> JSONSchemaType:
+        left_type = get_type(self.left, data_schema)
+        right_type = get_type(self.right, data_schema)
+
+        if not left_type.comparable_with(right_type):
+            raise TypecheckError("Cannot compare types", self)
+
+        return BooleanType()
+
+    def apply(self, data) -> bool:
+        left = self.left
+        if isinstance(left, Operator):
+            left = left.apply(data)
+        right = self.right
+        if isinstance(right, Operator):
+            right = right.apply(data)
+
+        return self.operator_func(left, right)
+
+
+@dataclass
+class GreaterThan(ComparableOperator):
+    operator_func = operator.gt
+
+
+@dataclass
+class GreaterThanOrEqual(ComparableOperator):
+    operator_func = operator.ge
+
+
+@dataclass
+class LessThan(ComparableOperator):
+    operator_func = operator.lt
+
+
+@dataclass
+class LessThanOrEqual(ComparableOperator):
+    operator_func = operator.le

python-jsonlogic-0.0.1/src/jsonlogic/operators/typechecking.py

@@ -0,0 +1,16 @@
+from typing import Any
+
+from jsonlogic.core import Operator
+from jsonlogic.json_schema import from_value
+from jsonlogic.json_schema.types import JSONSchemaType
+from jsonlogic.typing import OperatorArgument
+
+
+def get_type(obj: OperatorArgument, data_schema: dict[str, Any]) -> JSONSchemaType:
+    return obj.typecheck(data_schema) if isinstance(obj, Operator) else from_value(obj)
+
+
+class TypecheckError(Exception):
+    def __init__(self, message: str, operator: Operator, /) -> None:
+        self.operator = operator
+        self.message = message

python-jsonlogic-0.0.1/src/jsonlogic/registry.py

@@ -0,0 +1,94 @@
+from typing import Callable, overload
+
+from ._compat import Self, TypeAlias
+from .core import Operator
+
+
+class AlreadyRegistered(Exception):
+    """The provided ID is already registered."""
+
+    def __init__(self, operator_id: str, /) -> None:
+        self.operator_id = operator_id
+
+
+class UnkownOperator(Exception):
+    """The provided ID does not exist in the registry."""
+
+    def __init__(self, operator_id: str, /) -> None:
+        self.operator_id = operator_id
+
+
+OperatorType: TypeAlias = type[Operator]
+
+
+class OperatorRegistry:
+    def __init__(self) -> None:
+        self._registry: dict[str, OperatorType] = {}
+
+    @overload
+    def register(self, operator_id: str, *, force: bool = ...) -> Callable[[OperatorType], OperatorType]: ...
+
+    @overload
+    def register(self, operator_id: str, operator_type: OperatorType, *, force: bool = ...) -> OperatorType: ...
+
+    def register(
+        self, operator_id: str, operator_type: OperatorType | None = None, *, force: bool = False
+    ) -> Callable[[OperatorType], OperatorType] | OperatorType:
+        """Register an operator type under the provided ID.
+
+        Args:
+            operator_id: The ID to be used to register the operator.
+            operator_type: Type class of the operator. If not provided,
+                will return a callable to be applied on an operator class.
+            force: Whether to override any existing operator under the provided ID.
+
+        Raises:
+            AlreadyRegistered: If ``force`` wasn't set and the ID already exist.
+
+        Note:
+            The method is usable as a decorator:
+
+            .. code-block:: python
+                :emphasize-lines: 5,6
+
+                reg = OperatorRegistry()
+                reg.register("==", EqualOperator)
+
+                # Or:
+                @reg.register("==")
+                class EqualOperator(Operator): ...
+        """
+
+        if operator_type is None:
+
+            def dec(operator_type: OperatorType, /) -> OperatorType:
+                return self.register(operator_id, operator_type)
+
+            return dec
+
+        if operator_id in self._registry and not force:
+            raise AlreadyRegistered(operator_id)
+
+        self._registry[operator_id] = operator_type
+        return operator_type
+
+    def get(self, operator_id: str, /) -> OperatorType:
+        """Get the operator class corresponding to the ID.
+
+        Args:
+            operator_id: The registered ID of the operator.
+
+        Raises:
+            UnkownOperator: If the provided ID does not exist.
+        """
+        try:
+            return self._registry[operator_id]
+        except KeyError:
+            raise UnkownOperator(operator_id)  # noqa: B904
+
+    def copy(self) -> Self:
+        """Create a new instance of the registry."""
+
+        new = self.__class__()
+        new._registry = self._registry.copy()
+        return new

python-jsonlogic-0.0.1/src/jsonlogic/typing.py

@@ -0,0 +1,17 @@
+from typing import TYPE_CHECKING
+
+from ._compat import TypeAlias
+
+if TYPE_CHECKING:
+    # This is a hack to make pyright think `TypeAlias` comes from `typing`
+    from .typing import TypeAlias
+
+JSONPrimitive: TypeAlias = str | int | float | bool | None
+JSONObject: TypeAlias = "dict[str, JSON]"
+JSONArray: TypeAlias = "list[JSON]"
+JSON: TypeAlias = "JSONPrimitive | JSONArray | JSONObject"
+
+JSONLogicPrimitive: TypeAlias = JSONPrimitive | list[JSONPrimitive]
+
+OperatorArgument: TypeAlias = "JSONLogicPrimitive | Operator"
+"""A valid operator argument, either a JSON Logic primitive or an operator."""

python-jsonlogic-0.0.1/src/jsonlogic/utils.py

@@ -0,0 +1,14 @@
+from typing import Literal
+
+
+class Unset:
+    """A class representing an unset value."""
+
+    def __bool__(self) -> Literal[False]:
+        return False
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__qualname__}()"
+
+
+UNSET: Unset = Unset()

python-jsonlogic-0.0.1/src/python_jsonlogic.egg-info/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.1
+Name: python-jsonlogic
+Version: 0.0.1
+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.6.0; python_version < "3.12"
+
+=========
+jsonlogic
+=========
+
+|Pythons| |PyPI|
+
+.. |Pythons| image:: https://img.shields.io/pypi/pyversions/jsonlogic.svg
+  :alt: Supported Python versions
+  :target: https://pypi.org/project/jsonlogic/
+
+.. |PyPI| image:: https://img.shields.io/pypi/v/jsonlogic.svg
+  :alt: PyPI - Version
+  :target: https://pypi.org/project/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://pypi.org/project/jsonlogic/
+
+``jsonlogic`` is an extensible and sane implementation of `JsonLogic`_.
+
+.. _`JsonLogic`: https://jsonlogic.com/

python-jsonlogic-0.0.1/src/python_jsonlogic.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+LICENSE
+README.rst
+pyproject.toml
+src/jsonlogic/__init__.py
+src/jsonlogic/_compat.py
+src/jsonlogic/core.py
+src/jsonlogic/py.typed
+src/jsonlogic/registry.py
+src/jsonlogic/typing.py
+src/jsonlogic/utils.py
+src/jsonlogic/json_schema/__init__.py
+src/jsonlogic/json_schema/resolvers.py
+src/jsonlogic/json_schema/types.py
+src/jsonlogic/operators/__init__.py
+src/jsonlogic/operators/base.py
+src/jsonlogic/operators/operators.py
+src/jsonlogic/operators/typechecking.py
+src/python_jsonlogic.egg-info/PKG-INFO
+src/python_jsonlogic.egg-info/SOURCES.txt
+src/python_jsonlogic.egg-info/dependency_links.txt
+src/python_jsonlogic.egg-info/requires.txt
+src/python_jsonlogic.egg-info/top_level.txt

python-jsonlogic-0.0.1/src/python_jsonlogic.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

python-jsonlogic-0.0.1/src/python_jsonlogic.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[:python_version < "3.12"]
+typing-extensions>=4.6.0

python-jsonlogic-0.0.1/src/python_jsonlogic.egg-info/top_level.txt

@@ -0,0 +1 @@
+jsonlogic