pydantic-json-patch 0.1.3__tar.gz → 0.3.0__tar.gz

{pydantic_json_patch-0.1.3 → pydantic_json_patch-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic_json_patch
-Version: 0.1.3
+Version: 0.3.0
 Summary: Pydantic models for implementing JSON Patch.
 Author: Jonathan Sharpe
 Author-email: Jonathan Sharpe <mail@jonrshar.pe>
@@ -90,7 +90,7 @@ CopyOp(op='copy', path='/foo/bar~1new', from_='/foo/bar~0old')
 ('foo', 'bar~old')
 ```
 
-Similarly, the `create` factory methods can accept tuples of tokens, and will encode them appropriately:
+Similarly, the `create` factory methods can accept sequences of tokens, and will encode them appropriately:
 
 ```python
 >>> from pydantic_json_patch import TestOp
@@ -139,17 +139,48 @@ uv sync
 uv run pre-commit install
 ```
 
+The pre-commit hooks will ensure that the code style checks (using [isort] and [ruff]) are applied.
+
+### Testing
+
+The test suite uses [pytest] and can be run with:
+
+```shell
+uv run pytest
+```
+
+Additionally, there is [ty] type-checking that can be run with:
+
+```shell
+uv run ty check
+```
+
+### FastAPI
+
+You can preview the FastAPI/Swagger documentation by running:
+
+```shell
+uv run fastapi dev tests/app.py
+```
+
+and visiting the Documentation link that's logged in the console.
+This will auto-restart as you make changes.
+
   [ci-badge]: https://github.com/textbook/pydantic_json_patch/actions/workflows/push.yml/badge.svg
   [ci-page]: https://github.com/textbook/pydantic_json_patch/actions/workflows/push.yml
   [coverage-badge]: https://coveralls.io/repos/github/textbook/pydantic_json_patch/badge.svg?branch=main
   [coverage-page]: https://coveralls.io/github/textbook/pydantic_json_patch?branch=main
   [fastapi]: https://fastapi.tiangolo.com/
+  [isort]: https://pycqa.github.io/isort/
   [json patch]: https://datatracker.ietf.org/doc/html/rfc6902/
   [json pointer]: https://datatracker.ietf.org/doc/html/rfc6901/
   [pydantic]: https://docs.pydantic.dev/latest/
   [pypi]: https://pypi.org/
   [pypi-badge]: https://img.shields.io/pypi/v/pydantic-json-patch?logo=python&logoColor=white&label=PyPI
   [pypi-page]: https://pypi.org/project/pydantic-json-patch/
+  [pytest]: https://docs.pytest.org/en/stable/
+  [ruff]: https://docs.astral.sh/ruff/
   [swagger-example]: https://github.com/textbook/pydantic_json_patch/blob/main/docs/swagger-example.png?raw=true
   [swagger-schemas]: https://github.com/textbook/pydantic_json_patch/blob/main/docs/swagger-schemas.png?raw=true
+  [ty]: https://docs.astral.sh/ty/
   [uv]: https://docs.astral.sh/uv/

{pydantic_json_patch-0.1.3 → pydantic_json_patch-0.3.0}/README.md

@@ -58,7 +58,7 @@ CopyOp(op='copy', path='/foo/bar~1new', from_='/foo/bar~0old')
 ('foo', 'bar~old')
 ```
 
-Similarly, the `create` factory methods can accept tuples of tokens, and will encode them appropriately:
+Similarly, the `create` factory methods can accept sequences of tokens, and will encode them appropriately:
 
 ```python
 >>> from pydantic_json_patch import TestOp
@@ -107,17 +107,48 @@ uv sync
 uv run pre-commit install
 ```
 
+The pre-commit hooks will ensure that the code style checks (using [isort] and [ruff]) are applied.
+
+### Testing
+
+The test suite uses [pytest] and can be run with:
+
+```shell
+uv run pytest
+```
+
+Additionally, there is [ty] type-checking that can be run with:
+
+```shell
+uv run ty check
+```
+
+### FastAPI
+
+You can preview the FastAPI/Swagger documentation by running:
+
+```shell
+uv run fastapi dev tests/app.py
+```
+
+and visiting the Documentation link that's logged in the console.
+This will auto-restart as you make changes.
+
   [ci-badge]: https://github.com/textbook/pydantic_json_patch/actions/workflows/push.yml/badge.svg
   [ci-page]: https://github.com/textbook/pydantic_json_patch/actions/workflows/push.yml
   [coverage-badge]: https://coveralls.io/repos/github/textbook/pydantic_json_patch/badge.svg?branch=main
   [coverage-page]: https://coveralls.io/github/textbook/pydantic_json_patch?branch=main
   [fastapi]: https://fastapi.tiangolo.com/
+  [isort]: https://pycqa.github.io/isort/
   [json patch]: https://datatracker.ietf.org/doc/html/rfc6902/
   [json pointer]: https://datatracker.ietf.org/doc/html/rfc6901/
   [pydantic]: https://docs.pydantic.dev/latest/
   [pypi]: https://pypi.org/
   [pypi-badge]: https://img.shields.io/pypi/v/pydantic-json-patch?logo=python&logoColor=white&label=PyPI
   [pypi-page]: https://pypi.org/project/pydantic-json-patch/
+  [pytest]: https://docs.pytest.org/en/stable/
+  [ruff]: https://docs.astral.sh/ruff/
   [swagger-example]: https://github.com/textbook/pydantic_json_patch/blob/main/docs/swagger-example.png?raw=true
   [swagger-schemas]: https://github.com/textbook/pydantic_json_patch/blob/main/docs/swagger-schemas.png?raw=true
+  [ty]: https://docs.astral.sh/ty/
   [uv]: https://docs.astral.sh/uv/

{pydantic_json_patch-0.1.3 → pydantic_json_patch-0.3.0}/pyproject.toml

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

{pydantic_json_patch-0.1.3 → pydantic_json_patch-0.3.0}/src/pydantic_json_patch/__init__.py

@@ -3,7 +3,7 @@ from importlib.metadata import version
 
 from pydantic import Discriminator
 
-from .models import AddOp, CopyOp, MoveOp, Op, RemoveOp, ReplaceOp, TestOp, Tokens
+from .models import AddOp, CopyOp, MoveOp, RemoveOp, ReplaceOp, TestOp
 
 __version__ = version(__name__)
 
@@ -18,10 +18,8 @@ __all__ = [
     "CopyOp",
     "JsonPatch",
     "MoveOp",
-    "Op",
     "Operation",
     "RemoveOp",
     "ReplaceOp",
     "TestOp",
-    "Tokens",
 ]

{pydantic_json_patch-0.1.3 → pydantic_json_patch-0.3.0}/src/pydantic_json_patch/models.py

@@ -1,15 +1,13 @@
 import re
 import typing as tp
-from functools import cached_property
+from collections.abc import Sequence
+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 = tp.TypeVar("T")
-Op: tp.TypeAlias = tp.Literal["add", "copy", "move", "remove", "replace", "test"]
-Tokens: tp.TypeAlias = tuple[str, ...]
 
 # region base models
 
@@ -21,39 +19,48 @@ class _BaseOp(BaseModel):
     )
 
     @classmethod
