Update app.py

app.py

@@ -22,9 +22,7 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# tasks = { "task_id": { ... } }
 tasks = {}
-
 DATA_DIR = "/data"
 os.makedirs(DATA_DIR, exist_ok=True)
 
@@ -38,16 +36,14 @@ async def cleanup_old_files():
             for filename in os.listdir(DATA_DIR):
                 filepath = os.path.join(DATA_DIR, filename)
                 if os.path.isfile(filepath):
-                    # 24 hours = 86400 seconds
                     if now - os.path.getmtime(filepath) > 86400:
                         os.remove(filepath)
-                        # Remove from tasks if exists
                         for tid, tinfo in list(tasks.items()):
                             if tinfo.get("file_path") == filepath:
                                 del tasks[tid]
         except Exception as e:
             print(f"Cleanup error: {e}")
-        await asyncio.sleep(3600) # Check every hour
+        await asyncio.sleep(3600)
 
 @app.on_event("startup")
 async def startup_event():
@@ -55,9 +51,7 @@ async def startup_event():
 
 async def download_file(task_id: str, url: str):
     file_path = tasks[task_id]["file_path"]
-    
     try:
-        # read_bufsize chota rakha hai taaki network cache RAM block na kare
         connector = aiohttp.TCPConnector(limit=10)
         async with aiohttp.ClientSession(connector=connector, read_bufsize=256 * 1024) as session:
             async with session.get(url, timeout=None) as response:
@@ -65,10 +59,8 @@ async def download_file(task_id: str, url: str):
                 total_size = int(response.headers.get('Content-Length', 0))
                 tasks[task_id]["total_size"] = total_size
                 
-                # Check for Content-Disposition header for filename
                 cd = response.headers.get('Content-Disposition')
                 if cd and 'filename=' in cd:
-                    # Extract filename from header
                     fname = re.findall('filename="([^"]+)"', cd)
                     if not fname:
                         fname = re.findall('filename=([^;]+)', cd)
@@ -86,7 +78,6 @@ async def download_file(task_id: str, url: str):
                 chunk_counter = 0
                 
                 with open(file_path, 'wb') as f:
-                    # Iter_chunked strictly allocated chunks ko read karega
                     async for chunk in response.content.iter_chunked(256 * 1024):
                         if not chunk:
                             break
@@ -102,13 +93,11 @@ async def download_file(task_id: str, url: str):
                             last_downloaded = downloaded
                         
                         f.flush()
-                        
-                        # Har thodi der mein file data disk par push karke RAM se clear karna
                         chunk_counter += 1
                         if chunk_counter % 20 == 0:
                             os.fsync(f.fileno())
                             del chunk
-                            gc.collect()  # Force fully garbage clean
+                            gc.collect()
                             
                 tasks[task_id]["status"] = "completed"
                 tasks[task_id]["speed"] = 0.0
@@ -121,8 +110,6 @@ async def download_file(task_id: str, url: str):
 @app.post("/start_download")
 async def start_download(req: DownloadRequest, background_tasks: BackgroundTasks):
     task_id = str(uuid.uuid4())
-    
-    # Try to extract filename from URL
     filename = req.url.split("/")[-1]
     if "?" in filename:
         filename = filename.split("?")[0]
@@ -140,7 +127,6 @@ async def start_download(req: DownloadRequest, background_tasks: BackgroundTasks
         "original_filename": filename,
         "timestamp": time.time()
     }
-    
     background_tasks.add_task(download_file, task_id, req.url)
     return {"task_id": task_id}
 
@@ -154,11 +140,7 @@ async def get_status(task_id: str):
 async def download(task_id: str):
     if task_id not in tasks or tasks[task_id]["status"] != "completed":
         return {"error": "File not ready"}
-    
-    file_path = tasks[task_id]["file_path"]
-    filename = tasks[task_id].get("original_filename", f"downloaded_{task_id}.bin")
-    
-    return FileResponse(file_path, filename=filename)
+    return FileResponse(tasks[task_id]["file_path"], filename=tasks[task_id].get("original_filename"))
 
 @app.get("/stream/{task_id}")
 async def stream(task_id: str, request: Request):
