Fix/sqlalchemy 2.0 compatibility - chapter6 UoW

.travis.yml

@@ -0,0 +1,10 @@
+dist: xenial
+language: python
+python: 3.8
+
+script:
+- make all
+
+branches:
+  except:
+  - /.*_exercise$/

Dockerfile

@@ -0,0 +1,15 @@
+FROM python:3.9-slim-buster
+
+# RUN apt install gcc libpq (no longer needed bc we use psycopg2-binary)
+
+COPY requirements.txt /tmp/
+RUN pip install -r /tmp/requirements.txt
+
+RUN mkdir -p /src
+COPY src/ /src/
+RUN pip install -e /src
+COPY tests/ /tests/
+
+WORKDIR /src
+ENV FLASK_APP=allocation/entrypoints/flask_app.py FLASK_DEBUG=1 PYTHONUNBUFFERED=1
+CMD flask run --host=0.0.0.0 --port=80

Makefile

@@ -0,0 +1,32 @@
+# these will speed up builds, for docker-compose >= 1.25
+export COMPOSE_DOCKER_CLI_BUILD=1
+export DOCKER_BUILDKIT=1
+
+all: down build up test
+
+build:
+	docker-compose build
+
+up:
+	docker-compose up -d app
+
+down:
+	docker-compose down --remove-orphans
+
+test: up
+	docker-compose run --rm --no-deps --entrypoint=pytest app /tests/unit /tests/integration /tests/e2e
+
+unit-tests:
+	docker-compose run --rm --no-deps --entrypoint=pytest app /tests/unit
+
+integration-tests: up
+	docker-compose run --rm --no-deps --entrypoint=pytest app /tests/integration
+
+e2e-tests: up
+	docker-compose run --rm --no-deps --entrypoint=pytest app /tests/e2e
+
+logs:
+	docker-compose logs app | tail -100
+
+black:
+	black -l 86 $$(find * -name '*.py')

README.md

@@ -0,0 +1,76 @@
+# Example application code for the python architecture book
+
+## Chapters
+
+Each chapter has its own branch which contains all the commits for that chapter,
+so it has the state that corresponds to the _end_ of that chapter.  If you want
+to try and code along with a chapter, you'll want to check out the branch for the
+previous chapter.
+
+https://github.com/python-leap/code/branches/all
+
+
+## Exercises
+
+Branches for the exercises follow the convention `{chatper_name}_exercise`, eg 
+https://github.com/python-leap/code/tree/chapter_04_service_layer_exercise
+
+
+## Requirements
+
+* docker with docker-compose
+* for chapters 1 and 2, and optionally for the rest: a local python3.7 virtualenv
+
+
+## Building the containers
+
+_(this is only required from chapter 3 onwards)_
+
+```sh
+make build
+make up
+# or
+make all # builds, brings containers up, runs tests
+```
+
+## Creating a local virtualenv (optional)
+
+```sh
+python3.8 -m venv .venv && source .venv/bin/activate # or however you like to create virtualenvs
+
+# for chapter 1
+pip install pytest 
+
+# for chapter 2
+pip install pytest sqlalchemy
+
+# for chapter 4+5
+pip install requirements.txt
+
+# for chapter 6+
+pip install requirements.txt
+pip install -e src/
+```
+
+<!-- TODO: use a make pipinstall command -->
+
+
+## Running the tests
+
+```sh
+make test
+# or, to run individual test types
+make unit
+make integration
+make e2e
+# or, if you have a local virtualenv
+make up
+pytest tests/unit
+pytest tests/integration
+pytest tests/e2e
+```
+
+## Makefile
+
+There are more useful commands in the makefile, have a look and try them out.
+

docker-compose.yml

@@ -0,0 +1,29 @@
+version: "3"
+services:
+
+  app:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    depends_on:
+      - postgres
+    environment:
+      - DB_HOST=postgres
+      - DB_PASSWORD=abc123
+      - API_HOST=app
+      - PYTHONDONTWRITEBYTECODE=1
+    volumes:
+      - ./src:/src
+      - ./tests:/tests
+    ports:
+      - "5005:80"
+
+
+  postgres:
+    image: postgres:9.6
+    environment:
+      - POSTGRES_USER=allocation
+      - POSTGRES_PASSWORD=abc123
+    ports:
+      - "54321:5432"
+

mypy.ini

@@ -1,9 +1,7 @@
 [mypy]
 ignore_missing_imports = False
+mypy_path = ./src
+check_untyped_defs = True
 
-[mypy-pytest.*]
+[mypy-pytest.*,sqlalchemy.*]
 ignore_missing_imports = True
-
-[mypy-sqlalchemy.*]
-ignore_missing_imports = True
-

requirements.txt

@@ -0,0 +1,10 @@
+# app
+sqlalchemy>=2.0
+flask
+psycopg2-binary
+
+# tests
+pytest
+pytest-icdiff
+mypy
+requests

