Ruff-format

app/routers/decks.py

@@ -6,27 +6,30 @@ from ..templates import jinja_templates, _jsonify
 from ..sql import crud, schemas
 from ..sql.database import get_db
 
-from .players import read_player, list_players
+from .players import list_players
 
 api_router = APIRouter(prefix="/deck", tags=["deck"])
 html_router = APIRouter(prefix="/deck", include_in_schema=False)
 
+
 @api_router.post("/", response_model=schemas.Deck, status_code=201)
 def create_deck(deck: schemas.DeckCreate, db: Session = Depends(get_db)):
     db_player = crud.get_player_by_id(db, deck.owner_id)
     if db_player is None:
-        raise HTTPException(status_code=400, detail=f"Owner id {deck.owner_id} not found")
+        raise HTTPException(
+            status_code=400, detail=f"Owner id {deck.owner_id} not found"
+        )
 
     return crud.create_deck(db=db, deck=deck)
 
 
 @api_router.get("/list", response_model=list[schemas.Deck])
-def list_decks(skip: int = 0, limit: int = 100, db = Depends(get_db)):
+def list_decks(skip: int = 0, limit: int = 100, db=Depends(get_db)):
     return crud.get_decks(db, skip=skip, limit=limit)
 
 
 @api_router.get("/{deck_id}", response_model=schemas.Deck)
-def read_deck(deck_id: int, db = Depends(get_db)):
+def read_deck(deck_id: int, db=Depends(get_db)):
     print(deck_id)
     db_deck = crud.get_deck_by_id(db, deck_id)
     if db_deck is None:
@@ -35,44 +38,33 @@ def read_deck(deck_id: int, db = Depends(get_db)):
 
 
 @api_router.delete("/{deck_id}", status_code=204)
-def delete_deck(deck_id: str, db = Depends(get_db)):
+def delete_deck(deck_id: str, db=Depends(get_db)):
     crud.delete_deck_by_id(db, int(deck_id))
 
 
 @html_router.get("/create", response_class=HTMLResponse)
-def deck_create_html(request: Request, db = Depends(get_db)):
+def deck_create_html(request: Request, db=Depends(get_db)):
     players = list_players(db=db)
     return jinja_templates.TemplateResponse(
-        request,
+        request, "decks/create.html", {"players": players}
-        "decks/create.html",
-        {
-            "players": players
-        }
     )
 
 
 # TODO - pagination
 @html_router.get("/list", response_class=HTMLResponse)
-def decks_html(request: Request, db = Depends(get_db)):
+def decks_html(request: Request, db=Depends(get_db)):
     decks = list_decks(db=db)
     return jinja_templates.TemplateResponse(
-        request,
+        request, "decks/list.html", {"decks": decks}
-        "decks/list.html",
-        {
-            "decks": decks
-        }
     )
 
 
 # This must be after the static-path routes, lest it take priority over them
 @html_router.get("/{deck_id}", response_class=HTMLResponse)
-def deck_html(request: Request, deck_id: str, db = Depends(get_db)):
+def deck_html(request: Request, deck_id: str, db=Depends(get_db)):
     deck_info = read_deck(deck_id, db)
     return jinja_templates.TemplateResponse(
         request,
         "decks/detail.html",
-        {
+        {"deck": _jsonify(deck_info), "owner": _jsonify(deck_info.owner)},
-            "deck": _jsonify(deck_info),
-            "owner": _jsonify(deck_info.owner)
-        }
     )

app/routers/players.py

@@ -9,13 +9,14 @@ from ..sql.database import get_db
 api_router = APIRouter(prefix="/player", tags=["player"])
 html_router = APIRouter(prefix="/player", include_in_schema=False)
 
+
 @api_router.post("/", response_model=schemas.Player, status_code=201)
 def create_player(player: schemas.PlayerCreate, db: Session = Depends(get_db)):
     return crud.create_player(db=db, player=player)
 
 
 @api_router.get("/list", response_model=list[schemas.Player])
-def list_players(skip: int = 0, limit: int = 100, db = Depends(get_db)):
+def list_players(skip: int = 0, limit: int = 100, db=Depends(get_db)):
     return crud.get_players(db, skip=skip, limit=limit)
 
 
@@ -31,26 +32,19 @@ def read_player(player_id: int, db=Depends(get_db)):
 
 
 @api_router.delete("/{player_id}", status_code=204)
-def delete_player(player_id: str, db = Depends(get_db)):
+def delete_player(player_id: str, db=Depends(get_db)):
     crud.delete_player_by_id(db, int(player_id))
 
 
 @html_router.get("/create", response_class=HTMLResponse)
-def player_create_html(request: Request, db = Depends(get_db)):
+def player_create_html(request: Request, db=Depends(get_db)):
-    return jinja_templates.TemplateResponse(
+    return jinja_templates.TemplateResponse(request, "players/create.html")
-        request,
-        "players/create.html"
-    )
 
 
 # This must be after the static-path routes, lest it take priority over them
 @html_router.get("/{player_id}", response_class=HTMLResponse)
-def player_html(request: Request, player_id: str, db = Depends(get_db)):
+def player_html(request: Request, player_id: str, db=Depends(get_db)):
     player_info = read_player(player_id, db)
     return jinja_templates.TemplateResponse(
-        request,
+        request, "players/detail.html", {"player": player_info}
-        "players/detail.html",
-        {
-            "player": player_info
-        }
     )

app/sql/crud.py

@@ -2,12 +2,15 @@ from sqlalchemy.orm import Session
 
 from . import models, schemas
 
+
 def get_player_by_id(db: Session, player_id: int):
     return db.query(models.Player).filter(models.Player.id == player_id).first()
 
