Upload 22 files

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.9
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirements.txt
+
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+COPY ./app /code/app
+COPY ./app.py /code/app.py
+
+CMD ["python", "app.py"]

app/__init__.py

@@ -0,0 +1,15 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+def create_app() -> FastAPI:
+    app = FastAPI(title="File Sharing API")
+
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=[""],
+        allow_credentials=True,
+        allow_methods=[""],
+        allow_headers=["*"],
+    )
+
+    return app

app/config.py

@@ -0,0 +1,17 @@
+from pydantic_settings import BaseSettings
+from functools import lru_cache
+
+class Settings(BaseSettings):
+    APPWRITE_ENDPOINT: str
+    APPWRITE_PROJECT_ID: str
+    APPWRITE_API_KEY: str
+    APPWRITE_BUCKET_ID: str
+
+    class Config:
+        env_file = ".env"
+
+@lru_cache()
+def get_settings() -> Settings:
+    return Settings()
+
+settings = get_settings()

app/main.py

@@ -0,0 +1,25 @@
+from fastapi import FastAPI
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from .routes import file_routes
+from . import create_app
+from .services.storage_service import StorageService
+
+app = create_app()
+storage_service = StorageService()
+
+# Register routes
+app.include_router(file_routes.router, prefix="/api")
+
+# Set up scheduler for cleanup
+scheduler = AsyncIOScheduler()
+scheduler.add_job(storage_service.cleanup_expired_files, 'interval', minutes=1)  # Run every 5 minutes
+scheduler.start()
+
+@app.get("/")
+async def root():
+    return {"message": "File Sharing API with auto-cleanup"}
+
+# Handle shutdown
+@app.on_event("shutdown")
+async def shutdown_event():
+    scheduler.shutdown()

app/routes/file_routes.py

@@ -0,0 +1,28 @@
+from fastapi import APIRouter, File, UploadFile, Query
+from fastapi.responses import JSONResponse
+from enum import Enum
+from ..services.storage_service import StorageService
+
+router = APIRouter()
+storage_service = StorageService()
+
+class ExpirationTime(str, Enum):
+    THIRTY_SECONDS = "30s"
+    ONE_DAY = "24h"
+    THREE_DAYS = "3d"
+    FIVE_DAYS = "5d"
+    ONE_WEEK = "7d"
+
+@router.post("/upload")
+async def upload_file(
+    file: UploadFile = File(...),
+    expiration: ExpirationTime = Query(..., description="File expiration time")
+):
+    result = await storage_service.upload_file(file, expiration)
+    return JSONResponse(
+        content={
+            'message': 'File uploaded successfully',
+            'data': result
+        },
+        status_code=200
+    )

app/services/storage_service.py

@@ -0,0 +1,112 @@
+from appwrite.client import Client
+from appwrite.services.storage import Storage
+from appwrite.input_file import InputFile
+from appwrite.exception import AppwriteException
+from fastapi import UploadFile, HTTPException
+from datetime import datetime, timedelta
+import uuid
+import os
+from typing import Dict, Any
+from ..config import settings
+from ..utils.validators import validate_file_extension, validate_file_size
+
+class StorageService:
+    def __init__(self):
+        try:
+            self.client = Client()
+            self.client.set_endpoint(settings.APPWRITE_ENDPOINT)
+            self.client.set_project(settings.APPWRITE_PROJECT_ID)
+            self.client.set_key(settings.APPWRITE_API_KEY)
+            self.storage = Storage(self.client)
+        except Exception as e:
+            raise HTTPException(
+                status_code=500,
+                detail=f"Failed to initialize storage service: {str(e)}"
+            )
+
+    def _get_expiration_seconds(self, expiration_time: str) -> int:
+        expiration_map = {
+            "30s": 30,
+            "24h": 86400,
+            "3d": 259200,
+            "5d": 432000,
+            "7d": 604800
+        }
+        return expiration_map.get(expiration_time, 86400)
+
+    async def upload_file(self, file: UploadFile, expiration_time: str) -> Dict[str, Any]:
+        try:
+            validate_file_extension(file.filename)
+            contents = await file.read()
+            validate_file_size(len(contents))
+
+            _, ext = os.path.splitext(file.filename)
+            file_id = f"{uuid.uuid4().hex[:8]}{ext}"
+            
+            expiration_seconds = self._get_expiration_seconds(expiration_time)
+            expiration = datetime.now() + timedelta(seconds=expiration_seconds)
+            
+            result = self.storage.create_file(
+                bucket_id=settings.APPWRITE_BUCKET_ID,
+                file_id=file_id,
+                file=InputFile.from_bytes(contents, file.filename),
+                permissions=['read("any")']
+            )
+            
+            new_file_name = f"{file_id}__exp_{expiration.isoformat()}"
+            self.storage.update_file(
+                bucket_id=settings.APPWRITE_BUCKET_ID,
+                file_id=file_id,
+                name=new_file_name,
+                permissions=['read("any")']
+            )
+
+            url = f"{settings.APPWRITE_ENDPOINT}/storage/buckets/{settings.APPWRITE_BUCKET_ID}/files/{file_id}/view?project={settings.APPWRITE_PROJECT_ID}"
+            
+            return {
+                'file_id': file_id,
+                'url': url,
+                'expiration': expiration.isoformat(),
+                'original_name': file.filename
+            }
+
+        except HTTPException as e:
+            raise e
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Unexpected error: {str(e)}")
+        finally:
+            await file.seek(0)
+
+    async def cleanup_expired_files(self):
+        try:
+            files = self.storage.list_files(settings.APPWRITE_BUCKET_ID)
+            now = datetime.now()
+            
+            for file in files['files']:
+                try:
+                    file_name = file['name']
+                    if '__exp_' in file_name:
+                        _, exp_str = file_name.split('__exp_')
+                        expiration = datetime.fromisoformat(exp_str)
+                        if now > expiration:
+                            self.storage.delete_file(
+                                bucket_id=settings.APPWRITE_BUCKET_ID,
+                                file_id=file['$id']
+                            )
+                            print(f"Deleted expired file: {file['$id']}")
+                except Exception as e:
+                    print(f"Error processing file {file['$id']}: {str(e)}")
+                    continue
+
+        except Exception as e:
+            print(f"Error during cleanup: {str(e)}")
+
+    async def get_file_info(self, file_id: str) -> Dict[str, Any]:
+        try:
+            file = self.storage.get_file(
+                bucket_id=settings.APPWRITE_BUCKET_ID,
+                file_id=file_id
+            )
+            return file
+        except AppwriteException as e:
+            raise HTTPException(status_code=404, detail="File not found")

app/utils/validators.py

@@ -0,0 +1,23 @@
+from fastapi import HTTPException
+from typing import List
+
+ALLOWED_EXTENSIONS = {'.pdf', '.doc', '.docx', '.txt', '.jpg', '.jpeg', '.png', '.gif', '.mp3', '.mp4', '.mov', '.zip', '.rar'}
+MAX_FILE_SIZE = 50 * 1024 * 1024  # 10MB
+
+def validate_file_extension(filename: str) -> bool:
+    import os
+    ext = os.path.splitext(filename)[1].lower()
+    if ext not in ALLOWED_EXTENSIONS:
+        raise HTTPException(
+            status_code=400,
+            detail=f"File extension not allowed. Allowed extensions: {', '.join(ALLOWED_EXTENSIONS)}"
+        )
+    return True
+
+def validate_file_size(file_size: int) -> bool:
+    if file_size > MAX_FILE_SIZE:
+        raise HTTPException(
+            status_code=400,
+            detail=f"File too large. Maximum size allowed: {MAX_FILE_SIZE/1024/1024}MB"
+        )
+    return True