jsonpatch-trigger 0.1.0__tar.gz

jsonpatch_trigger-0.1.0/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: jsonpatch-trigger
+Version: 0.1.0
+Summary: Extension for JSONPatch (RFC6902) that introduces operation preconditions, change tracking and automated listeners that can introduce new operations based on the previous change
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: python-jsonpath==2.0.2
+Requires-Dist: pydantic==2.12.5
+Provides-Extra: test
+Requires-Dist: coverage==7.13.4; extra == "test"
+Requires-Dist: pytest==9.0.2; extra == "test"
+
+# JSONPatch-Trigger
+
+This package extends the JSON Patch (RFC 6902) functionality with the following features:
+- Preconditions for operations that prevent their execution
+- Usage of JSONPaths over JSONPointers to allow operation targets with wildcards and conditions
+- Change tracking of each operation (a list of additionas and deletions as JSONPointers)
+- Listeners that can react to the tracked changes to dynamically perform customizable actions when something in the JSON document has changed
+
+The JSONPath and JSONPatch implementations used as a basis are from https://pypi.org/project/python-jsonpath/
+
+## Use Case
+The functionalities in this package have been developed to serve the following use case:
+
+A process P produces JSON objects.
+Every time P executes the results needs to be adjusted with changes the user can configure.
+So the set of operations is persisted and applied for every process run.
+There are different processes and each requires a different set of user operations.
+Additionally, the produced JSON objects can have patterns that can be changed automatically instead of with a manual user action.
+However, the automated steps might be dependent on the order of user operations.
+So instead of appending or prepending the automated operations, a listener approach is used to apply the automated operation as soon as a certain path in the document is modified (triggered).
+For this to work properly the first operation is always an AddOperation that 
+adds the entire existing object therefore the tracking produces an addition for every JSONPointer in the document.
+
+## CI Debug Counter
+3

jsonpatch_trigger-0.1.0/README.md

@@ -0,0 +1,25 @@
+# JSONPatch-Trigger
+
+This package extends the JSON Patch (RFC 6902) functionality with the following features:
+- Preconditions for operations that prevent their execution
+- Usage of JSONPaths over JSONPointers to allow operation targets with wildcards and conditions
+- Change tracking of each operation (a list of additionas and deletions as JSONPointers)
+- Listeners that can react to the tracked changes to dynamically perform customizable actions when something in the JSON document has changed
+
+The JSONPath and JSONPatch implementations used as a basis are from https://pypi.org/project/python-jsonpath/
+
+## Use Case
+The functionalities in this package have been developed to serve the following use case:
+
+A process P produces JSON objects.
+Every time P executes the results needs to be adjusted with changes the user can configure.
+So the set of operations is persisted and applied for every process run.
+There are different processes and each requires a different set of user operations.
+Additionally, the produced JSON objects can have patterns that can be changed automatically instead of with a manual user action.
+However, the automated steps might be dependent on the order of user operations.
+So instead of appending or prepending the automated operations, a listener approach is used to apply the automated operation as soon as a certain path in the document is modified (triggered).
+For this to work properly the first operation is always an AddOperation that 
+adds the entire existing object therefore the tracking produces an addition for every JSONPointer in the document.
+
+## CI Debug Counter
+3

jsonpatch_trigger-0.1.0/pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "jsonpatch-trigger"
+version = "0.1.0"
+description = "Extension for JSONPatch (RFC6902) that introduces operation preconditions, change tracking and automated listeners that can introduce new operations based on the previous change"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "python-jsonpath==2.0.2",
+    "pydantic==2.12.5"
+]
+[project.optional-dependencies]
+test = [
+    "coverage==7.13.4",
+    "pytest==9.0.2"
+]

jsonpatch_trigger-0.1.0/setup.cfg

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

jsonpatch_trigger-0.1.0/src/jsonpatch_trigger/__init__.py

@@ -0,0 +1,8 @@
+from .common import json_type, make_jsonpath, normalize_jsonpath
+from .execution import OperationExecutionContext, AutomatedOperationProducer
+from .operations import Operation, AddOperation, MoveOperation, CopyOperation, CompoundOperation, RemoveOperation
+
+__ALL__ = ["json_type", "make_jsonpath", "normalize_jsonpath",
+           "OperationExecutionContext", "AutomatedOperationProducer",
+           "Operation", "AddOperation", "MoveOperation", "CopyOperation", "CompoundOperation", "RemoveOperation"]
+

jsonpatch_trigger-0.1.0/src/jsonpatch_trigger/common.py

@@ -0,0 +1,50 @@
+from typing import Sequence, Any, Mapping
+
+import jsonpath
+from jsonpath import JSONPath
+from pydantic import TypeAdapter
+from pydantic_core import core_schema
+
+json_type = str | int | float | bool | None | Sequence[Any] | Mapping[str, Any]
+
+
+def make_jsonpath(path_string: str) -> JSONPath:
+    return jsonpath.compile(str(jsonpath.compile(path_string)))
+
+
+def normalize_jsonpath(path: JSONPath) -> JSONPath:
+    return jsonpath.compile(str(path))
+
+
+def serialize_jsonpath(path: JSONPath) -> str:
+    return str(path)
+
+
+#
+#
+# class ThirdPartyPydanticAdapter:
+#     @staticmethod
+#     def __get_pydantic_core_schema__(source_type, handler: GetCoreSchemaHandler):
+#         return core_schema.no_info_wrap_validator_function(
+#             make_jsonpath,
+#             core_schema.str_schema(),
+#             serialization=core_schema.plain_serializer_function_ser_schema(
+#                 serialize_jsonpath,
+#                 return_schema=core_schema.str_schema(),
+#             )
+#         )
+#
+#
+# class JSONPathAdapter(TypeAdapter):
+#
+#     @classmethod
+#     def __get_pydantic_core_schema__(cls, source_type, handler):
+#         return core_schema.chain_schema([
+#             core_schema.str_schema(),
+#             core_schema.no_info_after_validator_function(
+#                 make_jsonpath,
+#                 serialization=core_schema.plain_serializer_function_ser_schema(
+#                     serialize_jsonpath
+#                 )
+#             )
+#         ])

jsonpatch_trigger-0.1.0/src/jsonpatch_trigger/compat.py

