Initial commit

app/presentation/__init__.py

@@ -0,0 +1 @@
+

app/presentation/dependencies.py

@@ -0,0 +1,53 @@
+from collections.abc import Generator
+from hmac import compare_digest
+
+from fastapi import Depends, HTTPException, Security, status
+from fastapi.security import APIKeyHeader
+from sqlalchemy.orm import Session
+
+from app.domain.usecase.GetLatestModelUseCase import GetLatestModelUseCase
+from app.domain.usecase.UploadModelUseCase import UploadModelUseCase
+from app.infrastructure.bootstrap import get_container
+from app.infrastructure.constants import API_KEY_HEADER_NAME, API_KEYS
+from app.infrastructure.ModelRepositoryImpl import ModelRepositoryImpl
+
+api_key_header = APIKeyHeader(name=API_KEY_HEADER_NAME, auto_error=False)
+
+
+def verify_api_key(api_key: str | None = Security(api_key_header)) -> None:
+    if api_key and any(compare_digest(api_key, valid_key) for valid_key in API_KEYS):
+        return
+
+    raise HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Invalid or missing API key",
+    )
+
+
+def get_db_session() -> Generator[Session, None, None]:
+    container = get_container()
+    session = container.session_factory()
+    try:
+        yield session
+    finally:
+        session.close()
+
+
+def get_upload_model_use_case(
+    session: Session = Depends(get_db_session),
+) -> UploadModelUseCase:
+    container = get_container()
+    repository = ModelRepositoryImpl(session)
+    return UploadModelUseCase(
+        repository=repository,
+        storage=container.storage,
+        converter=container.converter,
+    )
+
+
+def get_latest_model_use_case(
+    session: Session = Depends(get_db_session),
+) -> GetLatestModelUseCase:
+    container = get_container()
+    repository = ModelRepositoryImpl(session)
+    return GetLatestModelUseCase(repository=repository, storage=container.storage)

app/presentation/response/ModelResponse.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+from pydantic import BaseModel, field_serializer
+
+from app.domain.Model import Model
+
+
+class ModelResponse(BaseModel):
+    version: str
+    created_at: datetime
+    filename: str
+    is_latest: bool
+
+    @field_serializer("created_at")
+    def serialize_created_at(self, value: datetime) -> str:
+        if value.tzinfo is None:
+            value = value.replace(tzinfo=timezone.utc)
+        return value.astimezone(timezone.utc).isoformat().replace("+00:00", "Z")
+
+    @staticmethod
+    def from_model(model: Model) -> ModelResponse:
+        return ModelResponse(
+            version=model.version,
+            created_at=model.created_at,
+            filename=model.filename,
+            is_latest=model.is_latest,
+        )

app/presentation/routes.py

@@ -0,0 +1,66 @@
+from fastapi import APIRouter, Depends, File, Form, HTTPException, Query, UploadFile, status
+from fastapi.responses import FileResponse
+from app.domain.Exception import *
+from app.domain.usecase.GetLatestModelUseCase import GetLatestModelUseCase
+from app.domain.usecase.UploadModelUseCase import UploadModelUseCase
+from app.presentation.dependencies import (
+    get_latest_model_use_case,
+    get_upload_model_use_case,
+    verify_api_key,
+)
+from app.presentation.response.ModelResponse import ModelResponse
+
+router = APIRouter(dependencies=[Depends(verify_api_key)])
+
+
+@router.post("/models", response_model=ModelResponse, status_code=status.HTTP_201_CREATED)
+def upload_model(
+    file: UploadFile = File(...),
+    version: str = Form(...),
+    use_case: UploadModelUseCase = Depends(get_upload_model_use_case),
+) -> ModelResponse:
+    try:
+        result = use_case.execute(version=version, upload_file=file)
+    except InvalidModelVersionError as exc:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(exc)) from exc
+    except InvalidModelFileError as exc:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(exc)) from exc
+    except DuplicateModelVersionError as exc:
+        raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=str(exc)) from exc
+    except ModelConversionError as exc:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=str(exc),
+        ) from exc
+    return ModelResponse.from_model(result)
+
+
+@router.get("/models/latest", response_model=ModelResponse)
+def get_latest_model(
+    use_case: GetLatestModelUseCase = Depends(get_latest_model_use_case),
+) -> ModelResponse:
+    try:
+        result = use_case.execute()
+    except ModelNotFoundError as exc:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc
+    return ModelResponse.from_model(result)
+
+
+@router.get("/models/latest/download")
+def download_latest_model(
+    version: str = Query(...),
+    filename: str = Query(...),
+    use_case: GetLatestModelUseCase = Depends(get_latest_model_use_case),
+) -> FileResponse:
+    try:
+        result = use_case.execute(version=version, filename=filename)
+    except ModelNotFoundError as exc:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc
+    except ModelFileMissingError as exc:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc
+
+    return FileResponse(
+        path=result.file_path,
+        filename=result.filename,
+        media_type="application/octet-stream",
+    )