Add synchronous example project.

Author: andrew-chang-dewitt

example_sync/.mypy.ini

@@ -0,0 +1,26 @@
+[mypy]
+
+;
+; Import discovery
+;
+; tell mypy where the project root is for module resolution
+mypy_path=$PYTHONPATH,$PYTHONPATH/stubs
+; tell mypy to look at namespace packages (ones without an __init__.py)
+namespace_packages = True
+
+;
+; Strict mode, almost
+;
+disallow_any_generics = True
+disallow_subclassing_any = True
+disallow_untyped_calls = True
+disallow_untyped_defs = True
+disallow_incomplete_defs = True
+check_untyped_defs = True
+disallow_untyped_decorators = True
+no_implicit_optional = True
+warn_redundant_casts = True
+warn_unused_ignores = True
+warn_return_any = True
+warn_unreachable = True
+strict_equality = True

example_sync/.python-version

@@ -0,0 +1 @@
+3.9.1

example_sync/Dockerfile

@@ -0,0 +1,30 @@
+FROM python:3.9.1-alpine3.12
+
+# load source code
+RUN mkdir /app
+COPY example /app
+COPY requirements/prod.txt /app/requirements.txt
+COPY requirements/db_wrapper-0.1.0a0.tar.gz /app/requirements/db_wrapper-0.1.0a0.tar.gz
+
+VOLUME /app
+WORKDIR /app
+
+# install python dependencies
+RUN apk add --no-cache --virtual .build-deps \
+    # needed to build psycopg2 & yarl
+    gcc \
+    # needed to build yarl
+    musl-dev \
+    # needed to build psycopg2
+    postgresql-dev \
+    # runtime dependency for psycopg2
+    && apk add --no-cache libpq \
+    # install python packages
+    && ls -la requirements \
+    && pip install -r requirements.txt \
+    # then remove build dependencies
+    && apk del .build-deps
+
+# start server
+ENTRYPOINT ["python"]
+CMD ["example.py"]

example_sync/docker-compose.yml

@@ -0,0 +1,28 @@
+version: "3" # this is the Docker Compose specification
+               # version, not the app stack version
+
+services:
+
+  # seed:
+  #   build: .
+  #   environment:
+  #     MODE: development
+  #     DB_HOST: db
+  #     DB_USER: test
+  #     DB_PASS: pass
+  #     DB_NAME: dev
+  #   volumes:
+  #     - ./example:/app
+
+  db:
+    image: postgres:13-alpine
+    restart: always
+    ports:
+      - 5432:5432
+    environment:
+      POSTGRES_DB: dev
+      POSTGRES_USER: test
+      POSTGRES_PASSWORD: pass # DONT DO THIS IN PROD -- acceptable in dev,
+                              # but docker secrets should be used in prod
+                              # in conjunction with docker swarm in place
+                              # of docker compose

example_sync/example/example.py

@@ -0,0 +1,135 @@
+"""An example of how to use SyncClient & Model together."""
+
+import json
+import logging
+import os
+from uuid import uuid4, UUID
+from typing import Any, List
+
+from db_wrapper import ConnectionParameters, SyncClient, Model
+
+from models import (
+    AModel,
+    # ExtendedModel,
+    # ExtendedModelData,
+)
+
+logging.basicConfig(level=logging.INFO)
+
+
+class UUIDJsonEncoder(json.JSONEncoder):
+    """Extended Json Encoder to allow encoding of objects containing UUID."""
+
+    def default(self, obj: Any) -> Any:
+        if isinstance(obj, UUID):
+            return str(obj)
+
+        return obj
+
+
+conn_params = ConnectionParameters(
+    host=os.getenv('DB_HOST', 'localhost'),
+    port=int(os.getenv('DB_PORT', '5432')),
+    # user=os.getenv('DB_USER', 'postgres'),
+    # password=os.getenv('DB_PASS', 'postgres'),
+    # database=os.getenv('DB_NAME', 'postgres'))
+    user=os.getenv('DB_USER', 'test'),
+    password=os.getenv('DB_PASS', 'pass'),
+    database=os.getenv('DB_NAME', 'dev'))
+client = SyncClient(conn_params)
+
+a_model = Model[AModel](client, 'a_model')
+# extended_model = ExtendedModel(client)
+
+
+def create_a_model_record() -> UUID:
+    """
+    Show how to use a simple Model instance.
+
+    Create a new record using the default Model.create.one method.
+    """
+    new_record = AModel(**{
+        'id': uuid4(),
+        'string': 'some string',
+        'integer': 1,
+        'array': ['an', 'array', 'of', 'strings'],
+    })
+
+    a_model.create.one(new_record)
+
+    return new_record.id
+
+
+def read_a_model(id_value: UUID) -> AModel:
+    """Show how to read a record with a given id value."""
+    # read.one_by_id expects a string, so UUID values need
+    # converted using str()
+    return a_model.read.one_by_id(str(id_value))
+
+
+# def create_extended_models() -> None:
+#     """Show how using an extended Model can be the same as the defaults."""
+#     dicts = [{
+#         'id': uuid4(),
+#         'string': 'something',
+#         'integer': 1,
+#         'data': {'a': 1, 'b': 2, 'c': True}
+#     }, {
+#         'id': uuid4(),
+#         'string': 'something',
+#         'integer': 1,
+#         'data': {'a': 1, 'b': 2, 'c': True}
+#     }, {
+#         'id': uuid4(),
+#         'string': 'something',
+#         'integer': 1,
+#         'data': {'a': 1, 'b': 2, 'c': True}
+#     }, {
+#         'id': uuid4(),
+#         'string': 'something',
+#         'integer': 1,
+#         'data': {'a': 1, 'b': 2, 'c': True}
+#     }]
+# 
+#     new_records: List[ExtendedModelData] = [
+#         ExtendedModelData(**record) for record in dicts]
+# 
+#     # by looping over a list of records, you can use the default create.one
+#     # method to create each record as a separate transaction
+#     for record in new_records:
+#         extended_model.create.one(record)
+# 
+# 
+# def read_extended_models() -> List[ExtendedModelData]:
+#     """Show how to use an extended Model's new methods."""
+#     # We defined read.all in ./models/extended_model.py's ExtendedRead class,
+#     # then replaced ExtendedModel's read property with ExtendedRead.
+#     # As a result, we can call it just like any other method on Model.read.
+#     return extended_model.read.all()
+
+
+def run() -> None:
+    """Show how to make a connection, execute queries, & disconnect."""
+
+    # First, have the client make a connection to the database
+    client.connect()
+
+    # Then, execute queries using the models that were initialized
+    # with the client above.
+    # Doing this inside a try/finally block allows client to gracefully
+    # disconnect even when an exception is thrown.
+    try:
+        new_id = create_a_model_record()
+        created_a_model = read_a_model(new_id)
+        # create_extended_models()
+        # extended_models = read_extended_models()
+    finally:
+        client.disconnect()
+
+    # Print results to stdout
+    print(json.dumps(created_a_model, cls=UUIDJsonEncoder))
+    print(json.dumps(extended_models, cls=UUIDJsonEncoder))
+
+
+if __name__ == '__main__':
+    run()

