jsonpatch-trigger 0.1.0__py3-none-any.whl

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/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/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/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

jsonpatch_trigger/operations.py

@@ -0,0 +1,466 @@
+import abc
+from typing import Any, Annotated, Union, ClassVar, Self
+
+from jsonpath import JSONPointer, JSONPath, JSONPathMatch, JSONPointerIndexError, JSONPointerKeyError
+from jsonpath.selectors import NameSelector, JSONPathSelector, IndexSelector
+from pydantic import PrivateAttr, Field, ConfigDict, BaseModel, Discriminator, Tag, computed_field, model_validator, \
+    ValidationError, model_serializer, field_serializer
+
+from jsonpatch_trigger import json_type
+from jsonpatch_trigger.compat import PydanticJSONPath
+from jsonpatch_trigger.parents import make_parent_key_pairs
+from jsonpatch_trigger.preconditions import Precondition, IsArrayOrObjectPreconditionFunction, ExistsPreconditionFunction, \
+    DoesNotExistPreconditionFunction
+from jsonpatch_trigger.tracking import ChangeTracker, TrackingJSONPatch, RemovalRegistrationMixin, \
+    CopyRegistrationMixin, AddRegistrationMixin, MoveRegistrationMixin
+
+
+class OperationBehavior(abc.ABC):
+    ...
+
+
+class Operation(BaseModel, abc.ABC):
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+        revalidate_instances='never'
+    )
+    _preconditions: list[Precondition] = PrivateAttr(default_factory=list)
+    user_preconditions: list[Precondition] = Field(default_factory=list)
+
+    locator: PydanticJSONPath
+
+    @computed_field
+    @property
+    def operation_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, Operation):
+            return value
+        elif isinstance(value, dict):
+            if cls is not Operation:
+                return value
+            operation_type = value.pop('operation_type')
+            return cls._registry[operation_type](**value)
+        raise ValidationError("Cannot deserialize operation")
+
+    # @model_serializer(mode='plain')
+    # def serialize(self) -> dict:
+    #     cls = self.__class__
+    #     return cls.model_dump(self)
+
+    @property
+    def preconditions(self) -> list[Precondition]:
+        return self._preconditions + self.user_preconditions
+
+    # @property
+    # def parent_locators(self) -> list[JSONPath]:
+    #     return make_parent_key_pairs(self.locator)
+
+    # @property
+    # def key(self) -> int | str | None:
+    #     return self.locator.segments[-1].selectors[0].name
+
+    @staticmethod
+    def iterate_matches(
+            path: JSONPath,
+            document: Any,
+            none_allowed=False,
+            only_resolvable_pointers=False
+    ) -> list[tuple[JSONPath, JSONPathMatch, JSONPathSelector, JSONPointer]]:
+        results = []
+
+        parent_key_pairs = make_parent_key_pairs(path)
+        for parent_path, selector in parent_key_pairs:
+            for parent_match in parent_path.finditer(document):
+                pointer = JSONPointer.from_match(parent_match)
+                if isinstance(selector, NameSelector):
+                    pointer = pointer.join(selector.name)
+                elif isinstance(selector, IndexSelector):
+                    if selector.index == -1:
+                        pointer = pointer.join('-')
+                    elif selector.index < 0:
+                        raise RuntimeError('Cannot use negative indexes other than -1 for json pointers')
+                    else:
+                        pointer = pointer.join(str(selector.index))
+                elif none_allowed and selector is None:
+                    pass
+                else:
+                    raise NotImplementedError('Selector type not supported')
+                if only_resolvable_pointers:
+                    try:
+                        pointer.resolve(document)
+                    except (JSONPointerIndexError, JSONPointerKeyError):
+                        continue
+                results.append((parent_path, parent_match, selector, pointer))
+        return results
+
+    # def apply(self, onto: Any) -> list[JSONPointer]:
+    #     if not self.test_preconditions(onto):
+    #         return []
+    #     return self._apply(onto)
+
+    def apply_rfc(self, document: Any, change_tracker: ChangeTracker) -> Any:
+        if not self.test_preconditions(document):
+            return document
+        patch_runner = TrackingJSONPatch(change_tracker, self, document)
+        self.register_rfc_operations(document, patch_runner)
+        document = patch_runner.run(document)
+        return document
+
+    # @abc.abstractmethod
+    # def _apply(self, onto: Any) -> list[JSONPointer]:
+    #     ...
+
+    @abc.abstractmethod
+    def register_rfc_operations(self, document: Any, patch_runner: TrackingJSONPatch):
+        ...
+
+    def test_preconditions(self, onto: Any) -> bool:
+        for condition in self.preconditions:
+            match = condition.query.match(onto)
+            if match is None:
+                if isinstance(condition.function, DoesNotExistPreconditionFunction):
+                    return True
+                if isinstance(condition.function, ExistsPreconditionFunction):
+                    return False
+                return False
+
+            if match.obj != condition.function:
+                return False
+        return True
+
+
+# class AddObjectOperation(Operation):
+#
+#     object_key: str
+#
+#     def __init__(self, **data: Any):
+#         super().__init__(**data)
+#         self._preconditions = [
+#             Precondition(
+#                 query=self.locator,
+#                 function=IsObjectPreconditionFunction()
+#             ),
+#             Precondition(
+#                 query=jsonpath.compile(f'{self.locator}.{self.object_key}'),
+#                 function=IsNonePreconditionFunction()
+#             )
+#         ]
+#
+#     def _apply(self, onto: Any) -> list[JSONPointer]:
+#         pointers = []
+#         for ref in self.locator.finditer(onto):
+#             ref.obj[self.object_key] = {}
+#             pointers.append(JSONPointer.from_match(ref).join(self.object_key))
+#         return pointers
+#
+#
+# class InsertScalarOperation(Operation):
+#
+#     # key: int | str
+#     value: int | float | bool | str | None
+#
+#     def __init__(self, /, **data: Any):
+#         super().__init__(**data)
+#         self._preconditions = [
+#             Precondition(
+#                 query=self.locator,
+#                 function=IsArrayOrObjectPreconditionFunction()
+#             ),
+#             Precondition(
+#                 query=jsonpath.compile(f'{self.locator}.{self.key}'),
+#                 function=IsNonePreconditionFunction()
+#             ),
+#         ]
+#
+#     def _apply(self, onto: Any) -> list[JSONPointer]:
+#         match = self.locator.match(onto)
+#         if isinstance(match.obj, MutableMapping):
+#             match.obj[self.key] = self.value
+#         else:
+#             match.obj.insert(self.key, self.value)
+#         return [JSONPointer.from_match(match).join(self.key)]
+
+
+
+# RFC 6902 compliant operations
+
+class AddOperation(Operation, AddRegistrationMixin):
+
+    value: json_type
+
+    # def __init__(self, /, **data: Any):
+    #     super().__init__(**data)
+    #     locator = self.locator
+
+        # parent_locator = make_parent(locator)
+
+        # if len(locator.segments) == 1 and locator.segments[0].selectors:
+        #     _ = 42
+
+        # self._preconditions = [
+        #     Precondition(
+        #         query=self.locator,
+        #
+        #     )
+        # ]
+
+    def register_rfc_operations(self, document: Any, patch_runner: TrackingJSONPatch):
+        for parent_path, parent_match, selector, pointer in (
+                self.iterate_matches(self.locator, document, none_allowed=True)
+        ):
+            patch_runner.add(pointer, self.value)
+
+    # def _apply(self, onto: Any) -> list[JSONPointer]:
+    #     match = self.locator.match(onto)
+    #     parent_matches = [x.match(onto) for x in self.parent_locators]
+    #
+    #     pointers = []
+    #     for parent_match in parent_matches:
+    #         if isinstance(parent_match.obj, MutableMapping):
+    #             parent_match.obj[self.key] = self.value
+    #             pointers.extend(get_all_subtree_pointers(onto, JSONPointer.from_match(match)))
+    #         elif isinstance(parent_match.obj, MutableSequence):
+    #             parent_match.obj.insert(self.key, self.value)
+    #             pointers.extend(get_all_subtree_pointers(onto, JSONPointer.from_match(match)))
+    #     return pointers
+
+
+
+class PointerPairConstraintResolver(BaseModel):
+    def resolve(
+            self,
+            pointers_a: list[JSONPointer],
+            pointers_b: list[JSONPointer]
+    ) -> list[tuple[JSONPointer, JSONPointer]]:
+        if len(pointers_a) != 1 or len(pointers_b) != 1:
+            raise RuntimeError('Only a single pair is allowed')
+        return [(pointers_a[0], pointers_b[0])]
+
+
+class OneToManyPointerPairConstraintResolver(PointerPairConstraintResolver):
+    def resolve(
+            self,
+            pointers_a: list[JSONPointer],
+            pointers_b: list[JSONPointer]
+    ) -> list[tuple[JSONPointer, JSONPointer]]:
+        if len(pointers_a) != 1 or len(pointers_b) == 0:
+            raise RuntimeError('Invalid one to many pointer pairs')
+        return [
+            (pointers_a[0], pointer)
+            for pointer in pointers_b
+        ]
+
+
+class PairwisePointerPairConstraintResolver(PointerPairConstraintResolver):
+    def resolve(
+            self,
+            pointers_a: list[JSONPointer],
+            pointers_b: list[JSONPointer]
+    ) -> list[tuple[JSONPointer, JSONPointer]]:
+        if len(pointers_a) != len(pointers_b):
+            raise RuntimeError('Can\'t handle number of pointers for move')
+        return [
+            (p_a, p_b)
+            for p_a, p_b in zip(
+                sorted(pointers_a, key=lambda p: str(p)),
+                sorted(pointers_b, key=lambda p: str(p))
+            )
+        ]
+
+
+class MoveOperation(Operation, MoveRegistrationMixin):
+
+    target_locator: PydanticJSONPath
+    constraint_strategy: PointerPairConstraintResolver = Field(default_factory=PointerPairConstraintResolver)
+
+    def register_rfc_operations(self, document: Any, patch_runner: TrackingJSONPatch):
+        source_data_tuple = self.iterate_matches(self.locator, document, none_allowed=True)
+        target_data_tuple = self.iterate_matches(self.target_locator, document, none_allowed=True)
+
+        source_pointers = [t[3] for t in source_data_tuple]
+        target_pointers = [t[3] for t in target_data_tuple]
+
+        for source_pointer, target_pointer in self.constraint_strategy.resolve(source_pointers, target_pointers):
+            try:
+                source_pointer.resolve(document)
+            except (JSONPointerIndexError, JSONPointerKeyError):
+                continue  # this can happen, and we don't consider it an error
+            patch_runner.move(source_pointer, target_pointer)
+
+
+        # TODO check what happens if the target pointer is below the source pointer? will it just insert a copy of the original object or is this referencing each other
+        # parent_key_pairs = make_parent_key_pairs(self.locator)
+        #
+        # assert len(parent_key_pairs) == 1  # we should only have one source-key pair otherwise the behavior is not clear
+        # source_matches = list(self.locator.finditer(document))
+        #
+        # # however for actual matches it is fine if we can find clear pairs of source and target
+        # #  e.g. to move several attributes with the same name in multiple classes
+        # #   but this is a generic move operation that has no knowledge on what would be okay
+        # #   i guess I need another workaround here...
+        #
+        # source_pointers = sorted([JSONPointer.from_match(match) for match in source_matches])
+        #
+        # target_matches = self.iterate_matches(self.target_locator, document, none_allowed=False)
+        # target_pointers = sorted([JSONPointer.from_match(match) for match in target_matches])
+        #
+        #
+        # for source_pointer, target_pointer in zip(source_pointers, target_pointers):
+        #
+        # # assert len(source_matches) == 1
+        # source_pointer = JSONPointer.from_match(source_matches[0])
+        #
+        #
+        # assert len(matches) == 1  # we should only have one target otherwise the behavior is not clear
+        #
+        # parent_path, parent_match, selector, pointer = matches[0]
+        # patch_runner.move(source_pointer, pointer)
+
+
+
+class CopyOperation(Operation, CopyRegistrationMixin):
+
+    target_locator: PydanticJSONPath
+    constraint_strategy: PointerPairConstraintResolver = Field(default_factory=OneToManyPointerPairConstraintResolver)
+    # target_key: str | int
+
+    def __init__(self, **data: Any):
+        super().__init__(**data)
+        self._preconditions = [
+            Precondition(
+                query=self.locator,
+                function=IsArrayOrObjectPreconditionFunction()
+            )
+        ]
+
+    def register_rfc_operations(self, document: Any, patch_runner: TrackingJSONPatch):
+        source_data_tuple = self.iterate_matches(self.locator, document, none_allowed=True,
+                                                 only_resolvable_pointers=True)
+        target_data_tuple = self.iterate_matches(self.target_locator, document, none_allowed=True)
+
+        source_pointers = [t[3] for t in source_data_tuple]
+        target_pointers = [t[3] for t in target_data_tuple]
+
+        for source_pointer, target_pointer in self.constraint_strategy.resolve(source_pointers, target_pointers):
+            patch_runner.copy(source_pointer, target_pointer)
+
+        # parent_key_pairs = make_parent_key_pairs(self.locator)
+        # assert len(parent_key_pairs) == 1  # we should only have one source otherwise the behavior is not clear
+        # source_matches = list(self.locator.finditer(document))
+        # assert len(source_matches) == 1
+        # source_pointer = JSONPointer.from_match(source_matches[0])
+        #
+        # for parent_path, parent_match, selector, pointer in (
+        #     self.iterate_matches(self.target_locator, document, none_allowed=False)
+        # ):
+        #     patch_runner.copy(source_pointer, pointer)
+
+    # def _apply(self, onto: Any) -> list[JSONPointer]:
+    #     match = self.locator.match(onto)
+    #     target_parent = self.target_locator.match(onto)
+    #     if isinstance(target_parent.obj, MutableMapping):
+    #         target_parent.obj[self.target_key] = match.obj
+    #         return get_all_subtree_pointers(
+    #             onto,
+    #             JSONPointer.from_match(target_parent)
+    #             .join(self.target_key)
+    #         )
+    #     elif isinstance(target_parent.obj, MutableSequence):
+    #         target_parent.obj.insert(self.target_key, match.obj)
+    #         return get_all_subtree_pointers(
+    #             onto,
+    #             JSONPointer.from_match(target_parent)
+    #             .join(self.target_key)
+    #         )
+    #     raise RuntimeError('Invalid state')
+
+
+class RemoveOperation(Operation, RemovalRegistrationMixin):
+
+    # key: str | int
+    #
+    # def __init__(self, **data: Any):
+    #     super().__init__(**data)
+    #     # if self.key is not None:
+    #     self._preconditions = [
+    #         Precondition(
+    #             query=self.locator,
+    #             function=IsArrayOrObjectPreconditionFunction()
+    #         )
+    #     ]
+        # else:
+        #     self._preconditions = [
+        #         Precondition(
+        #             query=self.locator,
+        #             function=IsNotNonePreconditionFunction()
+        #         )
+        #     ]
+    def register_rfc_operations(self, document: Any, patch_runner: TrackingJSONPatch):
+        for parent_path, parent_match, selector, pointer in (
+            self.iterate_matches(self.locator, document, none_allowed=False)
+        ):
+            patch_runner.remove(pointer)
+
+    # def _apply(self, onto: Any) -> list[JSONPointer]:
+    #     match = self.locator.match(onto)
+    #     # if isinstance(match.obj, (MutableMapping, MutableSequence)):
+    #     pointers = get_all_subtree_pointers(
+    #         onto,
+    #         JSONPointer.from_match(match).join(self.key)
+    #     )
+    #     del match.obj[self.key]
+    #     return pointers
+
+# End RFC 6902 compliant operations
+
+class CompoundOperation(Operation):
+
+    inner_operations: list[Operation]
+
+    def register_rfc_operations(self, document: Any, patch_runner: TrackingJSONPatch):
+        for operation in self.inner_operations:
+            operation.register_rfc_operations(document, patch_runner)
+
+    def apply_rfc(self, document: Any, change_tracker: ChangeTracker) -> Any:
+        if not self.test_preconditions(document):
+            return document
+        for operation in self.inner_operations:
+            document = operation.apply_rfc(document, change_tracker)
+        return document
+
+    @field_serializer('inner_operations')
+    def _serialize_inner_operations(self, ops: list[Operation]) -> list[dict]:
+        return [
+            op.model_dump() for op in ops
+        ]
+
+
+def _get_type_designator(obj: Operation) -> str:
+    return obj.__class__.__qualname__
+
+# Operation = Annotated[
+#     Union[
+#         Annotated[AddOperation, Tag('AddOperation')],
+#         Annotated[RemoveOperation, Tag('RemoveOperation')],
+#         Annotated[CompoundOperation, Tag('CompoundOperation')],
+#         Annotated[MoveOperation, Tag('MoveOperation')],
+#         Annotated[CopyOperation, Tag('CopyOperation')],
+#     ],
+#     Discriminator(_get_type_designator)
+# ]