+
 def get_players(db: Session, skip: int = 0, limit: int = 100):
     return db.query(models.Player).offset(skip).limit(limit).all()
 
+
 def create_player(db: Session, player: schemas.PlayerCreate):
     db_player = models.Player(**player.model_dump())
     db.add(db_player)
@@ -15,16 +18,20 @@ def create_player(db: Session, player: schemas.PlayerCreate):
     db.refresh(db_player)
     return db_player
 
+
 def delete_player_by_id(db: Session, player_id: int):
     db.query(models.Player).filter(models.Player.id == player_id).delete()
     db.commit()
 
+
 def get_deck_by_id(db: Session, deck_id: int):
     return db.query(models.Deck).filter(models.Deck.id == deck_id).first()
 
+
 def get_decks(db: Session, skip: int = 0, limit: int = 100):
     return db.query(models.Deck).offset(skip).limit(limit).all()
 
+
 def create_deck(db: Session, deck: schemas.DeckCreate):
     db_deck = models.Deck(**deck.model_dump())
     db.add(db_deck)
@@ -32,6 +39,7 @@ def create_deck(db: Session, deck: schemas.DeckCreate):
     db.refresh(db_deck)
     return db_deck
 
+
 def delete_deck_by_id(db: Session, deck_id: int):
     db.query(models.Deck).filter(models.Deck.id == deck_id).delete()
     db.commit()

app/sql/database.py

@@ -3,7 +3,9 @@ import os
 from sqlalchemy import create_engine
 from sqlalchemy.orm import declarative_base, sessionmaker
 
-SQLALCHEMY_DATABASE_URL = os.environ.get('DATABASE_URL', "sqlite:///database/sql_app.db")
+SQLALCHEMY_DATABASE_URL = os.environ.get(
+    "DATABASE_URL", "sqlite:///database/sql_app.db"
+)
 
 engine = create_engine(
     SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False}
@@ -12,6 +14,7 @@ SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
 
 Base = declarative_base()
 
+
 def get_db():
     db = SessionLocal()
     try:

app/sql/models.py

@@ -3,6 +3,7 @@ from sqlalchemy.orm import relationship
 
 from .database import Base
 
+
 class Player(Base):
     __tablename__ = "players"
 
@@ -11,6 +12,7 @@ class Player(Base):
 
     decks = relationship("Deck", back_populates="owner")
 
+
 class Deck(Base):
     __tablename__ = "decks"
 

app/sql/schemas.py

@@ -13,9 +13,7 @@ class PlayerCreate(PlayerBase):
 class Player(PlayerBase):
     id: int
 
-    model_config = {
+    model_config = {"from_attributes": True}
-        'from_attributes': True
-    }
 
 
 class DeckBase(BaseModel):
@@ -31,6 +29,4 @@ class DeckCreate(DeckBase):
 class Deck(DeckBase):
     id: int
 
-    model_config = {
+    model_config = {"from_attributes": True}
-        'from_attributes': True
-    }

app/templates/__init__.py

@@ -9,6 +9,7 @@ from fastapi.templating import Jinja2Templates
 
 jinja_templates = Jinja2Templates(directory="app/templates")
 
+
 # TODO - would this be better as a method on a class extending `db.Model` that the classes in `models.py` could then
 # extend?
 # (Probably not, as we'd still need to explicitly call it - it wouldn't be implicitly called _by_ Flask)

tests/conftest.py

@@ -4,6 +4,7 @@ import pytest
 
 from fastapi.testclient import TestClient
 
+
 def prime_database():
     # Start afresh!
     database_dir = "database"
@@ -18,8 +19,9 @@ def prime_database():
     if db_path.exists():
         db_path.unlink()
 
-    print(f'Setting database_url using {db_path}')
+    print(f"Setting database_url using {db_path}")
-    os.environ['DATABASE_URL'] = f'sqlite:///{db_path}'
+    os.environ["DATABASE_URL"] = f"sqlite:///{db_path}"
+
 
 prime_database()
 
@@ -27,6 +29,7 @@ prime_database()
 # during the import, and must do so after the environment-var setting
 from app import app  # noqa: E402
 
+
 @pytest.fixture()
 def test_client() -> TestClient:
     return TestClient(app)

tests/test_fresh_db_tests.py

@@ -33,7 +33,7 @@ def test_add_and_retrieve_deck(test_client: TestClient):
         test_client, "/deck", {"name": "Baby's First Deck", "owner_id": 1}
     )
     assert invalid_owner_response.status_code == 400
-    assert invalid_owner_response.json()['detail'] == "Owner id 1 not found"
+    assert invalid_owner_response.json()["detail"] == "Owner id 1 not found"
 
     create_jim_response = _json_post(test_client, "/player", {"name": "jim"})
     assert create_jim_response.status_code == 201
@@ -60,12 +60,14 @@ def test_add_and_retrieve_deck(test_client: TestClient):
 
 
 def _json_get(c: TestClient, path: str) -> httpx.Response:
-    return c.get(f'/api{path}', headers={"Content-Type": "application/json"})
+    return c.get(f"/api{path}", headers={"Content-Type": "application/json"})
 
 
 def _json_post(c: TestClient, path: str, body: Mapping) -> httpx.Response:
-    return c.post(f'/api{path}', headers={"Content-Type": "application/json"}, json=body)
+    return c.post(
+        f"/api{path}", headers={"Content-Type": "application/json"}, json=body
+    )
 
 
 def _json_delete(c: TestClient, path: str) -> httpx.Response:
-    return c.delete(f'/api{path}', headers={"Content-Type": "application/json"})
+    return c.delete(f"/api{path}", headers={"Content-Type": "application/json"})