Convert ModelData from TypedDict pydantic

- Uses BaseModel instead
- Adds runtime type validation at the Model level
- Breaking change, requires building Models with the class Constructor
instead of simply passing dictionaries around

Author: andrew-chang-dewitt

db_wrapper/model.py

@@ -13,18 +13,21 @@
 )
 from uuid import UUID
 
+# third party dependencies
+from pydantic import BaseModel
+
 # internal dependency
 from .client import Client, sql
 
 
-class ModelData(TypedDict):
+class ModelData(BaseModel):
     """Base interface for ModelData to be used in Model."""
 
     # PENDS python 3.9 support in pylint
     # pylint: disable=inherit-non-class
     # pylint: disable=too-few-public-methods
 
-    _id: UUID
+    id: UUID
 
 
 # Generic doesn't need a more descriptive name
@@ -65,7 +68,7 @@ async def one(self, item: T) -> T:
         columns: List[sql.Identifier] = []
         values: List[sql.Literal] = []
 
-        for column, value in item.items():
+        for column, value in item.dict().items():
             values.append(sql.Literal(value))
 
             columns.append(sql.Identifier(column))
@@ -100,7 +103,7 @@ async def one_by_id(self, id_value: str) -> T:
         query = sql.SQL(
             'SELECT * '
             'FROM {table} '
-            'WHERE _id = {id_value};'
+            'WHERE id = {id_value};'
         ).format(
             table=self._table,
             id_value=sql.Literal(id_value)
@@ -152,7 +155,7 @@ def compose_changes(changes: Dict[str, Any]) -> sql.Composed:
         query = sql.SQL(
             'UPDATE {table} '
             'SET {changes} '
-            'WHERE _id = {id_value} '
+            'WHERE id = {id_value} '
             'RETURNING *;'
         ).format(
             table=self._table,

requirements/prod.txt

@@ -1 +1,2 @@
 aiopg>=1.1.0,<2.0.0
+pydantic>=1.8.1,<2.0.0

tests/test_model.py

@@ -13,9 +13,8 @@
     TypeVar,
     List,
     Tuple,
-    TypedDict,
 )
-from uuid import uuid4, UUID
+from uuid import uuid4
 import unittest
 from unittest import TestCase
 
@@ -64,34 +63,34 @@ class TestReadOneById(TestCase):
 
     @helpers.async_test
     async def test_it_correctly_builds_query_with_given_id(self) -> None:
-        item: ModelData = {'_id': uuid4()}
+        item = ModelData(id=uuid4())
         model, client = setup([item])
-        await model.read.one_by_id(str(item['_id']))
+        await model.read.one_by_id(str(item.id))
         query_composed = cast(
             helpers.AsyncMock, client.execute_and_return).call_args[0][0]
         query = helpers.composed_to_string(query_composed)
 
         self.assertEqual(query, "SELECT * "
                                 "FROM test "
-                                f"WHERE _id = {item['_id']};")
+                                f"WHERE id = {item.id};")
 
     @helpers.async_test
     async def test_it_returns_a_single_result(self) -> None:
-        item: ModelData = {'_id': uuid4()}
+        item = ModelData(id=uuid4())
         model, _ = setup([item])
-        result = await model.read.one_by_id(str(item['_id']))
+        result = await model.read.one_by_id(str(item.id))
 
         self.assertEqual(result, item)
 
-    @helpers.async_test
+    @ helpers.async_test
     async def test_it_raises_exception_if_more_than_one_result(self) -> None:
-        item: ModelData = {'_id': uuid4()}
+        item = ModelData(id=uuid4())
         model, _ = setup([item, item])
 
         with self.assertRaises(UnexpectedMultipleResults):
-            await model.read.one_by_id(str(item['_id']))
+            await model.read.one_by_id(str(item.id))
 
-    @helpers.async_test
+    @ helpers.async_test
     async def test_it_raises_exception_if_no_result_to_return(self) -> None:
         model: Model[ModelData]
         model, _ = setup([])
@@ -108,31 +107,31 @@ class Item(ModelData):
         a: str
         b: str
 
-    @helpers.async_test
+    @ helpers.async_test
     async def test_it_correctly_builds_query_with_given_data(self) -> None:
-        item: TestCreateOne.Item = {
-            '_id': uuid4(),
+        item = TestCreateOne.Item(**{
+            'id': uuid4(),
             'a': 'a',
             'b': 'b',
-        }
+        })
         model, client = setup([item])
 
         await model.create.one(item)
         query_composed = cast(
             helpers.AsyncMock, client.execute_and_return).call_args[0][0]
         query = helpers.composed_to_string(query_composed)
 
