clean: remove all space contents

.gitignore

@@ -1 +0,0 @@
-.env

.vscode/settings.json

@@ -1,3 +0,0 @@
-{
-    "python-envs.defaultEnvManager": "ms-python.python:system"
-}

Dockerfile

@@ -1,30 +0,0 @@
-FROM python:3.11-slim
-
-ENV PYTHONDONTWRITEBYTECODE=1 \
-    PYTHONUNBUFFERED=1 \
-    PIP_NO_CACHE_DIR=1 \
-    PIP_DISABLE_PIP_VERSION_CHECK=1
-
-WORKDIR /app
-
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    curl \
-    && rm -rf /var/lib/apt/lists/*
-
-RUN useradd -m -u 1000 user
-
-COPY --chown=user:user requirements.txt .
-
-RUN pip install --no-cache-dir -r requirements.txt
-
-COPY --chown=user:user . .
-
-RUN mkdir -p /app/documents/pdfs /app/documents/images /app/files /app/db \
-    && chown -R user:user /app/documents /app/files /app/db \
-    && chmod +x /app/start.sh
-
-USER user
-
-EXPOSE 7860
-
-CMD ["./start.sh"]

README.md

@@ -1,9 +0,0 @@
----
-title: reconciliation-file-service-backup
-emoji: 📁
-colorFrom: red
-colorTo: pink
-sdk: docker
-app_file: main.py
-pinned: false
----

app/banner.py

@@ -1,20 +0,0 @@
-import pyfiglet
-from rich.console import Console
-from rich.rule import Rule
-from rich.text import Text
-
-from app.core.config import settings
-
-_console = Console()
-
-
-def print_banner() -> None:
-
-    art = pyfiglet.figlet_format("ValidOps", font="slant")
-
-    _console.print(Text(art, style="bold cyan"))
-    _console.print(f"  [bold white]{'Service:':<14}[/bold white]  [cyan]{settings.APP_NAME}[/cyan]")
-    _console.print(f"  [bold white]{'Version:':<14}[/bold white]  [cyan]v{settings.APP_VERSION}[/cyan]")
-    _console.print(f"  [bold white]{'Environment:':<14}[/bold white]  [cyan]{settings.ENVIRONMENT}[/cyan]")
-    _console.print(Rule(style="dim cyan"))
-    _console.print()

app/core/config.py

@@ -1,41 +0,0 @@
-from pathlib import Path
-from typing import Optional
-from pydantic_settings import BaseSettings
-
-
-class Settings(BaseSettings):
-    APP_BASE_URL: str = "https://validops-east-3-instance-2.hf.space"
-    APP_NAME: str = "reconciliation-backup-file-service"
-    APP_VERSION: str = "1.0.0"
-    ENVIRONMENT: str = "production"
-
-    BASE_DIR: Path = Path("documents")
-    FILES_DIR: Path = Path("/app/files")
-    DATABASE_URL: str = "sqlite:////app/db/file_service.db"
-    
-    MAX_FILE_SIZE_MB: int = 50
-
-    VALID_API_KEYS: set[str] = set()
-
-    ALLOWED_ORIGINS: list[str] = ["https://validops-east-1-instance-1.hf.space", "https://validops-east-1-instance-2.hf.space", "https://validops-ai.vercel.app"]
-    ALLOWED_METHODS: set[str] = {"GET", "POST", "PUT", "DELETE", "OPTIONS"}
-
-    IP_WHITELIST: Optional[set[str]] = None
-    IP_BLACKLIST: set[str] = set()
-
-    REDIS_URL: str
-    RATE_LIMIT_PER_MINUTE: int = 100
-    RATE_LIMIT_WINDOW_SECONDS: int = 60
-    RATE_LIMIT_KEY_PREFIX: str = "rl"
-
-    MAX_REQUEST_SIZE_MB: int = 50
-    TRUSTED_PROXIES: set[str] = {"127.0.0.1"}
-
-    REQUEST_ID_HEADER: str = "X-Request-ID"
-
-    class Config:
-        env_file = ".env"
-        extra = "ignore"
-
-
-settings = Settings()

app/core/constants.py

@@ -1 +0,0 @@
-# No specific constants required for the current implementation.

app/core/exceptions.py

@@ -1,5 +0,0 @@
-from fastapi import HTTPException, status
-
-class FileServiceException(HTTPException):
-    def __init__(self, status_code: int, detail: str):
-        super().__init__(status_code=status_code, detail=detail)

app/core/logger.py

@@ -1,26 +0,0 @@
-import logging
-import sys
-from functools import lru_cache
-
-
-LOG_FORMAT = "%(asctime)s | %(levelname)-8s | %(name)s | %(message)s"
-DATE_FORMAT = "%Y-%m-%dT%H:%M:%S"
-
-
-@lru_cache(maxsize=None)
-def get_logger(name: str) -> logging.Logger:
-    logger = logging.getLogger(name)
-
-    if logger.handlers:
-        return logger
-
-    logger.setLevel(logging.DEBUG)
-
-    handler = logging.StreamHandler(sys.stdout)
-    handler.setLevel(logging.DEBUG)
-    handler.setFormatter(logging.Formatter(fmt=LOG_FORMAT, datefmt=DATE_FORMAT))
-
-    logger.addHandler(handler)
-    logger.propagate = False
-
-    return logger

app/db/session.py

@@ -1,59 +0,0 @@
-from datetime import datetime, timezone
-from typing import AsyncGenerator
-
-from sqlalchemy import Column, DateTime, Integer, String
-from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
-from sqlalchemy.orm import DeclarativeBase
-
-from app.core.config import settings
-
-_async_url = settings.DATABASE_URL.replace("sqlite:///", "sqlite+aiosqlite:///")
-
-_engine = create_async_engine(
-    _async_url,
-    connect_args={"check_same_thread": False},
-    pool_pre_ping=True,
-    echo=False,
-)
-
-_AsyncSessionLocal = async_sessionmaker(
-    bind=_engine,
-    class_=AsyncSession,
-    expire_on_commit=False,
-    autoflush=False,
-    autocommit=False,
-)
-
-
-class _Base(DeclarativeBase):
-    pass
-
-
-class FileRecord(_Base):
-    __tablename__ = "files"
-
-    id = Column(Integer, primary_key=True, index=True, autoincrement=True)
-    fileid = Column(String, unique=True, index=True, nullable=False)
-    filename = Column(String, nullable=False)
-    file_url = Column(String, nullable=False)
-    createdat = Column(
-        DateTime(timezone=True),
-        default=lambda: datetime.now(timezone.utc),
-        nullable=False,
-    )
-    updatedat = Column(
-        DateTime(timezone=True),
-        default=lambda: datetime.now(timezone.utc),
-        onupdate=lambda: datetime.now(timezone.utc),
-        nullable=False,
-    )
-
-
-async def init_db() -> None:
-    async with _engine.begin() as conn:
-        await conn.run_sync(_Base.metadata.create_all)
-
-
-async def get_db() -> AsyncGenerator[AsyncSession, None]:
-    async with _AsyncSessionLocal() as session:
-        yield session

app/main.py

@@ -1,118 +0,0 @@
-import shutil
-from contextlib import asynccontextmanager
-
-from fastapi import Depends, FastAPI, HTTPException, Query, Request
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.middleware.trustedhost import TrustedHostMiddleware
-from fastapi.responses import FileResponse, Response
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.core.config import settings
-from app.core.logger import get_logger
-from app.db.session import FileRecord, get_db, init_db
-from app.middleware.allowed_methods import AllowedMethodsMiddleware
-from app.middleware.auth import AuthMiddleware
-from app.middleware.ip_filter import IPFilterMiddleware
-from app.middleware.logging import LoggingMiddleware
-from app.middleware.rate_limit import RateLimitMiddleware
-from app.middleware.request_id import RequestIDMiddleware
-from app.middleware.request_size import RequestSizeLimitMiddleware
-from app.middleware.security_headers import SecurityHeadersMiddleware
-from app.routers import files, ping
-from app.services.file_service import file_service
-
-logger = get_logger(__name__)
-
-
-def _get_storage_info() -> dict:
-    total, used, free = shutil.disk_usage("/")
-    gb = 2**30
-    return {
-        "total_gb": round(total / gb, 2),
-        "used_gb": round(used / gb, 2),
-        "free_gb": round(free / gb, 2),
-        "percent_used": f"{(used / total) * 100:.2f}%",
-    }
-
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    await init_db()
-    storage = _get_storage_info()
-    logger.info(
-        "Storage: %sGB free of %sGB (%s used)",
-        storage["free_gb"],
-        storage["total_gb"],
-        storage["percent_used"],
-    )
-    yield
-
-
-app = FastAPI(
-    title=settings.APP_NAME,
-    version=settings.APP_VERSION,
-    lifespan=lifespan,
-)
-
-app.add_middleware(RequestIDMiddleware)
-app.add_middleware(LoggingMiddleware)
-app.add_middleware(SecurityHeadersMiddleware)
-app.add_middleware(IPFilterMiddleware)
-app.add_middleware(RateLimitMiddleware)
-app.add_middleware(RequestSizeLimitMiddleware)
-app.add_middleware(AllowedMethodsMiddleware)
-app.add_middleware(AuthMiddleware)
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=settings.ALLOWED_ORIGINS,
-    allow_credentials=True,
-    allow_methods=list(settings.ALLOWED_METHODS),
-    allow_headers=["Authorization", "X-API-Key", "Content-Type", "X-Request-ID"],
-    expose_headers=["X-Request-ID", "Content-Length", "Content-Type", "Accept-Ranges"],
-)
-
-app.add_middleware(
-    TrustedHostMiddleware,
-    allowed_hosts=["*"],
-)
-
-app.include_router(ping.router, tags=["ping"])
-app.include_router(files.router, prefix="/api/v1/files", tags=["files"])
-
-
-@app.api_route("/v1/getfile", methods=["GET", "HEAD"])
-async def serve_file(
-    request: Request,
-    fileid: str = Query(..., description="UUID of the file to serve"),
-    db: AsyncSession = Depends(get_db),
-):
-    result = await db.execute(select(FileRecord).where(FileRecord.fileid == fileid))
-    db_record = result.scalar_one_or_none()
-    if not db_record:
-        logger.warning("File not found in database: %s", fileid)
-        raise HTTPException(status_code=404, detail="File not found")
-
-    file_path = file_service.get_file_path(fileid)
-    mime_type = file_service.get_mime_type(db_record.filename) or "application/octet-stream"
-    file_size = file_path.stat().st_size
-
-    base_headers = {
-        "Content-Disposition": f'inline; filename="{db_record.filename}"',
-        "Content-Length": str(file_size),
-        "Accept-Ranges": "bytes",
-    }
-
-    if request.method == "HEAD":
-        return Response(
-            status_code=200,
-            headers={**base_headers, "Content-Type": mime_type},
-        )
-
-    logger.info("Serving file: %s (%s)", db_record.filename, fileid)
-    return FileResponse(
-        path=file_path,
-        media_type=mime_type,
-        headers=base_headers,
-    )

app/middleware/allowed_methods.py

@@ -1,15 +0,0 @@
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.requests import Request
-from starlette.responses import JSONResponse
-from app.core.config import settings
-
-
-class AllowedMethodsMiddleware(BaseHTTPMiddleware):
-    async def dispatch(self, request: Request, call_next):
-        if request.method not in settings.ALLOWED_METHODS:
-            return JSONResponse(
-                status_code=405,
-                content={"detail": f"Method '{request.method}' is not allowed."},
-                headers={"Allow": ", ".join(settings.ALLOWED_METHODS)},
-            )
-        return await call_next(request)

app/middleware/auth.py

@@ -1,21 +0,0 @@
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.requests import Request
-from starlette.responses import JSONResponse
-from app.core.config import settings
-from app.core.logger import get_logger
-
-logger = get_logger(__name__)
-
-class AuthMiddleware(BaseHTTPMiddleware):
-    async def dispatch(self, request: Request, call_next):
-        if request.method == "POST" and ("/api/v1/files/upload" in request.url.path or "/api/v1/files/bulk-upload" in request.url.path):
-            api_key = request.headers.get("X-API-Key")
-            if not api_key or api_key not in settings.VALID_API_KEYS:
-                logger.warning(f"Unauthorized access attempt to {request.url.path}")
-                return JSONResponse(
-                    status_code=401,
-                    content={"detail": "Invalid or missing API key."},
-                )
-            logger.info(f"Authorized access to {request.url.path}")
-        
-        return await call_next(request)

app/middleware/ip_filter.py

@@ -1,23 +0,0 @@
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.requests import Request
-from starlette.responses import JSONResponse
-from app.core.config import settings
-
-
-class IPFilterMiddleware(BaseHTTPMiddleware):
-    async def dispatch(self, request: Request, call_next):
-        client_ip = self._resolve_client_ip(request)
-
-        if settings.IP_BLACKLIST and client_ip in settings.IP_BLACKLIST:
-            return JSONResponse(status_code=403, content={"detail": "Access denied."})
-
-        if settings.IP_WHITELIST and client_ip not in settings.IP_WHITELIST:
-            return JSONResponse(status_code=403, content={"detail": "Access denied."})
-
-        return await call_next(request)
-
-    def _resolve_client_ip(self, request: Request) -> str:
-        forwarded_for = request.headers.get("X-Forwarded-For")
-        if forwarded_for:
-            return forwarded_for.split(",")[0].strip()
-        return request.client.host if request.client else "unknown"

app/middleware/logging.py

@@ -1,33 +0,0 @@
-import time
-import logging
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.requests import Request
-from starlette.responses import Response
-
-logger = logging.getLogger("fileserver.access")
-
-
-class LoggingMiddleware(BaseHTTPMiddleware):
-    async def dispatch(self, request: Request, call_next) -> Response:
-        start = time.perf_counter()
-        response = await call_next(request)
-        duration_ms = (time.perf_counter() - start) * 1000
-
-        client_ip = getattr(request.state, "client_ip", None) or (
-            request.client.host if request.client else "unknown"
-        )
-        request_id = getattr(request.state, "request_id", "-")
-        auth_method = getattr(request.state, "auth_method", "none")
-
-        logger.info(
-            "%s %s %s | ip=%s | req_id=%s | auth=%s | %.2fms",
-            request.method,
-            request.url.path,
-            response.status_code,
-            client_ip,
-            request_id,
-            auth_method,
-            duration_ms,
-        )
-
-        return response

app/middleware/rate_limit.py

@@ -1,93 +0,0 @@
-import logging
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.requests import Request
-from starlette.responses import JSONResponse
-import redis.asyncio as aioredis
-from app.core.config import settings
-
-logger = logging.getLogger(__name__)
-
-SLIDING_WINDOW_LUA = """
-local key       = KEYS[1]
-local now       = tonumber(ARGV[1])
-local window_ms = tonumber(ARGV[2])
-local limit     = tonumber(ARGV[3])
-local cutoff    = now - window_ms
-
-redis.call("ZREMRANGEBYSCORE", key, "-inf", cutoff)
-
-local count = redis.call("ZCARD", key)
-
-if count >= limit then
-    local oldest = redis.call("ZRANGE", key, 0, 0, "WITHSCORES")
-    local retry_at = 0
-    if oldest and oldest[2] then
-        retry_at = math.ceil((tonumber(oldest[2]) + window_ms - now) / 1000)
-    end
-    return {0, retry_at}
-end
-
-redis.call("ZADD", key, now, now .. "-" .. math.random(1, 1000000))
-redis.call("PEXPIRE", key, window_ms)
-
-return {1, 0}
-"""
-
-EXEMPT_PATHS = {"/ping", "/api/v1/files/get"}
-
-
-class RateLimitMiddleware(BaseHTTPMiddleware):
-    def __init__(self, app):
-        super().__init__(app)
-        self._limit = settings.RATE_LIMIT_PER_MINUTE
-        self._window_ms = settings.RATE_LIMIT_WINDOW_SECONDS * 1000
-        self._key_prefix = settings.RATE_LIMIT_KEY_PREFIX
-        self._redis: aioredis.Redis = aioredis.from_url(
-            settings.REDIS_URL,
-            encoding="utf-8",
-            decode_responses=True,
-            socket_connect_timeout=2,
-            socket_timeout=2,
-        )
-        self._script = self._redis.register_script(SLIDING_WINDOW_LUA)
-
-    async def dispatch(self, request: Request, call_next):
-        if request.url.path in EXEMPT_PATHS:
-            return await call_next(request)
-
-        client_ip = (
-            getattr(request.state, "client_ip", None)
-            or request.headers.get("x-real-ip")
-            or (request.headers.get("x-forwarded-for", "").split(",")[0].strip() or None)
-            or (request.client.host if request.client else "unknown")
-        )
-
-        allowed, retry_after = await self._check(client_ip)
-
-        if not allowed:
-            return JSONResponse(
-                status_code=429,
-                content={"detail": "Too many requests. Please slow down."},
-                headers={"Retry-After": str(max(1, retry_after))},
-            )
-
-        return await call_next(request)
-
-    async def _check(self, client_ip: str) -> tuple[bool, int]:
-        import time
-
-        key = f"{self._key_prefix}:{client_ip}"
-        now_ms = int(time.time() * 1000)
-
-        try:
-            result = await self._script(
-                keys=[key],
-                args=[now_ms, self._window_ms, self._limit],
-            )
-            return bool(result[0]), int(result[1])
-        except Exception as exc:
-            logger.error("Rate limiter Redis error — failing open: %s", exc)
-            return True, 0
-
-    async def close(self):
-        await self._redis.aclose()

app/middleware/request_id.py

@@ -1,13 +0,0 @@
-import uuid
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.requests import Request
-from starlette.responses import Response
-
-
-class RequestIDMiddleware(BaseHTTPMiddleware):
-    async def dispatch(self, request: Request, call_next) -> Response:
-        request_id = request.headers.get("X-Request-ID") or str(uuid.uuid4())
-        request.state.request_id = request_id
-        response = await call_next(request)
-        response.headers["X-Request-ID"] = request_id
-        return response

app/middleware/request_size.py

@@ -1,22 +0,0 @@
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.requests import Request
-from starlette.responses import JSONResponse
-from app.core.config import settings
-
-
-class RequestSizeLimitMiddleware(BaseHTTPMiddleware):
-    async def dispatch(self, request: Request, call_next):
-        content_length = request.headers.get("Content-Length")
-
-        if content_length:
-            size_bytes = int(content_length)
-            max_bytes = settings.MAX_FILE_SIZE_MB * 1024 * 1024
-            if size_bytes > max_bytes:
-                return JSONResponse(
-                    status_code=413,
-                    content={
-                        "detail": f"Request body exceeds maximum allowed size of {settings.MAX_FILE_SIZE_MB}MB."
-                    },
-                )
-
-        return await call_next(request)

app/middleware/security_headers.py

@@ -1,27 +0,0 @@
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.requests import Request
-from starlette.responses import Response
-
-
-class SecurityHeadersMiddleware(BaseHTTPMiddleware):
-    async def dispatch(self, request: Request, call_next) -> Response:
-        response = await call_next(request)
-        response.headers["Strict-Transport-Security"] = "max-age=63072000; includeSubDomains; preload"
-        response.headers["X-Content-Type-Options"] = "nosniff"
-        # response.headers["X-Frame-Options"] = "DENY"
-        response.headers["X-XSS-Protection"] = "1; mode=block"
-        response.headers["Referrer-Policy"] = "strict-origin-when-cross-origin"
-        response.headers["Permissions-Policy"] = "geolocation=(), microphone=(), camera=()"
-        # Relax CSP for file rendering (e.g., PDFs and images)
-        response.headers["Content-Security-Policy"] = (
-            "default-src 'self'; "
-            "script-src 'self'; "
-            "style-src 'self'; "
-            "img-src 'self' data: *; "
-            "object-src 'self' *;"
-        )
-        # For file serving, we might want to allow caching, but for now we just ensure it doesn't force download
-        if not request.url.path.startswith("/v1/getfile"):
-            response.headers["Cache-Control"] = "no-store"
-            response.headers["Pragma"] = "no-cache"
-        return response

app/models/schemas.py

@@ -1,32 +0,0 @@
-from datetime import datetime
-from typing import List, Optional
-from pydantic import BaseModel
-
-
-class FileInfo(BaseModel):
-    id: int
-    fileid: str
-    filename: str
-    file_url: str
-    createdat: datetime
-    updatedat: datetime
-
-    class Config:
-        from_attributes = True
-
-
-class UploadResponse(BaseModel):
-    success: bool
-    data: Optional[FileInfo] = None
-
-
-class FileListResponse(BaseModel):
-    success: bool
-    total: int
-    items: List[FileInfo]
-
-
-class DeleteResponse(BaseModel):
-    success: bool
-    message: str
-    fileid: str

app/routers/files.py

@@ -1,83 +0,0 @@
-from typing import List
-
-from fastapi import APIRouter, Depends, File, HTTPException, Query, Request, UploadFile
-from fastapi.responses import FileResponse, Response
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.db.session import FileRecord, get_db
-from app.models.schemas import DeleteResponse, FileInfo, FileListResponse, UploadResponse
-from app.services.file_service import file_service
-
-router = APIRouter()
-
-
-@router.post("/upload", response_model=UploadResponse, status_code=201)
-async def upload_file(
-    file: UploadFile = File(...),
-    db: AsyncSession = Depends(get_db),
-) -> UploadResponse:
-    return await file_service.upload_file(db, file)
-
-
-@router.post("/bulk-upload", response_model=List[UploadResponse], status_code=201)
-async def bulk_upload_files(
-    files: List[UploadFile] = File(...),
-    db: AsyncSession = Depends(get_db),
-) -> List[UploadResponse]:
-    return await file_service.bulk_upload_files(db, files)
-
-
-@router.get("/all", response_model=FileListResponse)
-async def list_files(db: AsyncSession = Depends(get_db)) -> FileListResponse:
-    return await file_service.list_files(db)
-
-
-@router.get("/get", response_model=FileInfo)
-async def get_file_info(
-    fileid: str = Query(..., description="UUID of the uploaded file"),
-    db: AsyncSession = Depends(get_db),
-) -> FileInfo:
-    return await file_service.get_file_info(db, fileid)
-
-
-@router.delete("/", response_model=DeleteResponse)
-async def delete_file(
-    fileid: str = Query(..., description="UUID of the file to delete"),
-    db: AsyncSession = Depends(get_db),
-) -> DeleteResponse:
-    return await file_service.delete_file(db, fileid)
-
-
-@router.api_route("/getfile", methods=["GET", "HEAD"])
-async def serve_file(
-    request: Request,
-    fileid: str = Query(..., description="UUID of the file to serve"),
-    db: AsyncSession = Depends(get_db),
-):
-    result = await db.execute(select(FileRecord).where(FileRecord.fileid == fileid))
-    db_record = result.scalar_one_or_none()
-    if not db_record:
-        raise HTTPException(status_code=404, detail="File not found")
-
-    file_path = file_service.get_file_path(fileid)
-    mime_type = file_service.get_mime_type(db_record.filename) or "application/octet-stream"
-    file_size = file_path.stat().st_size
-
-    base_headers = {
-        "Content-Disposition": f'inline; filename="{db_record.filename}"',
-        "Content-Length": str(file_size),
-        "Accept-Ranges": "bytes",
-    }
-
-    if request.method == "HEAD":
-        return Response(
-            status_code=200,
-            headers={**base_headers, "Content-Type": mime_type},
-        )
-
-    return FileResponse(
-        path=file_path,
-        media_type=mime_type,
-        headers=base_headers,
-    )

app/routers/ping.py

@@ -1,22 +0,0 @@
-from fastapi import APIRouter
-from fastapi.responses import JSONResponse
-from app.core.config import settings
-
-router = APIRouter()
-
-
-@router.get("/", tags=["root"])
-async def root():
-    return JSONResponse(
-        content={
-            "service": settings.APP_NAME,
-            "version": settings.APP_VERSION,
-            "status": "online",
-            "docs": "/docs"
-        }
-    )
-
-
-@router.get("/ping", tags=["ping"])
-async def ping():
-    return {"message": f"{settings.APP_NAME} is running..."}

app/services/file_service.py

@@ -1,179 +0,0 @@
-import uuid
-import mimetypes
-from pathlib import Path
-
-import aiofiles
-import aiofiles.os
-from fastapi import HTTPException, UploadFile
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.core.config import settings
-from app.core.logger import get_logger
-from app.db.session import FileRecord
-from app.models.schemas import DeleteResponse, FileInfo, FileListResponse, UploadResponse
-
-logger = get_logger(__name__)
-
-
-class FileService:
-    RENDERABLE_MIME_TYPES: dict[str, str] = {
-        ".png": "image/png",
-        ".jpg": "image/jpeg",
-        ".jpeg": "image/jpeg",
-        ".gif": "image/gif",
-        ".webp": "image/webp",
-        ".svg": "image/svg+xml",
-        ".apng": "image/apng",
-        ".avif": "image/avif",
-        ".bmp": "image/bmp",
-        ".ico": "image/vnd.microsoft.icon",
-        ".tif": "image/tiff",
-        ".tiff": "image/tiff",
-        ".aac": "audio/aac",
-        ".mp3": "audio/mpeg",
-        ".oga": "audio/ogg",
-        ".ogg": "audio/ogg",
-        ".wav": "audio/wav",
-        ".weba": "audio/webm",
-        ".midi": "audio/midi",
-        ".mid": "audio/midi",
-        ".mp4": "video/mp4",
-        ".mpeg": "video/mpeg",
-        ".ogv": "video/ogg",
-        ".webm": "video/webm",
-        ".ts": "video/mp2t",
-        ".pdf": "application/pdf",
-        ".txt": "text/plain",
-        ".html": "text/html",
-        ".htm": "text/html",
-        ".css": "text/css",
-        ".js": "text/javascript",
-        ".json": "application/json",
-        ".jsonld": "application/ld+json",
-        ".md": "text/markdown",
-        ".xml": "application/xml",
-        ".xhtml": "application/xhtml+xml",
-        ".csv": "text/csv",
-        ".ics": "text/calendar",
-        ".otf": "font/otf",
-        ".ttf": "font/ttf",
-        ".woff": "font/woff",
-        ".woff2": "font/woff2",
-    }
-
-    def __init__(self) -> None:
-        self.files_dir = Path(settings.FILES_DIR)
-        self.files_dir.mkdir(parents=True, exist_ok=True)
-
-    def _generate_file_id(self) -> str:
-        return f"temp-{uuid.uuid4()}"
-
-    def _get_file_url(self, fileid: str) -> str:
-        return f"{settings.APP_BASE_URL}/v1/getfile?fileid={fileid}"
-
-    async def upload_file(self, db: AsyncSession, file: UploadFile) -> UploadResponse:
-        fileid = self._generate_file_id()
-        filename = file.filename
-        file_path = self.files_dir / fileid
-
-        logger.info("Starting file upload: %s", filename)
-
-        try:
-            async with aiofiles.open(file_path, "wb") as buffer:
-                while chunk := await file.read(1024 * 1024):
-                    await buffer.write(chunk)
-
-            logger.info("File saved to disk: %s", file_path)
-
-            file_url = self._get_file_url(fileid)
-            db_record = FileRecord(fileid=fileid, filename=filename, file_url=file_url)
-            db.add(db_record)
-            await db.commit()
-            await db.refresh(db_record)
-
-            logger.info("File record saved to database: %s", fileid)
-
-            return UploadResponse(success=True, data=FileInfo.from_orm(db_record))
-
-        except Exception as exc:
-            logger.error("Error during file upload: %s", str(exc))
-            if await aiofiles.os.path.exists(file_path):
-                await aiofiles.os.remove(file_path)
-            await db.rollback()
-            raise HTTPException(status_code=500, detail="Internal server error during file upload")
-
-    async def bulk_upload_files(self, db: AsyncSession, files: list[UploadFile]) -> list[UploadResponse]:
-        responses: list[UploadResponse] = []
-        for file in files:
-            try:
-                response = await self.upload_file(db, file)
-                responses.append(response)
-            except HTTPException as exc:
-                logger.error("Failed to upload file %s: %s", file.filename, exc.detail)
-                responses.append(UploadResponse(success=False, data=None))
-            except Exception as exc:
-                logger.error("Unexpected error during bulk upload for file %s: %s", file.filename, str(exc))
-                responses.append(UploadResponse(success=False, data=None))
-        return responses
-
-    async def get_file_info(self, db: AsyncSession, fileid: str) -> FileInfo:
-        logger.info("Fetching file info: %s", fileid)
-        result = await db.execute(select(FileRecord).where(FileRecord.fileid == fileid))
-        db_record = result.scalar_one_or_none()
-        if not db_record:
-            logger.warning("File not found in database: %s", fileid)
-            raise HTTPException(status_code=404, detail="File not found")
-        return FileInfo.from_orm(db_record)
-
-    async def list_files(self, db: AsyncSession) -> FileListResponse:
-        logger.info("Listing all files")
-        result = await db.execute(select(FileRecord))
-        records = result.scalars().all()
-        items = [FileInfo.from_orm(r) for r in records]
-        return FileListResponse(success=True, total=len(items), items=items)
-
-    async def delete_file(self, db: AsyncSession, fileid: str) -> DeleteResponse:
-        logger.info("Starting file deletion: %s", fileid)
-        result = await db.execute(select(FileRecord).where(FileRecord.fileid == fileid))
-        db_record = result.scalar_one_or_none()
-        if not db_record:
-            logger.warning("File not found for deletion: %s", fileid)
-            raise HTTPException(status_code=404, detail="File not found")
-
-        file_path = self.files_dir / fileid
-        try:
-            if await aiofiles.os.path.exists(file_path):
-                await aiofiles.os.remove(file_path)
-                logger.info("File removed from disk: %s", file_path)
-
-            await db.delete(db_record)
-            await db.commit()
-            logger.info("File record removed from database: %s", fileid)
-
-            return DeleteResponse(success=True, message="File deleted successfully", fileid=fileid)
-
-        except Exception as exc:
-            logger.error("Error during file deletion: %s", str(exc))
-            await db.rollback()
-            raise HTTPException(status_code=500, detail="Internal server error during file deletion")
-
-    def get_file_path(self, fileid: str) -> Path:
-        file_path = self.files_dir / fileid
-        if not file_path.exists():
-            logger.warning("File path does not exist: %s", file_path)
-            raise HTTPException(status_code=404, detail="File not found on disk")
-        return file_path
-
-    def get_mime_type(self, filename: str) -> str:
-        extension = Path(filename).suffix.lower()
-        if extension in self.RENDERABLE_MIME_TYPES:
-            return self.RENDERABLE_MIME_TYPES[extension]
-        mime_type, _ = mimetypes.guess_type(filename)
-        if mime_type:
-            return mime_type
-        return "application/octet-stream"
-
-
-file_service = FileService()
-

requirements.txt

@@ -1,13 +0,0 @@
-fastapi==0.115.0
-uvicorn[standard]==0.30.6
-python-multipart==0.0.9
-pydantic-settings==2.5.2
-aiofiles==24.1.0
-pyJWT==2.10.1
-sqlalchemy==2.0.25
-aiosqlite==0.20.0
-python-dotenv==1.0.0
-httpx>=0.27.0
-redis[hiredis]==6.2.0
-pyfiglet==1.0.2
-rich==14.1.0

start.sh

@@ -1,9 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-python - <<EOF
-from app.banner import print_banner
-print_banner()
-EOF
-
-exec uvicorn app.main:app --host 0.0.0.0 --port 7860 --workers 4