Delete app

app/__init__.py

@@ -1,15 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,112 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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