Fix CRUD method return types.

Previously, the built-in methods on the CRUD objects were returning the
raw data from the Client's `execute_and_return()` method, of type
`RealDictRow` from `psycopg2.extras`. Now each CRUD object also requires
a return type object of type `Type[T]` to be passed as a second argument
on initialization, which is then used to initialize a return type object
from the db query results (i.e. an instance of `ModelData`) to be
returned.

Also generalizes `model.base.ensure_exactly_one()` to accept any list
object.

Also removes unnecessary type imports.

Author: andrew-chang-dewitt

db_wrapper/model/__init__.py

@@ -1,5 +1,6 @@
 """Convenience objects to simplify database interactions w/ given interface."""
 
+from psycopg2.extras import RealDictRow
 from .async_model import (
     AsyncModel,
     AsyncCreate,

db_wrapper/model/base.py

@@ -3,12 +3,13 @@
 # std lib dependencies
 from __future__ import annotations
 from typing import (
-    TypeVar,
-    Generic,
     Any,
-    Tuple,
-    List,
     Dict,
+    Generic,
+    List,
+    Tuple,
+    Type,
+    TypeVar,
 )
 from uuid import UUID
 
@@ -54,23 +55,35 @@ def __init__(self) -> None:
         super().__init__(self, message)
 
 
-def ensure_exactly_one(result: List[T]) -> None:
+def ensure_exactly_one(result: List[Any]) -> None:
     """Raise appropriate Exceptions if list longer than 1."""
     if len(result) > 1:
         raise UnexpectedMultipleResults(result)
     if len(result) == 0:
         raise NoResultFound()
 
 
-class CreateABC(Generic[T]):
-    """Encapsulate Create operations for Model.read."""
+class CRUDABC(Generic[T]):
+    """Encapsulate object creation behavior for all CRUD objects."""
 
     # pylint: disable=too-few-public-methods
 
     _table: sql.Composable
+    _return_constructor: Type[T]
 
-    def __init__(self, table: sql.Composable) -> None:
+    def __init__(
+        self,
+        table: sql.Composable,
+        return_constructor: Type[T]
+    ) -> None:
         self._table = table
+        self._return_constructor = return_constructor
+
+
+class CreateABC(CRUDABC[T]):
+    """Encapsulate Create operations for Model.create."""
+
+    # pylint: disable=too-few-public-methods
 
     def _query_one(self, item: T) -> sql.Composed:
         """Build query to create one new record with a given item."""
@@ -95,16 +108,11 @@ def _query_one(self, item: T) -> sql.Composed:
         return query
 
 
-class ReadABC(Generic[T]):
+class ReadABC(CRUDABC[T]):
     """Encapsulate Read operations for Model.read."""
 
     # pylint: disable=too-few-public-methods
 
-    _table: sql.Composable
-
-    def __init__(self, table: sql.Composable) -> None:
-        self._table = table
-
     def _query_one_by_id(self, id_value: UUID) -> sql.Composed:
         """Build query to read a row by it's id."""
         query = sql.SQL(
@@ -119,16 +127,11 @@ def _query_one_by_id(self, id_value: UUID) -> sql.Composed:
         return query
 
 
-class UpdateABC(Generic[T]):
+class UpdateABC(CRUDABC[T]):
     """Encapsulate Update operations for Model.read."""
 
     # pylint: disable=too-few-public-methods
 
-    _table: sql.Composable
-
-    def __init__(self, table: sql.Composable) -> None:
-        self._table = table
-
     def _query_one_by_id(
         self,
         id_value: str,
@@ -160,16 +163,11 @@ def compose_changes(changes: Dict[str, Any]) -> sql.Composed:
         return query
 
 
-class DeleteABC(Generic[T]):
+class DeleteABC(CRUDABC[T]):
     """Encapsulate Delete operations for Model.read."""
 
     # pylint: disable=too-few-public-methods
 
-    _table: sql.Composable
-
-    def __init__(self, table: sql.Composable) -> None:
-        self._table = table
-
     def _query_one_by_id(self, id_value: str) -> sql.Composed:
         """Build query to delete one record with matching ID."""
         query = sql.SQL(

db_wrapper/model/sync_model.py

@@ -1,17 +1,19 @@
 """Synchronous Model objects."""
 
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Type
 from uuid import UUID
 
+from psycopg2.extras import RealDictRow
+
 from db_wrapper.client import SyncClient
 from .base import (
-    ensure_exactly_one,
     T,
     CreateABC,
+    DeleteABC,
     ReadABC,
     UpdateABC,
-    DeleteABC,
     ModelABC,
+    ensure_exactly_one,
     sql,
 )
 
@@ -23,16 +25,22 @@ class SyncCreate(CreateABC[T]):
 
     _client: SyncClient
 
-    def __init__(self, client: SyncClient, table: sql.Composable) -> None:
-        super().__init__(table)
+    def __init__(
+        self,
+        client: SyncClient,
+        table: sql.Composable,
+        return_constructor: Type[T]
+    ) -> None:
+        super().__init__(table, return_constructor)
         self._client = client
 
     def one(self, item: T) -> T:
         """Create one new record with a given item."""
-        result: List[T] = self._client.execute_and_return(
+        query_result: List[RealDictRow] = self._client.execute_and_return(
             self._query_one(item))
+        result: T = self._return_constructor(**query_result[0])
 
-        return result[0]
+        return result
 
 
 class SyncRead(ReadABC[T]):
@@ -42,19 +50,26 @@ class SyncRead(ReadABC[T]):
 
     _client: SyncClient
 
-    def __init__(self, client: SyncClient, table: sql.Composable) -> None:
-        super().__init__(table)
+    def __init__(
+        self,
+        client: SyncClient,
+        table: sql.Composable,
+        return_constructor: Type[T]
+    ) -> None:
+        super().__init__(table, return_constructor)
         self._client = client
 
     def one_by_id(self, id_value: UUID) -> T:
         """Read a row by it's id."""
-        result: List[T] = self._client.execute_and_return(
+        query_result: List[RealDictRow] = self._client.execute_and_return(
             self._query_one_by_id(id_value))
 
         # Should only return one item from DB
-        ensure_exactly_one(result)
+        ensure_exactly_one(query_result)
 
-        return result[0]
+        result: T = self._return_constructor(**query_result[0])
+
+        return result
 
 
 class SyncUpdate(UpdateABC[T]):
@@ -64,8 +79,13 @@ class SyncUpdate(UpdateABC[T]):
 
     _client: SyncClient
 
-    def __init__(self, client: SyncClient, table: sql.Composable) -> None:
-        super().__init__(table)
+    def __init__(
+        self,
+        client: SyncClient,
+        table: sql.Composable,
+        return_constructor: Type[T]
+    ) -> None:
+        super().__init__(table, return_constructor)
         self._client = client
 
     def one_by_id(self, id_value: str, changes: Dict[str, Any]) -> T:
@@ -79,12 +99,14 @@ def one_by_id(self, id_value: str, changes: Dict[str, Any]) -> T:
         Returns:
             full value of row updated
         """
-        result: List[T] = self._client.execute_and_return(
+        query_result: List[RealDictRow] = self._client.execute_and_return(
             self._query_one_by_id(id_value, changes))
 
-        ensure_exactly_one(result)
+        ensure_exactly_one(query_result)
+
+        result: T = self._return_constructor(**query_result[0])
 
-        return result[0]
+        return result
 
 
 class SyncDelete(DeleteABC[T]):
@@ -94,19 +116,25 @@ class SyncDelete(DeleteABC[T]):
 
     _client: SyncClient
 
-    def __init__(self, client: SyncClient, table: sql.Composable) -> None:
-        super().__init__(table)
+    def __init__(
+        self,
+        client: SyncClient,
+        table: sql.Composable,
+        return_constructor: Type[T]
+    ) -> None:
+        super().__init__(table, return_constructor)
         self._client = client
 
     def one_by_id(self, id_value: str) -> T:
         """Delete one record with matching ID."""
-        result: List[T] = self._client.execute_and_return(
+        query_result: List[RealDictRow] = self._client.execute_and_return(
             self._query_one_by_id(id_value))
 
-        # Should only return one item from DB
-        ensure_exactly_one(result)
+        ensure_exactly_one(query_result)
+
+        result: T = self._return_constructor(**query_result[0])
 
-        return result[0]
+        return result
 
 
 class SyncModel(ModelABC[T]):
@@ -128,13 +156,17 @@ def __init__(
         self,
         client: SyncClient,
         table: str,
+        return_constructor: Type[T],
     ) -> None:
         super().__init__(client, table)
 
-        self._create = SyncCreate[T](self.client, self.table)
-        self._read = SyncRead[T](self.client, self.table)
-        self._update = SyncUpdate[T](self.client, self.table)
-        self._delete = SyncDelete[T](self.client, self.table)
+        self._create = SyncCreate[T](
+            self.client, self.table, return_constructor)
+        self._read = SyncRead[T](self.client, self.table, return_constructor)
+        self._update = SyncUpdate[T](
+            self.client, self.table, return_constructor)
+        self._delete = SyncDelete[T](
+            self.client, self.table, return_constructor)
 
     @property
     def create(self) -> SyncCreate[T]: