dynamic-expressions 0.1.1__tar.gz

dynamic_expressions-0.1.1/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.2
+Name: dynamic-expressions
+Version: 0.1.1
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Provides-Extra: cache-redis
+Requires-Dist: redis>=5.2.1; extra == "cache-redis"
+Provides-Extra: serialization-pydantic
+Requires-Dist: pydantic>=2.10.6; extra == "serialization-pydantic"
+Provides-Extra: serialization-msgspec
+Requires-Dist: msgspec>=0.19.0; extra == "serialization-msgspec"

dynamic_expressions-0.1.1/dynamic_expressions/cache/__init__.py

@@ -0,0 +1,5 @@
+from .base import CachePolicy
+
+__all__ = [
+    "CachePolicy",
+]

dynamic_expressions-0.1.1/dynamic_expressions/cache/base.py

@@ -0,0 +1,81 @@
+import abc
+import contextlib
+import dataclasses
+from collections.abc import AsyncIterator, Callable, MutableMapping, Sequence
+from datetime import timedelta
+from typing import Any
+
+from dynamic_expressions.extensions import OnVisitExtension
+from dynamic_expressions.nodes import Node
+from dynamic_expressions.serialization import Serializer
+from dynamic_expressions.types import EmptyContext, ExecutionContext
+
+
+@dataclasses.dataclass(slots=True, kw_only=True)
+class CachePolicy[Context: EmptyContext]:
+    types: tuple[type[Node], ...]
+    key: Callable[[Node, Context], str]
+    ttl: timedelta
+    serializer: Serializer[Any] | None = None
+
+
+class CacheExtension[
+    Context: EmptyContext,
+](OnVisitExtension[Context]):
+    policies: Sequence[CachePolicy[Context]]
+    default_serializer: Serializer[Any]
+    _policy_cache: MutableMapping[type[Node], CachePolicy[Context] | None]
+
+    @contextlib.asynccontextmanager
+    async def on_visit(
+        self,
+        *,
+        node: Node,
+        provided_context: Context,
+        execution_context: ExecutionContext,
+    ) -> AsyncIterator[None]:
+        policy = self._get_policy(node)
+
+        if policy is None or node in execution_context.cache:
+            yield
+            return
+
+        key = policy.key(node, provided_context)
+        serializer = policy.serializer or self.default_serializer
+        cached_value = await self.get_cache(key)
+        if cached_value is not None:
+            execution_context.cache[node] = serializer.deserialize(cached_value)
+
+        yield
+
+        if (
+            node in execution_context.cache
+            and cached_value != execution_context.cache[node]
+        ):
+            await self.set_cache(
+                key=key,
+                value=serializer.serialize(execution_context.cache[node]),
+                policy=policy,
+            )
+
+    def _get_policy(self, node: Node) -> CachePolicy[Context] | None:
+        node_cls = type(node)
+        if node_cls in self._policy_cache:
+            return self._policy_cache[node_cls]
+
+        self._policy_cache[node_cls] = next(
+            (policy for policy in self.policies if isinstance(node, policy.types)),
+            None,
+        )
+        return self._policy_cache[node_cls]
+
+    @abc.abstractmethod
+    async def get_cache(self, key: str) -> Any | None: ...  # noqa: ANN401
+
+    @abc.abstractmethod
+    async def set_cache(
+        self,
+        key: str,
+        value: Any,  # noqa: ANN401
+        policy: CachePolicy[Context],
+    ) -> None: ...

dynamic_expressions-0.1.1/dynamic_expressions/cache/redis.py

@@ -0,0 +1,39 @@
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Any
+
+from redis.asyncio import Redis
+
+from dynamic_expressions.cache.base import CacheExtension, CachePolicy
+from dynamic_expressions.serialization import Serializer
+from dynamic_expressions.types import EmptyContext
+
+if TYPE_CHECKING:
+    RedisClient = Redis[bytes]
+else:
+    RedisClient = Redis
+
+
+class RedisCacheExtension[
+    Context: EmptyContext,
+](CacheExtension[Context]):
+    def __init__(
+        self,
+        client: RedisClient,
+        policies: Sequence[CachePolicy[Context]],
+        default_serializer: Serializer[Any],
+    ) -> None:
+        self.policies = policies
+        self.default_serializer = default_serializer
+        self._client = client
+        self._policy_cache = {}
+
+    async def get_cache(self, key: str) -> bytes | None:
+        return await self._client.get(name=key)
+
+    async def set_cache(
+        self,
+        key: str,
+        value: bytes,
+        policy: CachePolicy[Context],
+    ) -> None:
+        await self._client.set(name=key, value=value, ex=policy.ttl)