jsonpatch_trigger/parents.py

@@ -0,0 +1,61 @@
+from jsonpath import JSONPath
+from jsonpath.segments import JSONPathRecursiveDescentSegment
+from jsonpath.selectors import JSONPathSelector
+
+from jsonpatch_trigger.common import make_jsonpath, normalize_jsonpath
+
+
+def _make_raw_parent(path: JSONPath) -> JSONPath:
+    """
+    This could potentially return an invalid JSONPath that returns on ".." and it loops back on the root if needed
+
+    :param JSONPath path: the JSONPath to create a raw parent from
+    :return: new JSONPath that was stripped by its last segment
+    """
+    return normalize_jsonpath(JSONPath(
+        env=path.env,
+        segments=path.segments[:-1],
+        pseudo_root=path.pseudo_root
+    ))
+
+
+def make_parent_key_pairs(path: JSONPath) -> list[tuple[JSONPath, JSONPathSelector | None]]:
+    if len(path.segments) == 0:  # this is a root path
+        return [(path, None)]
+
+    last_segment = path.segments[-1]
+    selectors = last_segment.selectors
+
+    if isinstance(last_segment, JSONPathRecursiveDescentSegment):
+        base_parent = _make_raw_parent(path)
+        nested_parent = make_jsonpath(f'{base_parent}..*')
+        return [
+            (parent, selector)
+            for parent in [base_parent, nested_parent]
+            for selector in selectors
+        ]
+
+    return [
+        (_make_raw_parent(path), selector)
+        for selector in selectors
+    ]
+
+    allows_parent = True
+    for selector in segment.selectors:
+        if isinstance(selector, NameSelector):
+            pass
+        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):
+            pass
+        elif isinstance(selector, Filter):
+            pass
+        elif isinstance(selector, KeysFilter):
+            pass

