Testing workflow

.github/workflows/app-tests.yaml

@@ -5,9 +5,13 @@ on:
     branches: [ main ]
   pull_request:
     branches: [ main ]
+  workflow_dispatch:
+
+permissions:
+  contents: read
 
 jobs:
-  test_package:
+  test-package:
     name: Test ${{ matrix.os }} Python ${{ matrix.python_version }}
     runs-on: ${{ matrix.os }}
     strategy:
@@ -65,4 +69,8 @@ jobs:
           run: |
             cd ./src/frontend
             npm install
-            npm run build
+            npm run build
+        - name: Run MyPy
+          run: python3 -m mypy .
+        - name: Run Pytest
+          run: python3 -m pytest

.github/workflows/python-code-quality.yaml

@@ -3,23 +3,34 @@ name: Python code quality
 on:
   push:
     branches: [ main ]
+    paths:
+      - '**.py'
+
   pull_request:
     branches: [ main ]
+    paths:
+      - '**.py'
+
+  workflow_dispatch:
+
+permissions:
+  contents: read
 
 jobs:
-  build:
+  checks-format-and-lint:
     runs-on: ubuntu-latest
     steps:
         - uses: actions/checkout@v4
         - name: Set up Python 3
           uses: actions/setup-python@v5
           with:
             python-version: "3.12"
+            cache: 'pip'
         - name: Install dependencies
           run: |
-            python -m pip install --upgrade pip
-            pip install -r requirements-dev.txt
+            python3 -m pip install --upgrade pip
+            python3 -m pip install ruff
         - name: Lint with ruff
           run: ruff check .
         - name: Check formatting with ruff
-          run: ruff format --check .
+          run: ruff format . --check

pyproject.toml

@@ -1,10 +1,26 @@
 [tool.ruff]
 line-length = 120
-target-version = "py311"
+target-version = "py312"
+lint.select = ["E", "F", "I", "UP"]
+lint.ignore = ["D203"]
+lint.isort.known-first-party = ["fastapi_app"]
 
-[tool.ruff.lint]
-select = ["E", "F", "I", "UP"]
-ignore = ["D203"]
+[tool.mypy]
+check_untyped_defs = true
+python_version = 3.12
+exclude = [".venv/*"]
 
-[tool.ruff.lint.isort]
-known-first-party = ["fastapi_app"]
+[tool.pytest.ini_options]
+addopts = "-ra --cov"
+testpaths = ["tests"]
+pythonpath = ['src']
+filterwarnings = ["ignore::DeprecationWarning"]
+
+[[tool.mypy.overrides]]
+module = [
+    "pgvector.*",
+]
+ignore_missing_imports = true
+
+[tool.coverage.report]
+show_missing = true

requirements-dev.txt

@@ -2,4 +2,8 @@
 ruff
 pre-commit
 pip-tools
-pip-compile-cross-platform
+pip-compile-cross-platform
+pytest
+pytest-cov
+pytest-asyncio
+mypy

src/fastapi_app/__init__.py

@@ -1,70 +1,57 @@
-import contextlib
 import logging
 import os
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from typing import TypedDict
 
-import azure.identity
 from dotenv import load_dotenv
-from environs import Env
 from fastapi import FastAPI
-
-from .globals import global_storage
-from .openai_clients import create_openai_chat_client, create_openai_embed_client
-from .postgres_engine import create_postgres_engine_from_env
+from openai import AsyncAzureOpenAI, AsyncOpenAI
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+from fastapi_app.dependencies import (
+    FastAPIAppContext,
+    common_parameters,
+    create_async_sessionmaker,
+    get_azure_credentials,
+)
+from fastapi_app.openai_clients import create_openai_chat_client, create_openai_embed_client
+from fastapi_app.postgres_engine import create_postgres_engine_from_env
 
 logger = logging.getLogger("ragapp")
 
 