dynamic_expressions-0.1.1/dynamic_expressions/dispatcher.py

@@ -0,0 +1,64 @@
+import functools
+from collections.abc import Mapping, Sequence
+from contextlib import AsyncExitStack
+from typing import Any
+
+from dynamic_expressions.extensions import (
+    OnVisitExtension,
+)
+from dynamic_expressions.nodes import Node
+from dynamic_expressions.types import EmptyContext, ExecutionContext
+from dynamic_expressions.visitors import Visitor
+
+
+class VisitorDispatcher[Context: EmptyContext]:
+    def __init__(
+        self,
+        visitors: Mapping[type[Node], Visitor[Any, Context]],
+        extensions: Sequence[OnVisitExtension[Context]] = (),
+    ) -> None:
+        self._visitors = visitors
+        self._on_visit_exts = extensions
+
+    async def visit(
+        self,
+        node: Node,
+        context: Context,
+    ) -> Any:  # noqa: ANN401
+        execution_context = ExecutionContext()
+        return await self._visit(
+            node=node,
+            context=context,
+            execution_context=execution_context,
+        )
+
+    async def _visit(
+        self,
+        node: Node,
+        context: Context,
+        execution_context: ExecutionContext,
+    ) -> Any:  # noqa: ANN401
+        async with AsyncExitStack() as stack:
+            for ext in self._on_visit_exts:
+                await stack.enter_async_context(
+                    ext.on_visit(
+                        node=node,
+                        provided_context=context,
+                        execution_context=execution_context,
+                    )
+                )
+
+            if node in execution_context.cache:
+                return execution_context.cache[node]
+
+            visitor = self._visitors[type(node)]
+            result = await visitor.visit(
+                node=node,
+                context=context,
+                dispatch=functools.partial(
+                    self._visit,
+                    execution_context=execution_context,
+                ),
+            )
+            execution_context.cache[node] = result
+            return result

dynamic_expressions-0.1.1/dynamic_expressions/extensions.py

@@ -0,0 +1,16 @@
+from contextlib import AbstractAsyncContextManager
+from typing import Protocol, runtime_checkable
+
+from dynamic_expressions.nodes import Node
+from dynamic_expressions.types import EmptyContext, ExecutionContext
+
+
+@runtime_checkable
+class OnVisitExtension[Context: EmptyContext](Protocol):
+    def on_visit(
+        self,
+        *,
+        node: Node,
+        provided_context: Context,
+        execution_context: ExecutionContext,
+    ) -> AbstractAsyncContextManager[None]: ...

dynamic_expressions-0.1.1/dynamic_expressions/nodes.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from dynamic_expressions.types import BinaryExpressionOperator
+
+
+@dataclass(slots=True, frozen=True, kw_only=True, unsafe_hash=True)
+class Node: ...
+
+
+@dataclass(slots=True, frozen=True, kw_only=True, unsafe_hash=True)
+class AnyOfNode(Node):
+    expressions: tuple[Node, ...]
+
+
+@dataclass(slots=True, frozen=True, kw_only=True, unsafe_hash=True)
+class AllOfNode(Node):
+    expressions: tuple[Node, ...]
+
+
+@dataclass(slots=True, frozen=True, kw_only=True, unsafe_hash=True)
+class BinaryExpressionNode(Node):
+    operator: BinaryExpressionOperator
+    left: Node
+    right: Node
+
+
+@dataclass(slots=True, frozen=True, kw_only=True)
+class LiteralNode(Node):
+    value: Any
+
+    def __hash__(self) -> int:
+        return hash((self.value, type(self.value)))

dynamic_expressions-0.1.1/dynamic_expressions/serialization/__init__.py

@@ -0,0 +1,5 @@
+from ._serialization import Serializer
+
+__all__ = [
+    "Serializer",
+]

dynamic_expressions-0.1.1/dynamic_expressions/serialization/_serialization.py

@@ -0,0 +1,6 @@
+from typing import Protocol
+
+
+class Serializer[TResult](Protocol):
+    def serialize(self, value: TResult) -> bytes: ...
+    def deserialize(self, value: bytes) -> TResult: ...

dynamic_expressions-0.1.1/dynamic_expressions/serialization/msgspec.py

