pydantic-json-patch 0.2.0__tar.gz → 0.4.0__tar.gz

{pydantic_json_patch-0.2.0 → pydantic_json_patch-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic_json_patch
-Version: 0.2.0
+Version: 0.4.0
 Summary: Pydantic models for implementing JSON Patch.
 Author: Jonathan Sharpe
 Author-email: Jonathan Sharpe <mail@jonrshar.pe>
@@ -68,6 +68,15 @@ AddOp(op='add', path='/foo/bar', value=123)
 '{"op":"add","path":"/foo/bar","value":123}'
 ```
 
+The operations that take a value (`AddOp`, `ReplaceOp`, and `TestOp`) are generic, so you can parameterize them with a specific value type:
+
+```python
+>>> from pydantic_json_patch import ReplaceOp
+>>> op = ReplaceOp[str].create(path="/foo/bar", value="hello")
+>>> op
+ReplaceOp[str](op='replace', path='/foo/bar', value='hello')
+```
+
 Additionally, there are two compound models:
 
 - `Operation` is the union of all the operators; and

{pydantic_json_patch-0.2.0 → pydantic_json_patch-0.4.0}/README.md

@@ -36,6 +36,15 @@ AddOp(op='add', path='/foo/bar', value=123)
 '{"op":"add","path":"/foo/bar","value":123}'
 ```
 
+The operations that take a value (`AddOp`, `ReplaceOp`, and `TestOp`) are generic, so you can parameterize them with a specific value type:
+
+```python
+>>> from pydantic_json_patch import ReplaceOp
+>>> op = ReplaceOp[str].create(path="/foo/bar", value="hello")
+>>> op
+ReplaceOp[str](op='replace', path='/foo/bar', value='hello')
+```
+
 Additionally, there are two compound models:
 
 - `Operation` is the union of all the operators; and

{pydantic_json_patch-0.2.0 → pydantic_json_patch-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pydantic_json_patch"
-version = "0.2.0"
+version = "0.4.0"
 description = "Pydantic models for implementing JSON Patch."
 readme = "README.md"
 authors = [

{pydantic_json_patch-0.2.0 → pydantic_json_patch-0.4.0}/src/pydantic_json_patch/models.py

@@ -1,13 +1,14 @@
 import re
 import typing as tp
 from collections.abc import Sequence
-from functools import cached_property
+from functools import cached_property, lru_cache
 
 import typing_extensions as tx
 from pydantic import BaseModel, ConfigDict, Field, ValidationInfo, model_validator
 
 _JSON_POINTER = re.compile(r"^(?:/(?:[^/~]|~[01])+)*$")
 
+T = tx.TypeVar("T", default=tp.Any)
 
 # region base models
 
@@ -21,8 +22,7 @@ class _BaseOp(BaseModel):
     @classmethod
     def create(cls, *, path: str | Sequence[str], **kwargs) -> tx.Self:
         (op,) = tp.get_args(cls.model_fields["op"].annotation)
-        pointer = path if isinstance(path, str) else cls._dump_pointer(path)
-        return cls(op=op, path=pointer, **kwargs)
+        return cls(op=op, path=cls._dump_pointer(path), **kwargs)
 
     op: tp.Literal["add", "copy", "move", "remove", "replace", "test"]
     """The operation being represented."""
@@ -35,25 +35,33 @@ class _BaseOp(BaseModel):
         """The decoded tokens in the 'path' JSON pointer."""
         return self._load_pointer(self.path)
 
+    @classmethod
+    def _dump_pointer(cls, pointer: Sequence[str]) -> str:
+        if isinstance(pointer, str):
+            return pointer
+        return "/".join(["", *(cls._encode_token(token) for token in pointer)])
+
     @staticmethod
-    def _dump_pointer(pointer: Sequence[str]) -> str:
-        return "/".join(
-            ["", *(token.replace("~", "~0").replace("/", "~1") for token in pointer)]
-        )
+    @lru_cache
+    def _decode_token(token: str) -> str:
+        return token.replace("~1", "/").replace("~0", "~")
 
     @staticmethod
-    def _load_pointer(pointer: str) -> tuple[str, ...]:
-        return tuple(
-            token.replace("~1", "/").replace("~0", "~")
-            for token in pointer.split("/")[1:]
-        )
+    @lru_cache
+    def _encode_token(token: str) -> str:
+        return token.replace("~", "~0").replace("/", "~1")
+
+    @classmethod
+    @lru_cache
+    def _load_pointer(cls, pointer: str) -> tuple[str, ...]:
+        return tuple(cls._decode_token(token) for token in pointer.split("/")[1:])
 
 
 class _FromOp(_BaseOp):
     @classmethod
     def create(
         cls, *, path: str | Sequence[str], from_: str | Sequence[str]
-    ) -> tx.Self:  # type: ignore[invalid-method-override]
+    ) -> tx.Self:  # ty: ignore[invalid-method-override] -- deliberately narrows **kwargs to named params
         pointer = from_ if isinstance(from_, str) else cls._dump_pointer(from_)
         return super().create(path=path, **{"from": pointer})
 
@@ -78,12 +86,12 @@ class _FromOp(_BaseOp):
         return self._load_pointer(self.from_)
 
 
-class _ValueOp(_BaseOp):
+class _ValueOp(_BaseOp, tp.Generic[T]):
     @classmethod
-    def create(cls, *, path: str | Sequence[str], value: tp.Any) -> tx.Self:  # type: ignore[invalid-method-override]
+    def create(cls, *, path: str | Sequence[str], value: T) -> tx.Self:  # ty: ignore[invalid-method-override] -- deliberately narrows **kwargs to named params
         return super().create(path=path, value=value)
 
-    value: tp.Any = Field(examples=[42])
+    value: T = Field(examples=[42])
     """The value to use in the operation."""
 
 
@@ -92,7 +100,7 @@ class _ValueOp(_BaseOp):
 # region public models
 
 
-class AddOp(_ValueOp):
+class AddOp(_ValueOp[T], tp.Generic[T]):
     op: tp.Literal["add"]
 
 
@@ -106,17 +114,17 @@ class MoveOp(_FromOp):
 
 class RemoveOp(_BaseOp):
     @classmethod
-    def create(cls, *, path: str | Sequence[str]) -> tx.Self:  # type: ignore[invalid-method-override]
+    def create(cls, *, path: str | Sequence[str]) -> tx.Self:  # ty: ignore[invalid-method-override] -- deliberately narrows **kwargs to named params
         return super().create(path=path)
 
     op: tp.Literal["remove"]
 
 
-class ReplaceOp(_ValueOp):
+class ReplaceOp(_ValueOp[T], tp.Generic[T]):
     op: tp.Literal["replace"]
 
 
-class TestOp(_ValueOp):
+class TestOp(_ValueOp[T], tp.Generic[T]):
     op: tp.Literal["test"]