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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic_json_patch
-Version: 0.1.2
+Version: 0.2.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
@@ -129,16 +129,58 @@ and list the models along with the other schemas:
 
 [![Screenshot of Swagger UI schema list][swagger-schemas]][swagger-schemas]
 
+## Development
+
+This project uses [uv] for managing dependencies.
+Having installed uv, you can set the project up for local development with:
+
+```shell
+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.2 → pydantic_json_patch-0.2.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
@@ -97,16 +97,58 @@ and list the models along with the other schemas:
 
 [![Screenshot of Swagger UI schema list][swagger-schemas]][swagger-schemas]
 
+## Development
+
+This project uses [uv] for managing dependencies.
+Having installed uv, you can set the project up for local development with:
+
+```shell
+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.2 → pydantic_json_patch-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pydantic_json_patch"
-version = "0.1.2"
+version = "0.2.0"
 description = "Pydantic models for implementing JSON Patch."
 readme = "README.md"
 authors = [
@@ -47,6 +47,8 @@ dev = [
     "fastapi>=0.128.2",
     "fastapi-cli>=0.0.20",
     "httpx>=0.28.1",
+    "isort>=7.0.0",
+    "pre-commit>=4.5.1",
     "pytest>=9.0.2",
     "ruff>=0.15.0",
     "ty>=0.0.15",
@@ -58,5 +60,8 @@ omit = ["tests/**"]
 [tool.coverage.lcov]
 output = "coverage/lcov.info"
 
+[tool.isort]
+profile = "black"
+
 [tool.pytest.ini_options]
 python_classes = []  # avoid trying to run TestOp as a test

{pydantic_json_patch-0.1.2 → pydantic_json_patch-0.2.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.2 → pydantic_json_patch-0.2.0}/src/pydantic_json_patch/models.py

@@ -1,15 +1,13 @@
 import re
 import typing as tp
+from collections.abc import Sequence
 from functools import cached_property
 
-from pydantic import BaseModel, ConfigDict, Field, ValidationInfo, model_validator
 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,30 +19,30 @@ 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)
 
-    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)
 
     @staticmethod
-    def _dump_pointer(pointer: Tokens) -> str:
+    def _dump_pointer(pointer: Sequence[str]) -> str:
         return "/".join(
             ["", *(token.replace("~", "~0").replace("/", "~1") for token in pointer)]
         )
 
     @staticmethod
-    def _load_pointer(pointer: str) -> Tokens:
+    def _load_pointer(pointer: str) -> tuple[str, ...]:
         return tuple(
             token.replace("~1", "/").replace("~0", "~")
             for token in pointer.split("/")[1:]
@@ -53,7 +51,9 @@ class _BaseOp(BaseModel):
 
 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 +73,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 +92,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 +106,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"]