Upload folder using huggingface_hub

.gitignore

@@ -8,4 +8,6 @@ __pycache__
 llm_documentation.md
 
 # enironment variable
-.env
+.env
+
+uploaded_files

app/main.py

@@ -21,6 +21,11 @@ from app.routers.security import password_generator
 # ==========================
 from app.routers.auth import system as auth_system
 
+# ==========================
+# ☁️ Cloud Drive Module (NEW)
+# ==========================
+from app.routers.drive import storage
+
 # ==========================
 # 🧪 Test Utilities
 # ==========================
@@ -45,6 +50,7 @@ app.include_router(random_number_generator.router)    # Random number tester
 app.include_router(help.router)                       # Helper/test info
 app.include_router(calculator.router)                 # Mini calculator service
 app.include_router(auth_system.router)                # <-- NEW AUTH SYSTEM
+app.include_router(storage.router)                    # new cloud drive support
 app.include_router(server_status.router)              # function to check the system
 
 

app/routers/drive/storage.py

@@ -0,0 +1,177 @@
+import shutil
+import os
+import asyncio
+from fastapi import (
+    APIRouter, 
+    UploadFile, 
+    File, 
+    HTTPException, 
+    Header, 
+    status, 
+    Depends, 
+    WebSocket, 
+    WebSocketDisconnect
+)
+
+# Import Auth System
+from app.routers.auth.system import get_current_user 
+
+# Router Configuration
+router = APIRouter(
+    prefix="/drive",
+    tags=["Cloud Drive"]
+)
+
+# Settings
+UPLOAD_DIR = "uploaded_files"
+MAX_FILE_SIZE = 1 * 1024 * 1024 * 1024  # 1GB Limit
+
+# 🔐 Auth Toggle
+AUTH_ENABLED = False  # <<< set False to disable authentication
+
+# Auth Wrapper (returns dependency or None)
+def auth_dependency():
+    return Depends(get_current_user) if AUTH_ENABLED else None
+
+# Ensure the upload directory exists
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+
+# ==========================================
+# 🛠️ Helper: Safe Username Extraction
+# ==========================================
+def get_safe_username(user_obj):
+    if not user_obj:
+        return "anonymous"
+    if hasattr(user_obj, "username"):
+        return user_obj.username
+    return user_obj.get("username", "anonymous")
+
+
+# ==========================================
+# 📤 Standard File Upload
+# ==========================================
+@router.post("/upload/")
+async def upload_file(
+    file: UploadFile = File(...),
+    content_length: int = Header(None),
+    current_user: object = auth_dependency()
+):
+    if content_length and content_length > MAX_FILE_SIZE:
+        raise HTTPException(
+            status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
+            detail="File is too large. Maximum limit is 1GB."
+        )
+
+    username = get_safe_username(current_user)
+    file_path = os.path.join(UPLOAD_DIR, file.filename)
+
+    try:
+        with open(file_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Internal Server Error: {str(e)}")
+    finally:
+        file.file.close()
+
+    return {
+        "user": username,
+        "filename": file.filename,
+        "path": file_path,
+        "message": "File uploaded successfully"
+    }
+
+
+# ==========================================
+# 🚀 Remote Upload (Aria2)
+# ==========================================
+@router.post("/remote-upload/")
+async def remote_url_upload(
+    url: str,
+    custom_filename: str = None,
+    current_user: object = auth_dependency()
+):
+    username = get_safe_username(current_user)
+
+    command = ["aria2c", "-x", "6", "-s", "6", "-d", UPLOAD_DIR, url]
+    if custom_filename:
+        command.extend(["-o", custom_filename])
+
+    try:
+        process = await asyncio.create_subprocess_exec(
+            *command,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+        stdout, stderr = await process.communicate()
+
+        if process.returncode != 0:
+            raise HTTPException(status_code=500, detail=f"Aria2 Error: {stderr.decode()}")
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"System Error: {str(e)}")
+
+    return {
+        "user": username,
+        "source": url,
+        "filename": custom_filename or "Auto-detected",
+        "message": "Download completed via Aria2"
+    }
+
+
+# ==========================================
+# 📡 WebSocket Remote Upload (No Auth Applied)
+# ==========================================
+@router.websocket("/ws/remote-upload/")
+async def websocket_remote_upload(websocket: WebSocket):
+    await websocket.accept()
+    
+    try:
+        data = await websocket.receive_json()
+        target_url = data.get("url")
+        custom_filename = data.get("filename")
+
+        if not target_url:
+            await websocket.send_text("❌ Error: No URL provided.")
+            await websocket.close()
+            return
+
+        command = ["aria2c", "-x", "6", "-s", "6", "-d", UPLOAD_DIR, target_url]
+        if custom_filename:
+            command.extend(["-o", custom_filename])
+
+        await websocket.send_text(f"🚀 Starting download: {target_url}")
+
+        process = await asyncio.create_subprocess_exec(
+            *command,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+
+        while True:
+            line = await process.stdout.readline()
+            if not line:
+                if process.returncode is not None:
+                    break
+                await asyncio.sleep(0.1)
+                continue
+
+            decoded_line = line.decode().strip()
+            if decoded_line:
+                await websocket.send_text(decoded_line)
+
+        await process.wait()
+        if process.returncode == 0:
+            await websocket.send_text("✅ Download Complete.")
+        else:
+            await websocket.send_text("❌ Download Failed.")
+
+        await websocket.close()
+
+    except WebSocketDisconnect:
+        print("WS: Client disconnected")
+    except Exception as e:
+        try:
+            await websocket.send_text(f"🔥 Critical Error: {str(e)}")
+            await websocket.close()
+        except:
+            pass

app/routers/image/jpgcompressor.py

@@ -3,7 +3,6 @@ from fastapi.responses import StreamingResponse
 from PIL import Image
 from io import BytesIO
 
-
 # ==========================
 # 🖼️ Image Processing Router
 # ==========================
@@ -12,54 +11,126 @@ router = APIRouter(
     tags=["Image Processing"]
 )
 
-
 # ==========================
-# 📦 JPG Compression Endpoint
+# 📦 JPG Target Size Endpoint
 # ==========================
-@router.post("/compress_jpg")
-async def compress_jpg(
+@router.post("/compress_jpg_to_size")
+async def compress_jpg_to_size(
     file: UploadFile = File(..., description="The JPG image file to compress."),
-    quality: int = Form(75, description="JPEG compression quality (1 to 100). Default is 75.")
+    target_size_kb: int = Form(..., description="Target file size in KB (e.g., 240).")
 ):
     """
-    🔧 Compresses a JPEG image at a specified quality and returns the optimized file.
+    🔧 Compresses a JPEG image to fit within a specific file size (in KB).
+    Uses binary search to find the best quality and, if necessary, resizes dimensions.
     """
 
     # --------------------------
     # 🛑 Validation Checks
     # --------------------------
-    if file.content_type != "image/jpeg":
+    if file.content_type not in ["image/jpeg", "image/jpg"]:
         raise HTTPException(
             status_code=400,
-            detail="Invalid file type. Only JPEG files are supported for this endpoint."
+            detail="Invalid file type. Only JPEG files are supported."
         )
 
-    if not 1 <= quality <= 100:
+    if target_size_kb <= 0:
         raise HTTPException(
             status_code=400,
-            detail="Quality must be an integer between 1 and 100."
+            detail="Target size must be greater than 0 KB."
         )
 
+    # Calculate target bytes
+    target_bytes = target_size_kb * 1024
+
     # --------------------------
     # 📥 Read Image Bytes
     # --------------------------
     content = await file.read()
-    input_buffer = BytesIO(content)
-    output_buffer = BytesIO()
+    
+    # ⚡ Optimization: If original is already smaller than target, return original
+    if len(content) <= target_bytes:
+        return StreamingResponse(
+            BytesIO(content),
+            media_type="image/jpeg",
+            headers={"Content-Disposition": f"attachment; filename=original_{file.filename}"}
+        )
 
+    input_buffer = BytesIO(content)
+    
     try:
+        img = Image.open(input_buffer)
+        
+        # Convert to RGB if necessary (e.g., if input was RGBA)
+        if img.mode != 'RGB':
+            img = img.convert('RGB')
+
+        output_buffer = BytesIO()
+        
         # --------------------------
-        # 🧪 Pillow Compression
+        # 📉 Binary Search Algorithm
         # --------------------------
-        img = Image.open(input_buffer)
-        img.save(output_buffer, "JPEG", quality=quality)
-        output_buffer.seek(0)
+        # We search for the best quality between 1 and 95
+        min_quality = 1
+        max_quality = 95
+        best_buffer = None
+        
+        while min_quality <= max_quality:
+            quality = (min_quality + max_quality) // 2
+            
+            # Clear buffer and save with current quality
+            output_buffer.seek(0)
+            output_buffer.truncate()
+            img.save(output_buffer, format="JPEG", quality=quality)
+            
+            size = output_buffer.tell()
+            
+            if size <= target_bytes:
+                # This fits! But can we get better quality?
+                best_buffer = BytesIO(output_buffer.getvalue()) # Store success
+                min_quality = quality + 1 # Try higher quality
+            else:
+                # Too big, reduce quality
+                max_quality = quality - 1
+
+        # --------------------------
+        # ⚠️ Fallback: Resize
+        # --------------------------
+        # If even quality=1 is too big, we must reduce image dimensions
+        if best_buffer is None:
+            resize_factor = 0.9
+            while True:
+                width, height = img.size
+                new_width = int(width * resize_factor)
+                new_height = int(height * resize_factor)
+                
+                # Stop if image gets too tiny (sanity check)
+                if new_width < 10 or new_height < 10:
+                    break
+                    
+                img = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
+                
+                output_buffer.seek(0)
+                output_buffer.truncate()
+                img.save(output_buffer, format="JPEG", quality=5) # Low quality + resize
+                
+                if output_buffer.tell() <= target_bytes:
+                    best_buffer = output_buffer
+                    break
+                
+                resize_factor *= 0.9 # Reduce size by another 10%
+
+        # If we still failed (extremely rare), just return the last attempt
+        if best_buffer is None:
+            output_buffer.seek(0)
+            best_buffer = output_buffer
+
+        best_buffer.seek(0)
 
         # --------------------------
         # 📤 Return as Stream
         # --------------------------
         return StreamingResponse(
-            output_buffer,
+            best_buffer,
             media_type="image/jpeg",
             headers={
                 "Content-Disposition": f"attachment; filename=compressed_{file.filename}"
@@ -67,10 +138,7 @@ async def compress_jpg(
         )
 
     except Exception as e:
-        # --------------------------
-        # 💥 Error Handling
-        # --------------------------
         raise HTTPException(
             status_code=500,
             detail=f"Image processing error: {e}"
-        )
+        )