@@ -0,0 +1,24 @@
+from typing import Any
+
+import msgspec
+
+from ._serialization import Serializer
+
+
+class MsgSpecSerializer[T](Serializer[T]):
+    def __init__(self, instance_of: type[T]) -> None:
+        self.instance_of = instance_of
+
+    def serialize(self, value: T) -> bytes:
+        return msgspec.json.encode(value)
+
+    def deserialize(self, value: bytes) -> T:
+        return msgspec.json.decode(value, type=self.instance_of)
+
+
+class MsgSpecScalarSerializer(Serializer[Any]):
+    def serialize(self, value: Any) -> bytes:  # noqa: ANN401
+        return msgspec.json.encode(value)
+
+    def deserialize(self, value: bytes) -> Any:  # noqa: ANN401
+        return msgspec.json.decode(value)

dynamic_expressions-0.1.1/dynamic_expressions/serialization/pydantic.py

@@ -0,0 +1,104 @@
+import abc
+from collections.abc import Sequence
+from typing import Any, Literal, Union, overload
+
+from pydantic import BaseModel, ConfigDict, TypeAdapter
+
+from dynamic_expressions.nodes import (
+    AllOfNode,
+    AnyOfNode,
+    BinaryExpressionNode,
+    LiteralNode,
+    Node,
+)
+from dynamic_expressions.types import BinaryExpressionOperator
+
+from ._serialization import Serializer
+
+
+class NodeSchema(BaseModel):
+    model_config = ConfigDict(strict=True)
+
+    @abc.abstractmethod
+    def to_node(self) -> Node: ...
+
+
+class AnyOfNodeSchema[T: NodeSchema](NodeSchema):
+    type: Literal["any-of"]
+    expressions: tuple[T, ...]
+
+    def to_node(self) -> AnyOfNode:
+        return AnyOfNode(expressions=tuple(expr.to_node() for expr in self.expressions))
+
+
+class AllOfNodeSchema[T: NodeSchema](NodeSchema):
+    type: Literal["all-of"]
+    expressions: tuple[T, ...]
+
+    def to_node(self) -> AllOfNode:
+        return AllOfNode(expressions=tuple(expr.to_node() for expr in self.expressions))
+
+
+class BinaryExpressionNodeSchema[T: NodeSchema](NodeSchema):
+    type: Literal["binary"]
+    operator: BinaryExpressionOperator
+    left: T
+    right: T
+
+    def to_node(self) -> BinaryExpressionNode:
+        return BinaryExpressionNode(
+            operator=self.operator,
+            left=self.left.to_node(),
+            right=self.right.to_node(),
+        )
+
+
+class LiteralNodeSchema[T](NodeSchema):
+    type: Literal["literal"]
+    value: int | str | bool
+
+    def to_node(self) -> LiteralNode:
+        return LiteralNode(value=self.value)
+
+
+BUILTIN_SCHEMAS: Sequence[type[NodeSchema]] = [
+    AnyOfNodeSchema,
+    AllOfNodeSchema,
+    BinaryExpressionNodeSchema,
+    LiteralNodeSchema,
+]
+
+
+class PydanticExpressionParser:
+    def __init__(self, types: Sequence[type[NodeSchema]]) -> None:
+        self._types = list(types)
+        self._needs_rebuild = True
+        self._type_adapter: TypeAdapter[NodeSchema] | None = None
+
+    def add_type(self, cls: type[NodeSchema]) -> None:
+        self._types.append(cls)
+
+    @property
+    def type_adapter(self) -> TypeAdapter[NodeSchema]:
+        if self._needs_rebuild or self._type_adapter is None:
+            union = Union[tuple(model["union"] for model in self._types)]  # type: ignore[valid-type,index]  # noqa: UP007
+            self._type_adapter = TypeAdapter(union)
+
+        return self._type_adapter
+
+
+class PydanticSerializer[T](Serializer[T]):
+    @overload
+    def __init__(self, instance_of: type[T]) -> None: ...
+
+    @overload
+    def __init__(self, instance_of: Any) -> None: ...  # noqa: ANN401
+
+    def __init__(self, instance_of: Any) -> None:
+        self._type_adapter = TypeAdapter[T](instance_of)
+
+    def serialize(self, value: T) -> bytes:
+        return self._type_adapter.dump_json(value, by_alias=True)
+
+    def deserialize(self, value: bytes) -> T:
+        return self._type_adapter.validate_json(value, strict=True)

dynamic_expressions-0.1.1/dynamic_expressions/types.py

@@ -0,0 +1,29 @@
+from dataclasses import dataclass, field
+from typing import Any, Literal, Protocol
+
+from dynamic_expressions.nodes import Node
+
+
+class EmptyContext(Protocol): ...
+
+
+@dataclass
+class ExecutionContext:
+    cache: dict[Node, Any] = field(default_factory=dict)
+
+
+BinaryExpressionOperator = Literal[
+    "=",
+    ">",
+    ">=",
+    "<",
+    "<=",
+    "!=",
+    "in",
+    "+",
+    "-",
+    "*",
+    "/",
+    "//",
+    "^",
+]