@@ -167,8 +149,8 @@ async def stream(task_id: str, request: Request):
     
     file_path = tasks[task_id]["file_path"]
     file_size = os.path.getsize(file_path)
-    
     range_header = request.headers.get("Range")
+    
     if range_header:
         byte1, byte2 = 0, None
         match = range_header.replace("bytes=", "").split("-")
@@ -184,7 +166,7 @@ async def stream(task_id: str, request: Request):
         def file_iterator(start, length):
             with open(file_path, "rb") as f:
                 f.seek(start)
-                chunk_size = 1024 * 1024
+                chunk_size = 512 * 1024  # Reduced chunk size for memory safety
                 while length > 0:
                     read_size = min(chunk_size, length)
                     data = f.read(read_size)
@@ -192,6 +174,7 @@ async def stream(task_id: str, request: Request):
                         break
                     yield data
                     length -= len(data)
+                    del data
                     
         headers = {
             "Content-Range": f"bytes {byte1}-{byte1+length-1}/{file_size}",
@@ -214,6 +197,8 @@ async def delete_all():
         try:
             if os.path.isfile(filepath):
                 os.remove(filepath)
+            elif os.path.isdir(filepath):
+                shutil.rmtree(filepath)
         except Exception as e:
             print(f"Failed to delete {filepath}: {e}")
     tasks.clear()
@@ -224,20 +209,24 @@ async def delete_all():
 async def get_history():
     return {"history": list(tasks.values())}
 
-
 @app.post("/upload")
 async def upload_file(file: UploadFile = File(...)):
     task_id = str(uuid.uuid4())
     original_filename = file.filename if file.filename else "uploaded_file.bin"
     file_path = os.path.join(DATA_DIR, f"{task_id}_{original_filename}")
     
+    # Using chunked reading directly from the file stream to save memory
     with open(file_path, "wb") as buffer:
-        while chunk := await file.read(512 * 1024):
+        while True:
+            chunk = await file.read(256 * 1024)
+            if not chunk:
+                break
             buffer.write(chunk)
             buffer.flush()
             os.fsync(buffer.fileno())
             del chunk
-        
+    
+    await file.close() # Strictly close file to free memory
     file_size = os.path.getsize(file_path)
     
     tasks[task_id] = {
@@ -254,7 +243,6 @@ async def upload_file(file: UploadFile = File(...)):
     gc.collect()
     return {"task_id": task_id}
 
-
 @app.post("/start_gofile_transfer")
 async def start_gofile_transfer(req: DownloadRequest, background_tasks: BackgroundTasks):
     task_id = str(uuid.uuid4())
@@ -279,10 +267,20 @@ async def start_gofile_transfer(req: DownloadRequest, background_tasks: Backgrou
     background_tasks.add_task(process_gofile_transfer, task_id, req.url)
     return {"task_id": task_id}
 
+# Chunked file reader generator to avoid streaming upload memory spikes
+async def file_sender(file_path, chunk_size=256 * 1024):
+    with open(file_path, 'rb') as f:
+        while True:
+            chunk = f.read(chunk_size)
+            if not chunk:
+                break
+            yield chunk
+            del chunk
+
 async def process_gofile_transfer(task_id: str, url: str):
     file_path = tasks[task_id]["file_path"]
     try:
-        # 1. Download File with memory lock
+        # 1. Download Setup
         connector = aiohttp.TCPConnector(limit=10)
         async with aiohttp.ClientSession(connector=connector, read_bufsize=256 * 1024) as session:
             async with session.get(url, timeout=None) as response:
@@ -329,31 +327,29 @@ async def process_gofile_transfer(task_id: str, url: str):
                             del chunk
                             gc.collect()
         
-        # 2. Upload to GoFile
+        # 2. Upload to GoFile (STREAMING JUGAD WITH ZERO RAM IMPRINT)
         tasks[task_id]["status"] = "uploading_to_gofile"
         tasks[task_id]["speed"] = 0.0
         
         async with aiohttp.ClientSession() as session:
-            # Get available server
             async with session.get("https://api.gofile.io/servers") as resp:
                 servers_data = await resp.json()
                 server = servers_data["data"]["servers"][0]["name"]
             
             upload_url = f"https://{server}.gofile.io/uploadFile"
             
+            # Form data wrapping without buffering entire file array into memory
             data = aiohttp.FormData()
-            with open(file_path, 'rb') as f_upload:
-                data.add_field('file', f_upload, filename=tasks[task_id]["original_filename"])
+            data.add_field('file', file_sender(file_path), filename=tasks[task_id]["original_filename"])
                 
-                async with session.post(upload_url, data=data) as upload_resp:
-                    upload_result = await upload_resp.json()
-                    if upload_result["status"] == "ok":
-                        tasks[task_id]["gofile_url"] = upload_result["data"]["downloadPage"]
-                        tasks[task_id]["status"] = "completed"
-                    else:
-                        raise Exception("GoFile upload failed")
+            async with session.post(upload_url, data=data) as upload_resp:
+                upload_result = await upload_resp.json()
+                if upload_result["status"] == "ok":
+                    tasks[task_id]["gofile_url"] = upload_result["data"]["downloadPage"]
+                    tasks[task_id]["status"] = "completed"
+                else:
+                    raise Exception("GoFile upload failed")
                         
-        # Local cache file clean up after completion
         try:
             os.remove(file_path)
         except:
@@ -369,7 +365,6 @@ async def process_gofile_transfer(task_id: str, url: str):
 
 @app.get("/list_zip/{task_id}")
 async def list_zip_contents(task_id: str):
-    """Bina extract kiye ZIP ke andar ki saari files ki list dikhayega"""
     if task_id not in tasks:
         return {"error": "Task not found"}
     
@@ -395,7 +390,6 @@ async def list_zip_contents(task_id: str):
 
 @app.post("/extract_zip/{task_id}")
 async def extract_zip_file(task_id: str, background_tasks: BackgroundTasks):
-    """Background mein ZIP file ko extract karne ka process shuru karega"""
     if task_id not in tasks:
         return {"error": "Task not found"}
         
@@ -406,22 +400,26 @@ async def extract_zip_file(task_id: str, background_tasks: BackgroundTasks):
     if not zipfile.is_zipfile(file_path):
         return {"error": "This file is not a valid ZIP archive"}
         
-    # Extraction folder name (Task ID ke sath folder banega jisse files mix na hon)
     extract_folder = os.path.join(DATA_DIR, f"extracted_{task_id}")
     os.makedirs(extract_folder, exist_ok=True)
     
     tasks[task_id]["status"] = "extracting"
     tasks[task_id]["extract_path"] = extract_folder
     
-    # Background mein execution taaki API request time out na ho aur UI freeze na ho
     background_tasks.add_task(process_zip_extraction, task_id, file_path, extract_folder)
     return {"status": "extraction_started", "task_id": task_id, "target_folder": extract_folder}
 
 def process_zip_extraction(task_id: str, zip_path: str, target_dir: str):
-    """Background extraction worker with automatic memory release"""
+    """Memory safe extraction processing member by member loop"""
     try:
         with zipfile.ZipFile(zip_path, 'r') as z:
-            z.extractall(path=target_dir)
+            file_counter = 0
+            for member in z.namelist():
+                z.extract(member, path=target_dir)
+                file_counter += 1
+                # Release lock periodically inside loops
+                if file_counter % 50 == 0:
+                    gc.collect()
         tasks[task_id]["status"] = "extracted"
     except Exception as e:
         tasks[task_id]["status"] = "extraction_error"
@@ -429,8 +427,6 @@ def process_zip_extraction(task_id: str, zip_path: str, target_dir: str):
     finally:
         gc.collect()
 
-# =====================================================================
-
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)