-        self.assertEqual(query, 'INSERT INTO test (_id,a,b) '
-                                f"VALUES ({item['_id']},a,b) "
+        self.assertEqual(query, 'INSERT INTO test (id,a,b) '
+                                f"VALUES ({item.id},a,b) "
                                 'RETURNING *;')
 
-    @helpers.async_test
+    @ helpers.async_test
     async def test_it_returns_the_new_record(self) -> None:
-        item: TestCreateOne.Item = {
-            '_id': uuid4(),
+        item = TestCreateOne.Item(**{
+            'id': uuid4(),
             'a': 'a',
             'b': 'b',
-        }
+        })
         model, _ = setup([item])
 
         result = await model.create.one(item)
@@ -148,84 +147,84 @@ class Item(ModelData):
         a: str
         b: str
 
-    @helpers.async_test
+    @ helpers.async_test
     async def test_it_correctly_builds_query_with_given_data(self) -> None:
-        item: TestUpdateOne.Item = {
-            '_id': uuid4(),
+        item = TestUpdateOne.Item(**{
+            'id': uuid4(),
             'a': 'a',
             'b': 'b',
-        }
+        })
         # cast required to avoid mypy error due to unpacking
         # TypedDict, see more on GitHub issue
         # https://github.com/python/mypy/issues/4122
-        updated = cast(TestUpdateOne.Item, {**item, 'b': 'c'})
+        updated = TestUpdateOne.Item(**{**item.dict(), 'b': 'c'})
         model, client = setup([updated])
 
-        await model.update.one_by_id(str(item['_id']), {'b': 'c'})
+        await model.update.one_by_id(str(item.id), {'b': 'c'})
         query_composed = cast(
             helpers.AsyncMock, client.execute_and_return).call_args[0][0]
         query = helpers.composed_to_string(query_composed)
 
         self.assertEqual(query, 'UPDATE test '
                                 'SET b = c '
-                                f"WHERE _id = {item['_id']} "
+                                f"WHERE id = {item.id} "
                                 'RETURNING *;')
 
-    @helpers.async_test
+    @ helpers.async_test
     async def test_it_returns_the_new_record(self) -> None:
-        item: TestUpdateOne.Item = {
-            '_id': uuid4(),
+        item = TestUpdateOne.Item(**{
+            'id': uuid4(),
             'a': 'a',
             'b': 'b',
-        }
+        })
         # cast required to avoid mypy error due to unpacking
         # TypedDict, see more on GitHub issue
         # https://github.com/python/mypy/issues/4122
-        updated = cast(TestUpdateOne.Item, {**item, 'b': 'c'})
+        updated = TestUpdateOne.Item(**{**item.dict(), 'b': 'c'})
         model, _ = setup([updated])
 
-        result = await model.update.one_by_id(str(item['_id']), {'b': 'c'})
+        result = await model.update.one_by_id(str(item.id), {'b': 'c'})
 
         self.assertEqual(result, updated)
 
 
 class TestDeleteOneById(TestCase):
-    """Testing Model.delete.one_by_id"""
+    """Testing Model.delete.one_byid"""
 
     class Item(ModelData):
         """Example ModelData Item for testing."""
         a: str
         b: str
 
-    @helpers.async_test
+    @ helpers.async_test
     async def test_it_correctly_builds_query_with_given_data(self) -> None:
-        item: TestDeleteOneById.Item = {
-            '_id': uuid4(),
+        item = TestDeleteOneById.Item(**{
+            'id': uuid4(),
             'a': 'a',
             'b': 'b',
-        }
+        })
         model, client = setup([item])
 
-        await model.delete.one_by_id(str(item['_id']))
+        await model.delete.one_by_id(str(item.id))
 
         query_composed = cast(
             helpers.AsyncMock, client.execute_and_return).call_args[0][0]
         query = helpers.composed_to_string(query_composed)
 
         self.assertEqual(query, 'DELETE FROM test '
-                                f"WHERE id = {item['_id']} "
+                                f"WHERE id = {item.id} "
                                 'RETURNING *;')
 
-    @helpers.async_test
+    @ helpers.async_test
     async def test_it_returns_the_deleted_record(self) -> None:
-        item: TestDeleteOneById.Item = {
-            '_id': uuid4(),
+        item = TestDeleteOneById.Item(**{
+            'id': uuid4(),
             'a': 'a',
             'b': 'b',
-        }
+        })
         model, _ = setup([item])
 
-        result = await model.delete.one_by_id(str(item['_id']))
+        result = await model.delete.one_by_id(str(item.id))
 
         self.assertEqual(result, item)