Implement initial API for web UI backend

.flake8

@@ -1,3 +1,3 @@
 [flake8]
 max-line-length = 160
-ignore = E203, E402, W503
+ignore = E203, E402, W503, B008

.pre-commit-config.yaml

@@ -19,7 +19,7 @@ repos:
       - id: autoflake
         args:
           - --in-place
-          - --imports=sqlalchemy,pydantic
+          - --imports=trapdata,sqlalchemy,pydantic,fastapi
         files: .
         types: [file, python]
 

pyproject.toml

@@ -45,6 +45,8 @@ ipython = "^8.11.0"
 pytest-cov = "^4.0.0"
 pytest-asyncio = "^0.21.0"
 pytest = "*"
+fastapi = "^0.95.0"
+uvicorn = "^0.21.1"
 
 
 [tool.pytest.ini_options]

trapdata/api/ami.service

@@ -0,0 +1,21 @@
+[Unit]
+
+Description=AMI Data Manager API
+
+After=network.target
+
+
+[Service]
+
+User=debian
+
+Group=www-data
+
+WorkingDirectory=/home/debian/ami-data-manager
+
+ExecStart=/home/debian/miniconda3/bin/gunicorn trapdata.api.main:app --bind 0.0.0.0:8000 --worker-class "uvicorn.workers.UvicornWorker" --log-syslog
+
+
+[Install]
+
+WantedBy=multi-user.target

trapdata/api/config.py

@@ -0,0 +1,39 @@
+import pathlib
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseSettings, HttpUrl, PostgresDsn, validator
+from pydantic.networks import AnyHttpUrl
+
+from trapdata.cli import read_settings
+from trapdata.settings import Settings as BaseSettings
+
+
+class Settings(BaseSettings):
+    PROJECT_NAME: str = "AMI Data Manager"
+
+    SENTRY_DSN: Optional[HttpUrl] = None
+
+    API_PATH: str = "/api/v1"
+
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = 7 * 24 * 60  # 7 days
+
+    BACKEND_CORS_ORIGINS: List[AnyHttpUrl] = []
+
+    # The following variables need to be defined in environment
+
+    TEST_DATABASE_URL: Optional[PostgresDsn]
+
+    SECRET_KEY: str
+    #  END: required environment variables
+
+    # STATIC_ROOT: str = "static"
+
+    # @validator("STATIC_ROOT")
+    # def validate_static_root(cls, v):
+    #     path = cls.user_data_path / v
+    #     path.mkdir(parents=True, exist_ok=True)
+    #     return path
+
+
+# settings = read_settings(SettingsClass=Settings, SECRET_KEY="secret")
+settings = Settings(SECRET_KEY="secret")

trapdata/api/deps/db.py

@@ -0,0 +1,15 @@
+from typing import Generator
+
+from sqlalchemy import orm
+
+from trapdata.cli import read_settings
+from trapdata.db.base import get_session_class
+
+settings = read_settings()
+
+
+def get_session() -> Generator[orm.Session, None, None]:
+    Session = get_session_class(db_path=settings.database_url)
+    with Session() as session:
+        yield session
+        session.close()

trapdata/api/deps/request_params.py

@@ -0,0 +1,46 @@
+import json
+from typing import Callable, Optional, Type
+
+from fastapi import HTTPException, Query
+from sqlalchemy import UnaryExpression, asc, desc
+
+from trapdata.api.request_params import RequestParams
+from trapdata.db import Base
+
+
+def parse_react_admin_params(model: Type[Base]) -> Callable:
+    """Parses sort and range parameters coming from a react-admin request"""
+
+    def inner(
+        sort_: Optional[str] = Query(
+            None,
+            alias="sort",
+            description='Format: `["field_name", "direction"]`',
+            example='["id", "ASC"]',
+        ),
+        range_: Optional[str] = Query(
+            None,
+            alias="range",
+            description="Format: `[start, end]`",
+            example="[0, 10]",
+        ),
+    ) -> RequestParams:
+        skip, limit = 0, 10
+        if range_:
+            start, end = json.loads(range_)
+            skip, limit = start, (end - start + 1)
+
+        order_by: UnaryExpression = desc(model.id)
+        if sort_:
+            sort_column, sort_order = json.loads(sort_)
+            if sort_order.lower() == "asc":
+                direction = asc
+            elif sort_order.lower() == "desc":
+                direction = desc
+            else:
+                raise HTTPException(400, f"Invalid sort direction {sort_order}")
+            order_by = direction(model.__table__.c[sort_column])
+
+        return RequestParams(skip=skip, limit=limit, order_by=order_by)
+
+    return inner

trapdata/api/factory.py

@@ -0,0 +1,87 @@
+from fastapi import FastAPI
+from fastapi.routing import APIRoute
+from fastapi.staticfiles import StaticFiles
+from starlette.middleware.cors import CORSMiddleware
+from starlette.requests import Request
+from starlette.responses import FileResponse, RedirectResponse
+
+from trapdata.api.config import settings
+from trapdata.api.views import api_router
+
+
+def create_app():
+    description = f"{settings.PROJECT_NAME} API"
+    app = FastAPI(
+        title=settings.PROJECT_NAME,
+        openapi_url=f"{settings.API_PATH}/openapi.json",
+        docs_url="/docs/",
+        description=description,
+        redoc_url="/redoc/",
+    )
+    setup_routers(app)
+    setup_cors_middleware(app)
+    serve_static_app(app)
+    return app
+
+
+def setup_routers(app: FastAPI) -> None:
+    app.include_router(api_router, prefix=settings.API_PATH)
+    # The following operation needs to be at the end of this function
+    use_route_names_as_operation_ids(app)
+
+
+def serve_static_app(app):
+    app.mount(
+        "/static/crops",
+        StaticFiles(directory=settings.user_data_path / "crops"),
+        name="crops",
+    )
+    app.mount(
+        "/static/captures",
+        StaticFiles(directory=settings.image_base_path),
+        name="captures",
+    )
+    app.mount(
+        "/",
+        StaticFiles(directory="trapdata/webui/public"),
+        name="static",
+    )
+
+    @app.middleware("http")
+    async def _add_404_middleware(request: Request, call_next):
+        """Serves static assets on 404"""
+        response = await call_next(request)
+        path = request["path"]
+        if path.startswith(settings.API_PATH) or path.startswith("/docs"):
+            return response
+        if response.status_code == 404:
+            return FileResponse("trapdata/webui/public/index.html")
+        return response
+
+
+def setup_cors_middleware(app):
+    if settings.BACKEND_CORS_ORIGINS:
+        app.add_middleware(
+            CORSMiddleware,
+            allow_origins=[str(origin) for origin in settings.BACKEND_CORS_ORIGINS],
+            allow_credentials=True,
+            allow_methods=["*"],
+            expose_headers=["Content-Range", "Range"],
+            allow_headers=["Authorization", "Range", "Content-Range"],
+        )
+
+
+def use_route_names_as_operation_ids(app: FastAPI) -> None:
+    """
+    Simplify operation IDs so that generated API clients have simpler function
+    names.
+
+    Should be called only after all routes have been added.
+    """
+    route_names = set()
+    for route in app.routes:
+        if isinstance(route, APIRoute):
+            if route.name in route_names:
+                raise Exception("Route function names should be unique")
+            route.operation_id = route.name
+            route_names.add(route.name)