jsonpatch_trigger/preconditions.py

@@ -0,0 +1,58 @@
+from typing import MutableSequence, MutableMapping, Any
+
+from jsonpath import JSONPath
+from pydantic import BaseModel
+
+from jsonpatch_trigger.compat import PydanticJSONPath
+
+
+class PreconditionFunction(BaseModel):
+    def __neq__(self, other) -> bool:
+        return not self.__eq__(other)
+
+
+class IsObjectPreconditionFunction(PreconditionFunction):
+    def __eq__(self, other):
+        return isinstance(other, MutableMapping)
+
+
+class IsArrayPreconditionFunction(PreconditionFunction):
+    def __eq__(self, other):
+        return isinstance(other, MutableSequence)
+
+
+class IsArrayOrObjectPreconditionFunction(PreconditionFunction):
+    def __eq__(self, other):
+        return isinstance(other, (MutableMapping, MutableSequence))
+
+
+class ValuePreconditionFunction(PreconditionFunction):
+    value: Any
+    def __eq__(self, other):
+        return other == self.value
+
+
+class IsNonePreconditionFunction(PreconditionFunction):
+    def __eq__(self, other):
+        return other is None
+
+
+class IsNotNonePreconditionFunction(PreconditionFunction):
+    def __eq__(self, other):
+        return other is not None
+
+
+class ExistsPreconditionFunction(PreconditionFunction):
+    ...
+
+
+class DoesNotExistPreconditionFunction(PreconditionFunction):
+    ...
+
+
+class Precondition(BaseModel):
+    query: PydanticJSONPath
+    function: PreconditionFunction
+    # def __init__(self, query: JSONPath, function: PreconditionFunction):
+    #     self.query = query
+    #     self.function = function