-@contextlib.asynccontextmanager
-async def lifespan(app: FastAPI):
-    load_dotenv(override=True)
+class State(TypedDict):
+    sessionmaker: async_sessionmaker[AsyncSession]
+    context: FastAPIAppContext
+    chat_client: AsyncOpenAI | AsyncAzureOpenAI
+    embed_client: AsyncOpenAI | AsyncAzureOpenAI
 
-    azure_credential = None
-    try:
-        if client_id := os.getenv("APP_IDENTITY_ID"):
-            # Authenticate using a user-assigned managed identity on Azure
-            # See web.bicep for value of APP_IDENTITY_ID
-            logger.info(
-                "Using managed identity for client ID %s",
-                client_id,
-            )
-            azure_credential = azure.identity.ManagedIdentityCredential(client_id=client_id)
-        else:
-            azure_credential = azure.identity.DefaultAzureCredential()
-    except Exception as e:
-        logger.warning("Failed to authenticate to Azure: %s", e)
 
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncIterator[State]:
+    context = await common_parameters()
+    azure_credential = await get_azure_credentials()
     engine = await create_postgres_engine_from_env(azure_credential)
-    global_storage.engine = engine
-
-    openai_chat_client, openai_chat_model = await create_openai_chat_client(azure_credential)
-    global_storage.openai_chat_client = openai_chat_client
-    global_storage.openai_chat_model = openai_chat_model
-
-    openai_embed_client, openai_embed_model, openai_embed_dimensions = await create_openai_embed_client(
-        azure_credential
-    )
-    global_storage.openai_embed_client = openai_embed_client
-    global_storage.openai_embed_model = openai_embed_model
-    global_storage.openai_embed_dimensions = openai_embed_dimensions
-
-    yield
+    sessionmaker = await create_async_sessionmaker(engine)
+    chat_client = await create_openai_chat_client(azure_credential)
+    embed_client = await create_openai_embed_client(azure_credential)
 
+    yield {"sessionmaker": sessionmaker, "context": context, "chat_client": chat_client, "embed_client": embed_client}
     await engine.dispose()
 
 
-def create_app():
-    env = Env()
-
-    if not os.getenv("RUNNING_IN_PRODUCTION"):
-        env.read_env(".env")
-        logging.basicConfig(level=logging.INFO)
-    else:
+def create_app(testing: bool = False):
+    if os.getenv("RUNNING_IN_PRODUCTION"):
         logging.basicConfig(level=logging.WARNING)
+    else:
+        if not testing:
+            load_dotenv(override=True)
+        logging.basicConfig(level=logging.INFO)
 
     app = FastAPI(docs_url="/docs", lifespan=lifespan)
 
-    from . import api_routes  # noqa
-    from . import frontend_routes  # noqa
+    from fastapi_app.routes import api_routes, frontend_routes
 
     app.include_router(api_routes.router)
     app.mount("/", frontend_routes.router)

src/fastapi_app/api_models.py

@@ -1,5 +1,6 @@
 from typing import Any
 
+from openai.types.chat import ChatCompletionMessageParam
 from pydantic import BaseModel
 
 
@@ -9,11 +10,36 @@ class Message(BaseModel):
 
 
 class ChatRequest(BaseModel):
-    messages: list[Message]
+    messages: list[ChatCompletionMessageParam]
     context: dict = {}
 
 
 class ThoughtStep(BaseModel):
     title: str
     description: Any
     props: dict = {}
+
+
+class RAGContext(BaseModel):
+    data_points: dict[int, dict[str, Any]]
+    thoughts: list[ThoughtStep]
+    followup_questions: list[str] | None = None
+
+
+class RetrievalResponse(BaseModel):
+    message: Message
+    context: RAGContext
+    session_state: Any | None = None
+
+
+class ItemPublic(BaseModel):
+    id: int
+    type: str
+    brand: str
+    name: str
+    description: str
+    price: float
+
+
+class ItemWithDistance(ItemPublic):
+    distance: float