dynamic_expressions-0.1.1/dynamic_expressions/visitors.py

@@ -0,0 +1,105 @@
+import abc
+import operator
+from collections.abc import Callable, Mapping
+from typing import Any, ClassVar, Protocol
+
+from dynamic_expressions.nodes import (
+    AllOfNode,
+    AnyOfNode,
+    BinaryExpressionNode,
+    LiteralNode,
+    Node,
+)
+from dynamic_expressions.types import BinaryExpressionOperator, EmptyContext
+
+
+class Dispatch[TContext: EmptyContext](Protocol):
+    async def __call__(self, node: Node, context: TContext) -> Any: ...  # noqa: ANN401
+
+
+class Visitor[TNode: Node, TContext: EmptyContext]:
+    @abc.abstractmethod
+    async def visit(
+        self,
+        *,
+        node: TNode,
+        dispatch: Dispatch[TContext],
+        context: TContext,
+    ) -> Any: ...  # noqa: ANN401
+
+
+class AnyOfVisitor(Visitor[AnyOfNode, EmptyContext]):
+    async def visit(
+        self,
+        *,
+        node: AnyOfNode,
+        dispatch: Dispatch[EmptyContext],
+        context: object,
+    ) -> bool:
+        for expr in node.expressions:
+            value = await dispatch(expr, context)
+            if value:
+                return True
+        return False
+
+
+class AllOfVisitor(Visitor[AllOfNode, EmptyContext]):
+    async def visit(
+        self,
+        *,
+        node: AllOfNode,
+        dispatch: Dispatch[EmptyContext],
+        context: EmptyContext,
+    ) -> bool:
+        for expr in node.expressions:
+            value = await dispatch(expr, context)
+            if not value:
+                return False
+        return True
+
+
+class BinaryExpressionVisitor(Visitor[BinaryExpressionNode, EmptyContext]):
+    operator_mapping: ClassVar[
+        Mapping[BinaryExpressionOperator, Callable[[Any, Any], bool]]
+    ] = {
+        "=": operator.eq,
+        ">": operator.gt,
+        ">=": operator.ge,
+        "<": operator.lt,
+        "<=": operator.le,
+        "!=": operator.ne,
+        "in": operator.contains,
+        "+": operator.add,
+        "-": operator.sub,
+        "*": operator.mul,
+        "/": operator.truediv,
+        "//": operator.floordiv,
+        "^": operator.pow,
+    }
+
+    async def visit(
+        self,
+        *,
+        node: BinaryExpressionNode,
+        dispatch: Dispatch[EmptyContext],
+        context: EmptyContext,
+    ) -> bool:
+        left = await dispatch(node.left, context)
+        right = await dispatch(node.right, context)
+
+        operator_callable = self.operator_mapping.get(node.operator)
+        if operator_callable is None:
+            msg = f"Unknown operator '{node.operator}'"
+            raise ValueError(msg)
+        return operator_callable(left, right)
+
+
+class LiteralVisitor(Visitor[LiteralNode, EmptyContext]):
+    async def visit(
+        self,
+        *,
+        node: LiteralNode,
+        dispatch: Dispatch[EmptyContext],  # noqa: ARG002
+        context: EmptyContext,  # noqa: ARG002
+    ) -> Any:  # noqa: ANN401
+        return node.value

dynamic_expressions-0.1.1/dynamic_expressions.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.2
+Name: dynamic-expressions
+Version: 0.1.1
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Provides-Extra: cache-redis
+Requires-Dist: redis>=5.2.1; extra == "cache-redis"
+Provides-Extra: serialization-pydantic
+Requires-Dist: pydantic>=2.10.6; extra == "serialization-pydantic"
+Provides-Extra: serialization-msgspec
+Requires-Dist: msgspec>=0.19.0; extra == "serialization-msgspec"

dynamic_expressions-0.1.1/dynamic_expressions.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+README.md
+pyproject.toml
+dynamic_expressions/__init__.py
+dynamic_expressions/dispatcher.py
+dynamic_expressions/extensions.py
+dynamic_expressions/nodes.py
+dynamic_expressions/py.typed
+dynamic_expressions/types.py
+dynamic_expressions/visitors.py
+dynamic_expressions.egg-info/PKG-INFO
+dynamic_expressions.egg-info/SOURCES.txt
+dynamic_expressions.egg-info/dependency_links.txt
+dynamic_expressions.egg-info/requires.txt
+dynamic_expressions.egg-info/top_level.txt
+dynamic_expressions/cache/__init__.py
+dynamic_expressions/cache/base.py
+dynamic_expressions/cache/redis.py
+dynamic_expressions/serialization/__init__.py
+dynamic_expressions/serialization/_serialization.py
+dynamic_expressions/serialization/msgspec.py
+dynamic_expressions/serialization/pydantic.py