jsonpatch_trigger/tracking.py

@@ -0,0 +1,131 @@
+import collections
+import copy
+import functools
+from typing import Any, MutableSequence, MutableMapping
+
+import jsonpath
+from jsonpath import JSONPointer, JSONPatch, JSONPointerIndexError, JSONPointerKeyError
+from pydantic import BaseModel
+
+
+def get_all_subtree_pointers(
+        document: Any,
+        base_pointer: JSONPointer
+) -> set[JSONPointer]:
+    try:
+        obj = base_pointer.resolve(document)
+    except (JSONPointerIndexError, JSONPointerKeyError):
+        return set()
+    if isinstance(obj, MutableMapping):
+        sub_pointers = {
+            copy.deepcopy(base_pointer).join(key)
+            for key in obj.keys()
+        }
+        return {base_pointer} | sub_pointers | {
+            child
+            for pointer in sub_pointers
+            for child in get_all_subtree_pointers(document, pointer)
+        }
+    elif isinstance(obj, MutableSequence):
+        sub_pointers = {
+            copy.deepcopy(base_pointer).join(str(idx))
+            for idx in range(len(obj))
+        }
+        return {base_pointer} | sub_pointers | {
+            child
+            for pointer in sub_pointers
+            for child in get_all_subtree_pointers(document, pointer)
+        }
+    return {base_pointer}
+
+
+class ChangeTracker:
+    def __init__(self):
+        self.additions: set[JSONPointer] = set()
+        self.removals: set[JSONPointer] = set()
+
+    def add_pointers(self, pointers: set[JSONPointer], removal=False):
+        if removal:
+            self.removals |= pointers
+            self.additions -= pointers  # Removes all additions if they are removed again before other actions can trigger
+        else:
+            self.additions |= pointers
+            # TODO for now, we do not do the inverse here: so if something becomes added after removal we still keep it in the removal list
+            #  this should not really matter because we don't trigger anything on removals yet
+
+    def add_pointer_pairs(self, pointer_pairs: list[tuple[JSONPointer, bool]]):
+        pointer_sorter = collections.defaultdict(set)
+        for pointer, removal in pointer_pairs:
+            pointer_sorter[removal].add(pointer)
+        self.add_pointers(pointer_sorter[True])
+        self.add_pointers(pointer_sorter[False])
+
+
+class ChangeRegistrationMixin(BaseModel):
+    @staticmethod
+    def _get_pointer(rfc_operation: jsonpath.patch.Op, slot_names: list[str]) -> JSONPointer:
+        for slot_name in slot_names:
+            pointer = getattr(rfc_operation, slot_name, None)
+            if pointer is not None:
+                return pointer
+        raise RuntimeError('No suitable pointer slot found')
+
+    def pre_execution_registration(self, rfc_operation: jsonpath.patch.Op, change_tracker: ChangeTracker, document: Any):
+        pass
+
+    def post_execution_registration(self, rfc_operation: jsonpath.patch.Op, change_tracker: ChangeTracker, document: Any):
+        pass
+
+
+class RemovalRegistrationMixin(ChangeRegistrationMixin):
+    def pre_execution_registration(self, rfc_operation: jsonpath.patch.Op, change_tracker: ChangeTracker, document: Any):
+        pointer = self._get_pointer(rfc_operation, ['path'])
+        change_tracker.add_pointers(get_all_subtree_pointers(document, pointer), removal=True)
+
+
+class CopyRegistrationMixin(ChangeRegistrationMixin):
+    def post_execution_registration(self, rfc_operation: jsonpath.patch.Op, change_tracker: ChangeTracker, document: Any):
+        pointer = self._get_pointer(rfc_operation, ['dest', 'path'])
+        change_tracker.add_pointers(get_all_subtree_pointers(document, pointer), removal=False)
+
+
+class MoveRegistrationMixin(CopyRegistrationMixin):
+    def pre_execution_registration(self, rfc_operation: jsonpath.patch.Op, change_tracker: ChangeTracker,
+                                   document: Any):
+        pointer = self._get_pointer(rfc_operation, ['source', 'path'])
+        change_tracker.add_pointers(get_all_subtree_pointers(document, pointer), removal=True)
+
+
+# TODO we likely need some further checking if an operation actually overwrites something else or not
+ReplaceRegistrationMixin = MoveRegistrationMixin
+AddRegistrationMixin = MoveRegistrationMixin
+
+
+class TrackingJSONPatch:
+
+    def __init__(self, change_tracker: ChangeTracker, base_operation: ChangeRegistrationMixin, document: Any):
+        self._patch = JSONPatch()
+        self._tracker = change_tracker
+        self._base = base_operation
+        self._document = document
+
+    def __getattr__(self, attr):
+        patch_attr = getattr(self._patch, attr)
+
+        if not attr.startswith('_') and attr != 'apply':
+            # this is a respective method to add an operation
+
+            @functools.wraps(patch_attr)
+            def wrapper(*args, **kwargs):
+                result = patch_attr(*args, **kwargs)
+                self._base.pre_execution_registration(result.ops[-1], self._tracker, self._document)
+                return result
+
+            return wrapper
+        return patch_attr
+
+    def run(self, document: Any) -> Any:
+        for operation in self._patch.ops:
+            document = operation.apply(document)
+            self._base.post_execution_registration(operation, self._tracker, document)
+        return document