-    def create(cls, *, path: str | Tokens, **kwargs) -> tx.Self:
+    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: Op
+    op: tp.Literal["add", "copy", "move", "remove", "replace", "test"]
     """The operation being represented."""
 
     path: str = Field(examples=["/a/b/c"], pattern=_JSON_POINTER)
     """A JSON pointer representing the path to apply the operation to."""
 
     @cached_property
-    def path_tokens(self) -> Tokens:
+    def path_tokens(self) -> tuple[str, ...]:
         """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: Tokens) -> 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) -> Tokens:
-        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 | Tokens, from_: str | Tokens) -> tx.Self:  # type: ignore[invalid-method-override]
+    def create(
+        cls, *, path: str | Sequence[str], from_: str | Sequence[str]
+    ) -> tx.Self:  # type: ignore[invalid-method-override]
         pointer = from_ if isinstance(from_, str) else cls._dump_pointer(from_)
         return super().create(path=path, **{"from": pointer})
 
@@ -73,17 +80,17 @@ class _FromOp(_BaseOp):
         return data
 
     @cached_property
-    def from_tokens(self) -> Tokens:
+    def from_tokens(self) -> tuple[str, ...]:
         """The decoded tokens in the 'from' JSON pointer."""
         return self._load_pointer(self.from_)
 
 
-class _ValueOp(_BaseOp, tp.Generic[T]):
+class _ValueOp(_BaseOp):
     @classmethod
-    def create(cls, *, path: str | Tokens, value: T) -> tx.Self:  # type: ignore[invalid-method-override]
+    def create(cls, *, path: str | Sequence[str], value: tp.Any) -> tx.Self:  # type: ignore[invalid-method-override]
         return super().create(path=path, value=value)
 
-    value: T = Field(examples=[42])
+    value: tp.Any = Field(examples=[42])
     """The value to use in the operation."""
 
 
@@ -92,7 +99,7 @@ class _ValueOp(_BaseOp, tp.Generic[T]):
 # region public models
 
 
-class AddOp(_ValueOp, tp.Generic[T]):
+class AddOp(_ValueOp):
     op: tp.Literal["add"]
 
 
@@ -106,17 +113,17 @@ class MoveOp(_FromOp):
 
 class RemoveOp(_BaseOp):
     @classmethod
-    def create(cls, *, path: str | Tokens) -> tx.Self:  # type: ignore[invalid-method-override]
+    def create(cls, *, path: str | Sequence[str]) -> tx.Self:  # type: ignore[invalid-method-override]
         return super().create(path=path)
 
     op: tp.Literal["remove"]
 
 
-class ReplaceOp(_ValueOp, tp.Generic[T]):
+class ReplaceOp(_ValueOp):
     op: tp.Literal["replace"]
 
 
-class TestOp(_ValueOp, tp.Generic[T]):
+class TestOp(_ValueOp):
     op: tp.Literal["test"]