dynamic_expressions-0.1.1/dynamic_expressions.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

dynamic_expressions-0.1.1/dynamic_expressions.egg-info/requires.txt

@@ -0,0 +1,9 @@
+
+[cache-redis]
+redis>=5.2.1
+
+[serialization-msgspec]
+msgspec>=0.19.0
+
+[serialization-pydantic]
+pydantic>=2.10.6

dynamic_expressions-0.1.1/dynamic_expressions.egg-info/top_level.txt

@@ -0,0 +1 @@
+dynamic_expressions

dynamic_expressions-0.1.1/pyproject.toml

@@ -0,0 +1,144 @@
+[project]
+name = "dynamic-expressions"
+version = "0.1.1"
+description = ""
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = []
+
+[project.optional-dependencies]
+cache-redis = [
+    "redis>=5.2.1",
+]
+serialization-pydantic = [
+    "pydantic>=2.10.6",
+]
+serialization-msgspec = [
+    "msgspec>=0.19.0",
+]
+
+[dependency-groups]
+dev = [
+    "anyio>=4.8.0",
+    "commitizen",
+    "coverage>=7.6.10",
+    "deptry>=0.23.0",
+    "mypy>=1.14.1",
+    "pytest>=8.3.4",
+    "redis>=5.2.1",
+    "ruff>=0.9.4",
+    "testcontainers>=4.9.1",
+    "types-redis>=4.6.0.20241004",
+]
+
+
+[tool.pytest.ini_options]
+pythonpath = "."
+markers = ["redis"]
+
+[tool.coverage.run]
+source = ["dynamic_expressions"]
+omit = []
+command_line = "-m pytest -v"
+concurrency = []
+branch = true
+
+[tool.coverage.report]
+exclude_lines = [
+    "class .*\\(.*\\bProtocol\\b.*\\):",
+    "@(?:typing\\.)?overload",
+    "if TYPE_CHECKING:",
+]
+
+[tool.deptry]
+[tool.deptry.per_rule_ignores]
+DEP002 = []
+
+[tool.mypy]
+plugins = [
+    "pydantic.mypy",
+]
+
+strict = true
+follow_imports = "normal"
+ignore_missing_imports = false
+
+allow_redefinition = false
+disallow_any_explicit = false
+ignore_errors = false
+local_partial_types = true
+no_implicit_optional = true
+strict_optional = true
+warn_no_return = true
+warn_return_any = true
+warn_unreachable = true
+
+pretty = true
+show_column_numbers = true
+show_error_codes = true
+
+[tool.pydantic-mypy]
+init_forbid_extra = true
+init_typed = true
+
+[tool.ruff]
+src = ["src", "tests"]
+[tool.ruff.lint]
+fixable = [
+    "F",
+    "E",
+    "W",
+    "I",
+    "COM",
+    "UP",
+    "RUF",
+]
+unfixable = [
+    "F841", # Variable  is assigned to but never used
+]
+select = ["ALL"]
+ignore = [
+    "E501", # Line Length
+    "D10", # Disable mandatory docstrings
+    "D203", # one-blank-line-before-class
+    "D212", # multi-line-summary-first-line
+    "PD", # pandas-vet
+    "EXE",
+    "COM812",  # ruff format conflict
+    "ISC001",  # ruff format conflict
+]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["S101"]
+
+[tool.ruff.lint.flake8-builtins]
+builtins-allowed-modules = ["types"]
+
+[tool.ruff.lint.flake8-pytest-style]
+fixture-parentheses = false
+mark-parentheses = false
+
+[tool.ruff.lint.mccabe]
+max-complexity = 6
+
+[tool.ruff.lint.flake8-bugbear]
+extend-immutable-calls = []
+
+[tool.ruff.lint.pep8-naming]
+classmethod-decorators = ["classmethod"]
+staticmethod-decorators = ["staticmethod"]
+
+[tool.ruff.lint.flake8-tidy-imports]
+ban-relative-imports = "parents"
+
+[tool.commitizen]
+name = "cz_conventional_commits"
+version = "0.1.1"
+tag_format = "$version"
+version_scheme = "pep440"
+version_provider = "pep621"
+major_version_zero = true
+update_changelog_on_bump = true
+version_files = [
+    "pyproject.toml:version",
+]

dynamic_expressions-0.1.1/setup.cfg

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