jsonpatch_trigger-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,12 @@
+jsonpatch_trigger/__init__.py,sha256=is1e5cn3odL5TN6RmW8tRmqa87MIQ9FcAx5RifhUwT0,505
+jsonpatch_trigger/common.py,sha256=X2k8B24l7I8K-Up7whlkB3F_c4NODxgwbqr4W-bJRhg,1476
+jsonpatch_trigger/compat.py,sha256=rkGYJVVWKYBiLfd172tQedLLbI8FfOwXy82vuwovd5M,5945
+jsonpatch_trigger/execution.py,sha256=JY4esJspBUEb-nKX5ttPol6f1x-Ga3Ul69YxdD3FnfY,8323
+jsonpatch_trigger/operations.py,sha256=ssC7xnQgMoUnL-YVJLxsP9YPcOiKDqPlimHsVnXwSKM,17807
+jsonpatch_trigger/parents.py,sha256=lTOqTtDqbR7NdyepShRqfTBsJq2SC9Qe95OCFSxhzVE,2012
+jsonpatch_trigger/preconditions.py,sha256=JOMnPr1AnnkkqSXCLFoidwRjf5ulWmsdvWUrKlbpC_o,1478
+jsonpatch_trigger/tracking.py,sha256=HRSfr7pAhfNnUA0kGhHmQMiGGNl2Xa8cy9zaowne5zk,5188
+jsonpatch_trigger-0.1.0.dist-info/METADATA,sha256=IJ7ldq-I0FMNgYtZo6FdaKhqBynQeDWZwSPx2izX3BU,2114
+jsonpatch_trigger-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+jsonpatch_trigger-0.1.0.dist-info/top_level.txt,sha256=gx0expLRzffeexZ_GE_aL-N5KmIQ6csIzqB9PRc1JfY,18
+jsonpatch_trigger-0.1.0.dist-info/RECORD,,

jsonpatch_trigger-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

jsonpatch_trigger-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+jsonpatch_trigger