svc.py

import logging
import os
import uuid
from contextlib import asynccontextmanager
from typing import AsyncGenerator
from uuid import UUID

import uvicorn
from fastapi import FastAPI, UploadFile, HTTPException, Query, Path, Depends, Request
from fastapi.responses import StreamingResponse

from content.local_storage import LocalContentStorage
from content.storage import FileUploadWrapper
from db.connections import DBConnManager
from metadata.db_storage import DBMetadataStorage
from storagemanager.storage_manager import (
    StorageManager,
    MetadataExtractionException,
    FileSaveException,
    MetadataRetrievalException,
    FileDeletionException,
    ContentRetrievalException
)
from validation import PaginatedContentMetadata, FileUploadResponse, ContentMetadata

logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.INFO)
logger = logging.getLogger(__name__)


@asynccontextmanager
async def lifespan(f_app: FastAPI) -> AsyncGenerator[None, None]:
    database_url = os.getenv('DB_URL')
    if not database_url:
        raise RuntimeError("DB_URL env var is required")
    delimiter_chars = os.getenv('CSV_DELIMITERS')
    estimate_rows = os.getenv('ESTIMATE_ROW_COUNT', 'False').lower() == 'true'

    db_conn_mgr = DBConnManager(conn_str=database_url)

    try:
        db_conn_mgr.init()

        storage_mgr = StorageManager(
            content_storage=LocalContentStorage('./'),
            metadata_storage=DBMetadataStorage(db_conn_mgr),
            csv_delimiters=delimiter_chars,
            estimate_rows=estimate_rows
        )

        f_app.state.storage_manager = storage_mgr
        f_app.state.db_conn_mgr = db_conn_mgr

        yield

    except Exception as e:
        logger.critical("Startup failed", exc_info=e)
        raise e

    finally:
        logger.info("Shutdown signal received")
        try:
            db_conn_mgr.close()
        except Exception as e:
            logger.error("Error closing DB connection", exc_info=e)


def get_storage_manager(request: Request) -> StorageManager:
    if not hasattr(request.app.state, "storage_manager"):
        raise RuntimeError("Storage Manager is not initialized. Check application lifespan.")
    return request.app.state.storage_manager


def create_app() -> FastAPI:
    app = FastAPI(title="CSV Upload Service", lifespan=lifespan)

    @app.post("/files", response_model=FileUploadResponse, status_code=201)
    async def upload_csv(
            file: UploadFile,
            storage_manager: StorageManager = Depends(get_storage_manager)
    ):
        try:
            file_id = await storage_manager.save(file.filename, FileUploadWrapper(file.file))
            return FileUploadResponse(id=uuid.UUID(file_id))

        except MetadataExtractionException:
            raise HTTPException(status_code=400, detail="Invalid CSV file or encoding")
        except FileSaveException:
            raise HTTPException(status_code=500, detail="Failed to persist the CSV file")
        finally:
            await file.close()

    @app.get("/files", response_model=PaginatedContentMetadata, status_code=200)
    async def get_all_metadata(
            page: int = Query(1, ge=1, description="Page number"),
            page_size: int = Query(10, ge=1, le=100, description="Items per page"),
            storage_manager: StorageManager = Depends(get_storage_manager)
    ):
        try:
            return await storage_manager.list_metadata(page, page_size)
        except MetadataRetrievalException:
            raise HTTPException(status_code=500, detail="Failed to retrieve metadata")

    @app.get("/files/{id}/metadata", response_model=ContentMetadata, status_code=200)
    async def get_metadata(
            id: UUID = Path(..., title="File UUID", description="The UUID of the file"),
            storage_manager: StorageManager = Depends(get_storage_manager)
    ):
        try:
            metadata = await storage_manager.get_metadata(str(id))
        except MetadataRetrievalException:
            raise HTTPException(status_code=500, detail="Error retrieving metadata")

        if metadata:
            return metadata
        raise HTTPException(status_code=404, detail="Not found")

    @app.delete("/files/{id}", status_code=204)
    async def delete_file(
            id: UUID = Path(..., title="File UUID", description="The UUID of the file"),
            storage_manager: StorageManager = Depends(get_storage_manager)
    ):
        try:
            deleted = await storage_manager.delete(str(id))
        except FileDeletionException:
            raise HTTPException(status_code=500, detail="Failed to delete file")

        if not deleted:
            raise HTTPException(status_code=404, detail="Not found")

    @app.get("/files/{id}/data", status_code=200)
    async def get_content(
            id: UUID = Path(..., title="File UUID", description="The UUID of the file"),
            storage_manager: StorageManager = Depends(get_storage_manager)
    ):
        try:
            content_stream = await storage_manager.get_content_stream(str(id))
        except (MetadataRetrievalException, ContentRetrievalException):
            raise HTTPException(status_code=500, detail="Failed to retrieve content")

        if content_stream:
            return StreamingResponse(content_stream(), media_type="application/json")

        raise HTTPException(status_code=404, detail="Not found")

    return app


app = create_app()

if __name__ == '__main__':
    # uvicorn main:app --host 0.0.0.0 --port 8080
    uvicorn.run(app, host="0.0.0.0", port=8080)