Adding support for Pydantic V2

Author: ishmeet1995

.github/workflows/pull_request.yml

@@ -8,10 +8,11 @@ jobs:
     strategy:
       matrix:
         python_version: [
-          "3.7",
           "3.8",
           "3.9",
           "3.10",
+          "3.11",
+          "3.12",
         ]
     runs-on: ubuntu-latest
     env:

CHANGELOG.md

@@ -0,0 +1,25 @@
+
+# Change Log
+All notable changes to this project will be documented in this file.
+ 
+The format is based on [Keep a Changelog](http://keepachangelog.com/)
+and this project adheres to [Semantic Versioning](http://semver.org/).
+ 
+## [1.0.0] - 2024-01-15
+ 
+Added support for Pydantic V2 (version - ^2.5).
+ 
+### Added
+
+- Test coverage for Python versions `3.11` and `3.12`
+
+### Changed
+- Python base version from `3.7` to `3.8`.
+- Changed Pydantic version from `^1.8.2` to `^2.5`.
+- Updated Model validation function from `parse_obj` to `model_validate`.
+- Renamed backend initialization class from `Config` to `db_config` to follow pydantic's naming convention.
+- Updated method for generation of dictionary from `dict` to `model_dump`.
+
+## [0.4.2] - 2023-11-16
+ 
+Added count() for dynamo backend that returns integer count as total.

poetry.lock

@@ -102,7 +102,7 @@ def _to_epoch_decimal(dt: datetime) -> Decimal:
 
 def chunk_list(lst, size):
     for i in range(0, len(lst), size):
-        yield lst[i : i + size]
+        yield lst[i: i + size]
 
 
 def index_definition(index_name, keys, gsi=False):
@@ -123,7 +123,7 @@ def index_definition(index_name, keys, gsi=False):
 class DynamoSerializer:
     def __init__(self, schema, ttl_field=None):
         self.properties = schema.get("properties")
-        self.definitions = schema.get("definitions")
+        self.definitions = schema.get("$defs")
         self.ttl_field = ttl_field
 
     def _get_type_possibilities(self, field_name) -> Set[tuple]:
@@ -143,7 +143,6 @@ def type_from_definition(definition_signature: Union[str, dict]) -> dict:
                 t = definition_signature.split("/")[-1]
                 return self.definitions[t]
             return definition_signature
-
         type_dicts = [type_from_definition(t) for t in possible_types]
 
         return set([(t["type"], t.get("format", "")) for t in type_dicts])
@@ -213,7 +212,7 @@ def __init__(self, cls, result, serialized_items):
 
 class Backend:
     def __init__(self, cls):
-        cfg = cls.Config
+        cfg = cls.db_config
         self.cls = cls
         self.schema = cls.schema()
         self.hash_key = cfg.hash_key

pydanticrud/backends/dynamodb.py

@@ -45,7 +45,7 @@ def get_column_data(field_type):
 
 class Backend:
     def __init__(self, cls):
-        cfg = cls.Config
+        cfg = cls.db_config
         self.hash_key = cfg.hash_key
         self.table_name = cls.get_table_name()
 
@@ -162,7 +162,7 @@ def get(self, item_key):
 
     def save(self, item, condition: Optional[Rule] = None) -> bool:
         table_name = item.get_table_name()
-        hash_key = item.Config.hash_key
+        hash_key = item.db_config.hash_key
         key = getattr(item, hash_key)
         fields = tuple(self._columns.keys())
 

pydanticrud/backends/sqlite.py

@@ -1,15 +1,12 @@
-import pydantic.error_wrappers
 from pydantic import BaseModel as PydanticBaseModel
-from pydantic.main import ModelMetaclass
-from rule_engine import Rule
+from pydantic._internal._model_construction import ModelMetaclass
 
 
 class CrudMetaClass(ModelMetaclass):
     def __new__(mcs, name, bases, namespace, **kwargs):
         cls = super().__new__(mcs, name, bases, namespace, **kwargs)
-        if hasattr(cls.__config__, "backend"):
-            cls.__backend__ = cls.__config__.backend(cls)
-
+        if hasattr(cls, "db_config") and hasattr(cls.db_config, "backend"):
+            cls.__backend__ = cls.db_config.backend(cls)
         return cls
 
 
@@ -46,7 +43,7 @@ def initialize(cls):
 
     @classmethod
     def get_table_name(cls) -> str:
-        return cls.Config.title.lower()
+        return cls.db_config.title.lower()
 
     @classmethod
     def exists(cls) -> bool:
@@ -65,11 +62,11 @@ def count(cls, *args, **kwargs):
 
     @classmethod
     def get(cls, *args, **kwargs):
-        return cls.parse_obj(cls.__backend__.get(*args, **kwargs))
+        return cls.model_validate(cls.__backend__.get(*args, **kwargs))
 
     def save(self) -> bool:
         # Parse the new obj to trigger validation
-        self.__class__.parse_obj(self.dict(by_alias=True))
+        self.__class__.model_validate(self.model_dump(by_alias=True))
 
         # Maybe we should pass a conditional to the backend but for now the only place that uses it doesn't need it.
         return self.__class__.__backend__.save(self)

pydanticrud/main.py

@@ -1,15 +1,15 @@
 [tool.poetry]
 name = "pydanticrud"
-version = "0.4.2"
+version = "1.0.0"
 description = "Supercharge your Pydantic models with CRUD methods and a pluggable backend"
 authors = ["Timothy Farrell <[email protected]>"]
 license = "MIT"
 
 [tool.poetry.dependencies]
-python = ">=3.6"
+python = ">=3.8"
 boto3 = "^1.17.112"
 rule-engine = "^3.2.0"
-pydantic = "^1.8.2"
+pydantic = "^2.5"
 dataclasses = {version = "^0.8", python = "3.6"}
 
 [tool.poetry.dev-dependencies]

pyproject.toml

@@ -6,7 +6,7 @@
 
 import docker
 from botocore.exceptions import ClientError
-from pydantic import BaseModel as PydanticBaseModel, Field, root_validator, ValidationError
+from pydantic import model_validator, BaseModel as PydanticBaseModel, Field, ValidationError
 from pydanticrud import BaseModel, DynamoDbBackend, ConditionCheckFailed
 import pytest
 from pydanticrud.exceptions import DoesNotExist
@@ -30,11 +30,11 @@ class SimpleKeyModel(BaseModel):
     expires: datetime
     sigfig: Decimal
     enabled: bool
-    data: Dict[int, int] = None
+    data: Dict[int, int] = {}
     items: List[int]
     hash: UUID
 
-    class Config:
+    class db_config:
         title = "ModelTitle123"
         hash_key = "name"
         ttl = "expires"
@@ -49,13 +49,14 @@ class AliasKeyModel(BaseModel):
     name: str
     type_: str = Field(alias="type")
 
-    @root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def type_from_typ(cls, values):
         if 'typ' in values:
             values['type'] = values.pop('typ')
         return values
 
-    class Config:
+    class db_config:
         title = "AliasTitle123"
         hash_key = "name"
         backend = DynamoDbBackend
@@ -71,7 +72,7 @@ class ComplexKeyModel(BaseModel):
     thread_id: str
     body: str = "some random string"
 
-    class Config:
+    class db_config:
         title = "ComplexModelTitle123"
         hash_key = "account"
         range_key = "sort_date_key"
@@ -101,14 +102,13 @@ class NestedModel(BaseModel):
     ticket: Optional[Ticket]
     other: Union[Ticket, SomethingElse]
 
-    class Config:
+    class db_config:
         title = "NestedModelTitle123"
         hash_key = "account"
         range_key = "sort_date_key"
         backend = DynamoDbBackend
         endpoint = "http://localhost:18002"
 
-
 def alias_model_data_generator(**kwargs):
     data = dict(
         id=random.randint(0, 100000),
@@ -231,7 +231,7 @@ def simple_query_data(simple_table):
     data = [datum for datum in [simple_model_data_generator(**i) for i in presets]]
     del data[0]["data"]  # We need to have no data to ensure that default values work
     for datum in data:
-        SimpleKeyModel.parse_obj(datum).save()
+        SimpleKeyModel.model_validate(datum).save()
     try:
         yield data
     finally:
@@ -250,20 +250,20 @@ def complex_query_data(complex_table):
         for i, p in enumerate(presets)
     ]
     for datum in data:
-        ComplexKeyModel.parse_obj(datum).save()
+        ComplexKeyModel.model_validate(datum).save()
     try:
         yield data
     finally:
         for datum in data:
-            ComplexKeyModel.delete((datum[ComplexKeyModel.Config.hash_key], datum[ComplexKeyModel.Config.range_key]))
+            ComplexKeyModel.delete((datum[ComplexKeyModel.db_config.hash_key], datum[getattr(ComplexKeyModel.db_config, "range_key")]))
 
 
 @pytest.fixture(scope="module")
 def alias_query_data(alias_table):
     presets = [dict(name="Jerry"), dict(name="Hermione"), dict(), dict(), dict()]
     data = [datum for datum in [alias_model_data_generator(**i) for i in presets]]
     for datum in data:
-        AliasKeyModel.parse_obj(datum).save()
+        AliasKeyModel.model_validate(datum).save()
     try:
         yield data
     finally:
@@ -276,35 +276,35 @@ def nested_query_data(nested_table):
     presets = [dict()] * 5
     data = [datum for datum in [nested_model_data_generator(**i) for i in presets]]
     for datum in data:
-        nested_datum = NestedModel.parse_obj(datum)
+        nested_datum = NestedModel.model_validate(datum)
         nested_datum.save()
     try:
         yield data
     finally:
         for datum in data:
-            NestedModel.delete((datum[NestedModel.Config.hash_key], datum[NestedModel.Config.range_key]))
+            NestedModel.delete((datum[NestedModel.db_config.hash_key], datum[NestedModel.db_config.range_key]))
 
 
 @pytest.fixture
 def nested_query_data_empty_ticket(nested_table):
     presets = [dict()] * 5
     data = [datum for datum in [nested_model_data_generator(include_ticket=False, **i) for i in presets]]
     for datum in data:
-        NestedModel.parse_obj(datum).save()
+        NestedModel.model_validate(datum).save()
     try:
         yield data
     finally:
         for datum in data:
-            NestedModel.delete((datum[NestedModel.Config.hash_key], datum[NestedModel.Config.range_key]))
+            NestedModel.delete((datum[NestedModel.db_config.hash_key], datum[NestedModel.db_config.range_key]))
 
 
 def test_save_get_delete_simple(dynamo, simple_table):
     data = simple_model_data_generator()
-    a = SimpleKeyModel.parse_obj(data)
+    a = SimpleKeyModel.model_validate(data)
     a.save()
     try:
         b = SimpleKeyModel.get(data["name"])
-        assert b.dict() == a.dict()
+        assert b.dict() == a.model_dump()
     finally:
         SimpleKeyModel.delete(data["name"])
 
@@ -330,7 +330,7 @@ def test_save_ttl_field_is_float(dynamo, simple_query_data):
 def test_query_with_hash_key_simple(dynamo, simple_query_data):
     res = SimpleKeyModel.query(Rule(f"name == '{simple_query_data[0]['name']}'"))
     res_data = {m.name: m.dict() for m in res}
-    simple_query_data[0]["data"] = None  # This is a default value and should be populated as such
+    simple_query_data[0]["data"] = {}  # This is a default value and should be populated as such
     assert res_data == {simple_query_data[0]["name"]: simple_query_data[0]}
 
 
@@ -383,11 +383,11 @@ def test_query_scan_contains_simple(dynamo, simple_query_data):
 
 def test_save_get_delete_complex(dynamo, complex_table):
     data = complex_model_data_generator()
-    a = ComplexKeyModel.parse_obj(data)
+    a = ComplexKeyModel.model_validate(data)
     a.save()
     try:
         b = ComplexKeyModel.get((data["account"], data["sort_date_key"]))
-        assert b.dict() == a.dict()
+        assert b.dict() == a.model_dump()
     finally:
         ComplexKeyModel.delete((data["account"], data["sort_date_key"]))
 
@@ -528,7 +528,7 @@ def test_query_alias_save(dynamo):
     AliasKeyModel.initialize()
     try:
         for datum in data:
-            AliasKeyModel.parse_obj(datum).save()
+            AliasKeyModel.model_validate(datum).save()
     except Exception as e:
         raise pytest.fail("Failed to save Alias model!")
 
@@ -567,7 +567,7 @@ def test_alias_model_validator_ingest(dynamo):
 
 def test_batch_write(dynamo, complex_table):
     response = {"UnprocessedItems": {}}
-    data = [ComplexKeyModel.parse_obj(complex_model_data_generator()) for x in range(0, 10)]
+    data = [ComplexKeyModel.model_validate(complex_model_data_generator()) for x in range(0, 10)]
     un_proc = ComplexKeyModel.batch_save(data)
     assert un_proc == response["UnprocessedItems"]
     res_get = ComplexKeyModel.get((data[0].account, data[0].sort_date_key))
@@ -581,7 +581,7 @@ def test_batch_write(dynamo, complex_table):
 
 def test_message_batch_write_client_exception(dynamo, complex_table):
     data = [
-        ComplexKeyModel.parse_obj(complex_model_data_generator(body="some big string" * 10000))
+        ComplexKeyModel.model_validate(complex_model_data_generator(body="some big string" * 10000))
         for x in range(0, 2)
     ]
     with pytest.raises(ClientError) as exc:

tests/test_dynamodb.py

@@ -21,7 +21,7 @@ class Model(BaseModel):
     name: str
     total: float
 
-    class Config:
+    class db_config:
         title = "ModelTitle123"
         backend = FalseBackend
 
@@ -57,4 +57,4 @@ def test_model_backend_query():
 
 
 def test_model_table_name_from_title():
-    assert Model.get_table_name() == Model.Config.title.lower()
+    assert Model.get_table_name() == Model.db_config.title.lower()

tests/test_model.py

@@ -19,7 +19,7 @@ class Model(BaseModel):
     data: Dict[str, str]
     items: List[int]
 
-    class Config:
+    class db_config:
         title = "ModelTitle123"
         hash_key = "id"
         backend = SqliteBackend
@@ -69,8 +69,8 @@ def test_initialize_creates_table():
 
 def test_save_and_get(model_in_db):
     data = model_data_generator()
-    a = Model.parse_obj(data)
-    assert a.dict() == data
+    a = Model.model_validate(data)
+    assert a.model_dump() == data
     a.save()
     b = Model.get(data["id"])
     assert b.dict() == data
@@ -108,13 +108,13 @@ def test_query(model_in_db):
     data2["id"] = 2
     data3 = model_data_generator()
     data3["id"] = 1234
-    Model.parse_obj(data1).save()
-    Model.parse_obj(data2).save()
-    Model.parse_obj(data3).save()
+    Model.model_validate(data1).save()
+    Model.model_validate(data2).save()
+    Model.model_validate(data3).save()
     for r in range(0, 10):
         _data = model_data_generator()
         _data["id"] += 3
-        Model.parse_obj(_data).save()
+        Model.model_validate(_data).save()
     res = Model.query(Rule(f"id < 3"))
     data = {m.id: m.dict() for m in res}
     assert data == {1: data1, 2: data2}