example_sync/example/models/__init__.py

@@ -0,0 +1,2 @@
+from .a_model import AModel
+from .extended_model import ExtendedModelData, ExtendedModel

example_sync/example/models/a_model.py

@@ -0,0 +1,17 @@
+"""Define a simple Model data type."""
+
+from typing import List
+
+from db_wrapper.model import ModelData
+
+
+class AModel(ModelData):
+    """An example Item."""
+
+    # PENDS python 3.9 support in pylint,
+    # ModelData inherits from TypedDict
+    # pylint: disable=too-few-public-methods
+
+    string: str
+    integer: int
+    array: List[str]

example_sync/example/models/a_model.sql

@@ -0,0 +1,6 @@
+CREATE TABLE IF NOT EXISTS "a_model" (
+    "id" uuid PRIMARY KEY,
+    "string" varchar(255),
+    "integer" smallint,
+    "array" varchar(255) []
+);

example_sync/example/models/extended_model.py

@@ -0,0 +1,102 @@
+"""An example implementation of custom object Model."""
+
+import json
+from typing import Any, List, Dict
+
+from psycopg2 import sql
+from psycopg2.extensions import register_adapter
+from psycopg2.extras import Json
+
+from db_wrapper.model import ModelData, Model, Read, Create, Client
+
+# tell psycopg2 to adapt all dictionaries to json instead of
+# the default hstore
+register_adapter(dict, Json)
+
+
+class ExtendedModelData(ModelData):
+    """An example Item."""
+
+    # PENDS python 3.9 support in pylint,
+    # ModelData inherits from TypedDict
+    # pylint: disable=too-few-public-methods
+
+    string: str
+    integer: int
+    data: Dict[str, Any]
+
+
+class ExtendedCreator(Create[ExtendedModelData]):
+    """Add custom json loading to Model.create."""
+
+    # pylint: disable=too-few-public-methods
+
+    async def one(self, item: ExtendedModelData) -> ExtendedModelData:
+        """Override default Model.create.one method."""
+        columns: List[sql.Identifier] = []
+        values: List[sql.Literal] = []
+
+        for column, value in item.dict().items():
+            if column == 'data':
+                values.append(sql.Literal(json.dumps(value)))
+            else:
+                values.append(sql.Literal(value))
+
+            columns.append(sql.Identifier(column))
+
+        query = sql.SQL(
+            'INSERT INTO {table} ({columns}) '
+            'VALUES ({values}) '
+            'RETURNING *;'
+        ).format(
+            table=self._table,
+            columns=sql.SQL(',').join(columns),
+            values=sql.SQL(',').join(values),
+        )
+
+        result: List[ExtendedModelData] = \
+            await self._client.execute_and_return(query)
+
+        return result[0]
+
+
+class ExtendedReader(Read[ExtendedModelData]):
+    """Add custom method to Model.read."""
+
+    async def all_by_string(self, string: str) -> List[ExtendedModelData]:
+        """Read all rows with matching `string` value."""
+        query = sql.SQL(
+            'SELECT * '
+            'FROM {table} '
+            'WHERE string = {string};'
+        ).format(
+            table=self._table,
+            string=sql.Identifier(string)
+        )
+
+        result: List[ExtendedModelData] = await self \
+            ._client.execute_and_return(query)
+
+        return result
+
+    async def all(self) -> List[ExtendedModelData]:
+        """Read all rows."""
+        query = sql.SQL('SELECT * FROM {table}').format(
+            table=self._table)
+
+        result: List[ExtendedModelData] = await self \
+            ._client.execute_and_return(query)
+
+        return result
+
+
+class ExtendedModel(Model[ExtendedModelData]):
+    """Build an ExampleItem Model instance."""
+
+    read: ExtendedReader
+    create: ExtendedCreator
+
+    def __init__(self, client: Client) -> None:
+        super().__init__(client, 'extended_model')
+        self.read = ExtendedReader(self.client, self.table)
+        self.create = ExtendedCreator(self.client, self.table)

example_sync/example/models/extended_model.sql

@@ -0,0 +1,8 @@
+CREATE EXTENSION hstore;
+
+CREATE TABLE IF NOT EXISTS "extended_model" (
+    "id" uuid PRIMARY KEY,
+    "string" varchar(255),
+    "integer" smallint,
+    "data" jsonb
+);