@@ -0,0 +1,177 @@
+from typing import (
+    Any,
+    Callable,
+)
+
+from pydantic_core import core_schema
+from typing_extensions import Annotated
+
+from pydantic import (
+    BaseModel,
+    GetJsonSchemaHandler,
+    ValidationError,
+)
+from pydantic.json_schema import JsonSchemaValue
+
+from jsonpath import JSONPath, JSONPointer
+
+from jsonpatch_trigger import make_jsonpath
+
+
+class _JSONPointerPydanticAnnotation:
+    @classmethod
+    def __get_pydantic_core_schema__(
+            cls,
+            _source_type: Any,
+            _handler: Callable[[Any], core_schema.CoreSchema],
+    ) -> core_schema.CoreSchema:
+        """
+        We return a pydantic_core.CoreSchema that behaves in the following ways:
+
+        * ints will be parsed as `ThirdPartyType` instances with the int as the x attribute
+        * `ThirdPartyType` instances will be parsed as `ThirdPartyType` instances without any changes
+        * Nothing else will pass validation
+        * Serialization will always return just an int
+        """
+
+        # def validate_from_int(value: int) -> ThirdPartyType:
+        #     result = ThirdPartyType()
+        #     result.x = value
+        #     return result
+
+        from_string_schema = core_schema.chain_schema(
+            [
+                core_schema.str_schema(),
+                core_schema.no_info_plain_validator_function(JSONPointer),
+            ]
+        )
+
+        return core_schema.json_or_python_schema(
+            json_schema=from_string_schema,
+            python_schema=core_schema.union_schema(
+                [
+                    # check if it's an instance first before doing any further work
+                    core_schema.is_instance_schema(JSONPointer),
+                    from_string_schema,
+                ]
+            ),
+            serialization=core_schema.plain_serializer_function_ser_schema(
+                lambda instance: str(instance)
+            ),
+        )
+
+    @classmethod
+    def __get_pydantic_json_schema__(
+            cls, _core_schema: core_schema.CoreSchema, handler: GetJsonSchemaHandler
+    ) -> JsonSchemaValue:
+        # Use the same schema that would be used for `str`
+        return handler(core_schema.str_schema())
+
+
+PydanticJSONPointer = Annotated[
+    JSONPointer, _JSONPointerPydanticAnnotation
+]
+
+
+class _JSONPathPydanticAnnotation:
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls,
+        _source_type: Any,
+        _handler: Callable[[Any], core_schema.CoreSchema],
+    ) -> core_schema.CoreSchema:
+        """
+        We return a pydantic_core.CoreSchema that behaves in the following ways:
+
+        * ints will be parsed as `ThirdPartyType` instances with the int as the x attribute
+        * `ThirdPartyType` instances will be parsed as `ThirdPartyType` instances without any changes
+        * Nothing else will pass validation
+        * Serialization will always return just an int
+        """
+
+        # def validate_from_int(value: int) -> ThirdPartyType:
+        #     result = ThirdPartyType()
+        #     result.x = value
+        #     return result
+
+        from_string_schema = core_schema.chain_schema(
+            [
+                core_schema.str_schema(),
+                core_schema.no_info_plain_validator_function(make_jsonpath),
+            ]
+        )
+
+        return core_schema.json_or_python_schema(
+            json_schema=from_string_schema,
+            python_schema=core_schema.union_schema(
+                [
+                    # check if it's an instance first before doing any further work
+                    core_schema.is_instance_schema(JSONPath),
+                    from_string_schema,
+                ]
+            ),
+            serialization=core_schema.plain_serializer_function_ser_schema(
+                lambda instance: str(instance)
+            ),
+        )
+
+    @classmethod
+    def __get_pydantic_json_schema__(
+        cls, _core_schema: core_schema.CoreSchema, handler: GetJsonSchemaHandler
+    ) -> JsonSchemaValue:
+        # Use the same schema that would be used for `str`
+        return handler(core_schema.str_schema())
+
+
+# We now create an `Annotated` wrapper that we'll use as the annotation for fields on `BaseModel`s, etc.
+PydanticJSONPath = Annotated[
+    JSONPath, _JSONPathPydanticAnnotation
+]
+
+
+
+#
+# # Create a model class that uses this annotation as a field
+# class Model(BaseModel):
+#     third_party_type: PydanticJSONPath
+#
+#
+# # Demonstrate that this field is handled correctly, that ints are parsed into `ThirdPartyType`, and that
+# # these instances are also "dumped" directly into ints as expected.
+# m_int = Model(third_party_type=1)
+# assert isinstance(m_int.third_party_type, ThirdPartyType)
+# assert m_int.third_party_type.x == 1
+# assert m_int.model_dump() == {'third_party_type': 1}
+#
+# # Do the same thing where an instance of ThirdPartyType is passed in
+# instance = ThirdPartyType()
+# assert instance.x == 0
+# instance.x = 10
+#
+# m_instance = Model(third_party_type=instance)
+# assert isinstance(m_instance.third_party_type, ThirdPartyType)
+# assert m_instance.third_party_type.x == 10
+# assert m_instance.model_dump() == {'third_party_type': 10}
+#
+# # Demonstrate that validation errors are raised as expected for invalid inputs
+# try:
+#     Model(third_party_type='a')
+# except ValidationError as e:
+#     print(e)
+#     """
+#     2 validation errors for Model
+#     third_party_type.is-instance[ThirdPartyType]
+#       Input should be an instance of ThirdPartyType [type=is_instance_of, input_value='a', input_type=str]
+#     third_party_type.chain[int,function-plain[validate_from_int()]]
+#       Input should be a valid integer, unable to parse string as an integer [type=int_parsing, input_value='a', input_type=str]
+#     """
+#
+#
+# assert Model.model_json_schema() == {
+#     'properties': {
+#         'third_party_type': {'title': 'Third Party Type', 'type': 'integer'}
+#     },
+#     'required': ['third_party_type'],
+#     'title': 'Model',
+#     'type': 'object',
+# }

jsonpatch_trigger-0.1.0/src/jsonpatch_trigger/execution.py

@@ -0,0 +1,243 @@
+import abc
+import collections
+import json
+from typing import Any, Self, ClassVar
+
+from jsonpath import JSONPath, JSONPointer
+from jsonpath.segments import JSONPathSegment
+from jsonpath.selectors import NameSelector, KeySelector, WildcardSelector, KeysSelector, SliceSelector, \
+    SingularQuerySelector, Filter, KeysFilter
+from pydantic import BaseModel, ConfigDict, Field, field_validator, field_serializer, computed_field, model_validator, \
+    ValidationError
+
+from jsonpatch_trigger import make_jsonpath
+from jsonpatch_trigger.operations import Operation, Operation
+from jsonpatch_trigger.tracking import ChangeTracker
+
+
+def can_pointer_match_path(pointer: JSONPointer, path: JSONPath) -> bool:
+    pointer_index = len(pointer.parts) - 1
+    path_index = len(path.segments) - 1
+
+    while pointer_index >= 0 and path_index >= 0:
+        pointer_part: str | int = pointer.parts[pointer_index]
+        segment: JSONPathSegment = path.segments[path_index]
+
+        solvable = False
+        for selector in segment.selectors:
+            if isinstance(selector, NameSelector):
+                if selector.name == pointer_part:
+                    solvable = True
+            elif isinstance(selector, KeySelector):
+                if selector.key == pointer_part:
+                    solvable = True
+            elif isinstance(selector, WildcardSelector):
+                solvable = True
+            elif isinstance(selector, KeysSelector):
+                pass
+            elif isinstance(selector, SliceSelector):
+                pass
+            elif isinstance(selector, SingularQuerySelector):
+                query = selector.query
+                sub_pointer_starting_index = pointer_index
+                inner_solvable = False
+                while sub_pointer_starting_index >= 0:
+                    sub_pointer = JSONPointer.from_parts(pointer.parts[sub_pointer_starting_index:pointer_index + 1])
+                    if can_pointer_match_path(sub_pointer, query):
+                        sub_pointer_starting_index -= 1
+                        inner_solvable = True
+                    else:
+                        sub_pointer_starting_index += 1
+                        break
+                if inner_solvable:
+                    pointer_index -= pointer_index - sub_pointer_starting_index
+                    solvable = True
+            elif isinstance(selector, Filter):
+                pass
+            elif isinstance(selector, KeysFilter):
+                pass
+        if not solvable:
+            return False
+        pointer_index -= 1
+        path_index -= 1
+
+    return pointer_index == path_index
+
+
+class AutomatedOperationProducer(BaseModel, abc.ABC):
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True
+    )
+
+    triggers: list[JSONPath] = Field(default_factory=list)
+
+    @computed_field
+    @property
+    def producer_type(self) -> str:
+        return self.__class__.__qualname__
+
+    _registry: ClassVar[dict[str, type[Self]]] = {}
+
+    def __init_subclass__(cls, **kwargs):
+        cls._registry[cls.__qualname__] = cls
+
+    @model_validator(mode='before')
+    @classmethod
+    def validate(
+            cls,
+            value: Any,
+            *,
+            strict: bool | None = None,
+            from_attributes: bool | None = None,
+            context: Any | None = None,
+    ):
+        if isinstance(value, AutomatedOperationProducer):
+            return value
+        elif isinstance(value, dict):
+            if cls is not AutomatedOperationProducer:
+                return value
+            producer_type = value.pop('producer_type')
+            return cls._registry[producer_type](**value)
+        raise ValidationError("Cannot deserialize automated producer")
+
+    @abc.abstractmethod
+    def run(
+            self,
+            document: Any,
+            modified_pointers: list[JSONPointer]
+    ) -> list[Operation]:
+        ...
+
+    @field_validator('triggers', mode='before')
+    @classmethod
+    def parse_triggers(cls, value_list):
+        return [
+            p
+            if isinstance(p, JSONPath) else
+            make_jsonpath(p)
+            for p in value_list
+        ]
+
+    @field_serializer('triggers', when_used='always')
+    def serialize_triggers(self, path_list: list[JSONPath]):
+        return [
+            str(p)
+            for p in path_list
+        ]
+
+
+# class OperationExecutionDTO(BaseModel):
+#     model_config = ConfigDict(
+#         revalidate_instances='never'
+#     )
+#
+#     operations: list[Operation]
+#     # listeners: dict[str, list[str]]
+#     producers: list[AutomatedOperationProducer]
+#
+#     @model_validator(mode='after')
+#     @classmethod
+#     def validate(cls, value: Any):
+#         if isinstance(value, cls):
+#             return value
+#         return cls(**value)
+#
+#     # @field_validator('operations', mode='before')
+#     # @classmethod
+#     # def _serialize_operations(cls, operation_list: list[Operation]):
+#     #     return [
+#     #         op.model_dump()
+#     #         for op in operation_list
+#     #     ]
+#
+#     @field_serializer('operations')
+#     def serialize_operations(self, operations: list[Operation]) -> list[dict]:
+#         return [
+#             op.model_dump() for op in operations
+#         ]
+#
+#     @field_serializer('producers')
+#     def serialize_producers(self, producers: list[AutomatedOperationProducer]) -> list[dict]:
+#         return [
+#             prod.model_dump() for prod in producers
+#         ]
+
+
+class OperationExecutionContext:
+
+    def __init__(self):
+        self.listeners: dict[JSONPath, list[AutomatedOperationProducer]] = collections.defaultdict(list)
+        self.operations: collections.deque[Operation] = collections.deque()
+
+    def register(self, producer: AutomatedOperationProducer):
+        for trigger in producer.triggers:
+            self.listeners[trigger].append(producer)
+
+    def add_custom_operations(self, operations: list[Operation]):
+        self.operations.extend(operations)
+
+    def add_custom_operation(self, operation: Operation):
+        self.operations.append(operation)
+
+    def run(self, document: Any) -> Any:
+
+        while self.operations:
+            operation = self.operations.popleft()
+            change_tracker = ChangeTracker()
+            document = operation.apply_rfc(document, change_tracker)
+            for trigger in self.listeners.keys():
+                # TODO we might encounter scenarios where we would want to also trigger on removal
+                relevant_pointers = [p for p in change_tracker.additions if can_pointer_match_path(p, trigger)]
+                if relevant_pointers:
+                    for producer in self.listeners[trigger]:
+                        added_operations = producer.run(document, relevant_pointers)
+                        self.operations.extendleft(reversed(added_operations))
+        return document
+
+    def serialize(self) -> dict:
+        flat_producer_lookup = {
+            producer.__class__.__name__: producer
+            for producers in self.listeners.values()
+            for producer in producers
+        }
+        return dict(
+            operations=[
+                op.model_dump()
+                for op in self.operations
+            ],
+            producers=[
+                producer.model_dump()
+                for producer in flat_producer_lookup.values()
+            ]
+        )
+        # return OperationExecutionDTO(
+        #     operations=list(self.operations),
+        #     producers=list(flat_producer_lookup.values())
+        #     # listeners={
+        #     #     str(path): [
+        #     #         producer.__class__.__name__
+        #     #         for producer in producers
+        #     #     ]
+        #     #     for path, producers in self.listeners.items()
+        #     # }
+        # )
+
+    @classmethod
+    def deserialize(cls, data: Any) -> Self:
+        if isinstance(data, str):
+            data = json.loads(data)
+
+        operations = [
+            Operation.validate(op)
+            for op in data['operations']
+        ]
+        producers = [
+            AutomatedOperationProducer.validate(producer)
+            for producer in data['producers']
+        ]
+
+        self = cls()
+        self.add_custom_operations(operations)
+        for producer in producers:
+            self.register(producer)
+        return self