src/allocation/adapters/orm.py

@@ -0,0 +1,50 @@
+from sqlalchemy import Table, MetaData, Column, Integer, String, Date, ForeignKey
+from sqlalchemy.orm import registry, relationship
+
+from allocation.domain import model
+
+
+mapper_registry = registry()
+metadata = mapper_registry.metadata
+
+order_lines = Table(
+    "order_lines",
+    metadata,
+    Column("id", Integer, primary_key=True, autoincrement=True),
+    Column("sku", String(255)),
+    Column("qty", Integer, nullable=False),
+    Column("orderid", String(255)),
+)
+
+batches = Table(
+    "batches",
+    metadata,
+    Column("id", Integer, primary_key=True, autoincrement=True),
+    Column("reference", String(255)),
+    Column("sku", String(255)),
+    Column("_purchased_quantity", Integer, nullable=False),
+    Column("eta", Date, nullable=True),
+)
+
+allocations = Table(
+    "allocations",
+    metadata,
+    Column("id", Integer, primary_key=True, autoincrement=True),
+    Column("orderline_id", ForeignKey("order_lines.id")),
+    Column("batch_id", ForeignKey("batches.id")),
+)
+
+
+def start_mappers():
+    lines_mapper = mapper_registry.map_imperatively(model.OrderLine, order_lines)
+    mapper_registry.map_imperatively(
+        model.Batch,
+        batches,
+        properties={
+            "_allocations": relationship(
+                lines_mapper,
+                secondary=allocations,
+                collection_class=set,
+            )
+        },
+    )

src/allocation/adapters/repository.py

@@ -0,0 +1,29 @@
+import abc
+from sqlalchemy import select
+from allocation.domain import model
+
+
+class AbstractRepository(abc.ABC):
+    @abc.abstractmethod
+    def add(self, batch: model.Batch):
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get(self, reference) -> model.Batch:
+        raise NotImplementedError
+
+
+class SqlAlchemyRepository(AbstractRepository):
+    def __init__(self, session):
+        self.session = session
+
+    def add(self, batch):
+        self.session.add(batch)
+
+    def get(self, reference):
+        return self.session.scalars(
+            select(model.Batch).filter_by(reference=reference)
+        ).one()
+
+    def list(self):
+        return self.session.scalars(select(model.Batch)).all()

src/allocation/config.py

@@ -0,0 +1,15 @@
+import os
+
+
+def get_postgres_uri():
+    host = os.environ.get("DB_HOST", "localhost")
+    port = 54321 if host == "localhost" else 5432
+    password = os.environ.get("DB_PASSWORD", "abc123")
+    user, db_name = "allocation", "allocation"
+    return f"postgresql://{user}:{password}@{host}:{port}/{db_name}"
+
+
+def get_api_url():
+    host = os.environ.get("API_HOST", "localhost")
+    port = 5005 if host == "localhost" else 80
+    return f"http://{host}:{port}"

src/allocation/domain/model.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from datetime import date
+from typing import Optional, List, Set
+
+
+class OutOfStock(Exception):
+    pass
+
+
+def allocate(line: OrderLine, batches: List[Batch]) -> str:
+    try:
+        batch = next(b for b in sorted(batches) if b.can_allocate(line))
+        batch.allocate(line)
+        return batch.reference
+    except StopIteration:
+        raise OutOfStock(f"Out of stock for sku {line.sku}")
+
+
+@dataclass(unsafe_hash=True)
+class OrderLine:
+    orderid: str
+    sku: str
+    qty: int
+
+
+class Batch:
+    def __init__(self, ref: str, sku: str, qty: int, eta: Optional[date]):
+        self.reference = ref
+        self.sku = sku
+        self.eta = eta
+        self._purchased_quantity = qty
+        self._allocations = set()  # type: Set[OrderLine]
+
+    def __repr__(self):
+        return f"<Batch {self.reference}>"
+
+    def __eq__(self, other):
+        if not isinstance(other, Batch):
+            return False
+        return other.reference == self.reference
+
+    def __hash__(self):
+        return hash(self.reference)
+
+    def __gt__(self, other):
+        if self.eta is None:
+            return False
+        if other.eta is None:
+            return True
+        return self.eta > other.eta
+
+    def allocate(self, line: OrderLine):
+        if self.can_allocate(line):
+            self._allocations.add(line)
+
+    def deallocate(self, line: OrderLine):
+        if line in self._allocations:
+            self._allocations.remove(line)
+
+    @property
+    def allocated_quantity(self) -> int:
+        return sum(line.qty for line in self._allocations)
+
+    @property
+    def available_quantity(self) -> int:
+        return self._purchased_quantity - self.allocated_quantity
+
+    def can_allocate(self, line: OrderLine) -> bool:
+        return self.sku == line.sku and self.available_quantity >= line.qty