ab-pydantic-patch 1.2.1__tar.gz → 1.2.2__tar.gz

{ab_pydantic_patch-1.2.1 → ab_pydantic_patch-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ab-pydantic-patch
-Version: 1.2.1
+Version: 1.2.2
 Summary: Python Pydantic support of TypeScript-style utility types, including Partial, Required, Pick, and Omit. Useful for PATCH endpoints driven from BaseModel / SQLModel classes.
 Author-email: Matt Coulter <mattcoul7@gmail.com>
 License-File: LICENSE

{ab_pydantic_patch-1.2.1 → ab_pydantic_patch-1.2.2}/pyproject.toml

@@ -28,7 +28,7 @@ description = "Python Pydantic support of TypeScript-style utility types, includ
 name = "ab-pydantic-patch"
 readme = "README.md"
 requires-python = ">=3.12,<4.0"
-version = "1.2.1"
+version = "1.2.2"
 
 [project.optional-dependencies]
 orm = [

{ab_pydantic_patch-1.2.1 → ab_pydantic_patch-1.2.2}/src/ab_core/pydantic_patch/orm_patch.py

@@ -27,6 +27,16 @@ def _provided_values(model: BaseModel) -> dict[str, object]:
     return {name: getattr(model, name) for name in model.model_fields_set}
 
 
+def _patch_scalar_value(instance: Any, key: str, value: Any) -> None:
+    current_value = getattr(instance, key, None)
+
+    if isinstance(current_value, BaseModel) and isinstance(value, BaseModel):
+        recursive_patch_scalar(current_value, value)
+        return
+
+    setattr(instance, key, value)
+
+
 def _mapper_for(model_cls: type[Any]) -> Any | None:
     if sa_inspect is None:
         return None
@@ -92,15 +102,11 @@ def _recursive_patch_pydantic_scalar(
 
         current_value = getattr(instance, key, None)
 
-        if isinstance(current_value, BaseModel) and isinstance(value, BaseModel):
-            recursive_patch_scalar(current_value, value)
-            continue
-
         if isinstance(current_value, list) and isinstance(value, list):
             setattr(instance, key, value)
             continue
 
-        setattr(instance, key, value)
+        _patch_scalar_value(instance, key, value)
 
 
 def _recursive_patch_orm_scalar(
@@ -123,7 +129,7 @@ def _recursive_patch_orm_scalar(
         if relationship is None:
             if key not in scalar_attributes:
                 continue
-            setattr(orm_instance, key, value)
+            _patch_scalar_value(orm_instance, key, value)
             continue
 
         if value is None:

ab_pydantic_patch-1.2.2/src/ab_core/pydantic_patch/pydantic_jsonb.py

@@ -0,0 +1,98 @@
+"""Support Pydantic Models as a JSON Serialisable Column in Postgres.
+
+As per: https://github.com/fastapi/sqlmodel/issues/63
+
+This is relatively common requirement that sqlmodel has not implemented for us :(
+
+Basically, we don't always want to use relationships and overcomplicate the ORM. Instead,
+we just wwant to serialise the pydantic dependency as JSON withhin that column.
+
+However, if we use JSONB directly, it requires that we define
+
+   supplier_address: dict = Field(
+       default_factory=SupplierAddress,
+       description="Supplier business address extracted from the quote.",
+       sa_column=Column(JSONB, nullable=False),
+   )
+
+Which isn't clean, and no long type-driven.
+
+To preserve the type driven nature for these cases, PydanticJSONB is our friend:
+
+   supplier_address: SupplierAddress = Field(
+       default_factory=SupplierAddress,
+       description="Supplier business address extracted from the quote.",
+       sa_column=Column(PydanticJSONB(SupplierAddress), nullable=False),
+   )
+
+TODO: This does cause some incompaibility with alembic (I think), so we will need
+to address that once alembic is added to this codebase. It looks something like this:
+
+```python
+   from typing import TYPE_CHECKING, Any, Literal
+   from knowledgeburst.fencing.quote_stateful.pydantic_jsonb import PydanticJSONB
+
+   if TYPE_CHECKING:
+       from alembic.autogenerate.api import AutogenContext
+
+   def render_item(
+       type_: str,
+       obj: Any,  # noqa: ANN401
+       autogen_context: AutogenContext,
+   ) -> str | Literal[False]:
+       if type_ == "type" and isinstance(obj, PydanticJSONB):
+           autogen_context.imports.add("import sqlalchemy as sa")
+           autogen_context.imports.add("from sqlalchemy.dialects import postgresql")
+           return "postgresql.JSONB(astext_type=sa.Text())"
+       return False
+```
+
+In that case, we probably want to move this module into a more central db module. Right now
+it is just coupled with fencing as we are keeping the fencing module as independent as possible.
+"""
+
+from typing import Any, cast, override
+
+from pydantic import TypeAdapter
+from sqlalchemy import Dialect, TypeDecorator
+from sqlalchemy.dialects.postgresql import JSONB
+
+
+class PydanticJSONB[T](TypeDecorator):
+    """A SQLAlchemy TypeDecorator that serializes/deserializes Pydantic models to/from JSONB.
+
+    This allows storing Pydantic models in PostgreSQL JSONB columns while maintaining
+    type safety and validation.
+    """
+
+    impl = JSONB
+    cache_ok = True
+
+    def __init__(self, pydantic_type: type[T]) -> None:
+        """Initialize the PydanticJSONB type decorator.
+
+        Args:
+            pydantic_type: The Pydantic model class to serialize/deserialize.
+
+        """
+        super().__init__()
+        self.adapter = TypeAdapter(pydantic_type)
+
+    @override
+    def process_bind_param(self, value: T | None, dialect: Dialect) -> Any:
+        if value is None:
+            return None
+        return self.adapter.dump_python(value, mode="json")
+
+    @override
+    def process_result_value(self, value: Any, dialect: Dialect) -> T | None:
+        if value is None:
+            return None
+        return self.adapter.validate_python(value)
+
+    def coerce_compared_value(self, op: Any, value: Any) -> Any:
+        """Coerce the compared value for SQL operations.
+
+        Delegates to the underlying JSONB implementation for comparison operations.
+        """
+        return cast(JSONB, self.impl).coerce_compared_value(op, value)