Update app.py

app.py

@@ -7,6 +7,7 @@ import shutil
 import aiohttp
 import gc  # Memory management ke liye garbage collector
 import zipfile  # ZIP file handle karne ke liye in-built library
+import urllib3  # Zero-buffer strict low RAM downloding ke liye
 from fastapi import FastAPI, BackgroundTasks, Request, File, UploadFile
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse, StreamingResponse
@@ -57,65 +58,71 @@ async def cleanup_old_files():
 async def startup_event():
     asyncio.create_task(cleanup_old_files())
 
-async def download_file(task_id: str, url: str):
+def sync_download_worker(task_id: str, url: str):
+    """Urllib3 pool se strict raw streaming taaki RAM me cache accumulate na ho"""
     file_path = tasks[task_id]["file_path"]
     try:
-        # Buffer limit ko strictly small rakha hai taaki RAM leak na ho
-        connector = aiohttp.TCPConnector(limit=5)
-        async with aiohttp.ClientSession(connector=connector, read_bufsize=64 * 1024) as session:
-            async with session.get(url, timeout=None) as response:
-                response.raise_for_status()
-                total_size = int(response.headers.get('Content-Length', 0))
-                tasks[task_id]["total_size"] = total_size
-                
-                # Header check for proper filename extraction (.apk, .mp4, etc.)
-                cd = response.headers.get('Content-Disposition')
-                if cd and 'filename=' in cd:
-                    fname = re.findall('filename="([^"]+)"', cd)
-                    if not fname:
-                        fname = re.findall('filename=([^;]+)', cd)
-                    if fname:
-                        new_filename = fname[0]
-                        file_path = os.path.join(DATA_DIR, f"{task_id}_{new_filename}")
-                        tasks[task_id]["file_path"] = file_path
-                        tasks[task_id]["original_filename"] = new_filename
+        http = urllib3.PoolManager(block=True, maxsize=1)
+        response = http.request('GET', url, preload_content=False, timeout=None)
+        
+        total_size = int(response.headers.get('Content-Length', 0))
+        tasks[task_id]["total_size"] = total_size
+        
+        # Proper filename aur extension extraction (.apk wagera)
+        cd = response.headers.get('Content-Disposition')
+        if cd and 'filename=' in cd:
+            fname = re.findall('filename="([^"]+)"', cd)
+            if not fname:
+                fname = re.findall('filename=([^;]+)', cd)
+            if fname:
+                new_filename = fname[0]
+                file_path = os.path.join(DATA_DIR, f"{task_id}_{new_filename}")
+                tasks[task_id]["file_path"] = file_path
+                tasks[task_id]["original_filename"] = new_filename
 
-                downloaded = 0
-                start_time = time.time()
-                last_time = start_time
-                last_downloaded = 0
-                chunk_counter = 0
+        downloaded = 0
+        start_time = time.time()
+        last_time = start_time
+        last_downloaded = 0
+        chunk_counter = 0
+        
+        with open(file_path, 'wb') as f:
+            # 64KB strict buffer chunking, RAM me data holds hi nahi hoga
+            for chunk in response.stream(64 * 1024):
+                if not chunk:
+                    break
+                f.write(chunk)
+                downloaded += len(chunk)
+                tasks[task_id]["downloaded"] = downloaded
                 
-                with open(file_path, 'wb') as f:
-                    async for chunk in response.content.iter_chunked(64 * 1024):
-                        if not chunk:
-                            break
-                        f.write(chunk)
-                        downloaded += len(chunk)
-                        tasks[task_id]["downloaded"] = downloaded
-                        
-                        current_time = time.time()
-                        if current_time - last_time >= 1.0:
-                            speed = (downloaded - last_downloaded) / (current_time - last_time)
-                            tasks[task_id]["speed"] = speed
-                            last_time = current_time
-                            last_downloaded = downloaded
-                        
-                        f.flush()
-                        chunk_counter += 1
-                        if chunk_counter % 10 == 0:
-                            os.fsync(f.fileno())
-                            del chunk
-                            gc.collect() # Strict garbage collection
-                            
-                tasks[task_id]["status"] = "completed"
-                tasks[task_id]["speed"] = 0.0
+                current_time = time.time()
+                if current_time - last_time >= 1.0:
+                    speed = (downloaded - last_downloaded) / (current_time - last_time)
+                    tasks[task_id]["speed"] = speed
+                    last_time = current_time
+                    last_downloaded = downloaded
+                
+                f.flush()
+                chunk_counter += 1
+                if chunk_counter % 10 == 0:
+                    os.fsync(f.fileno())
+                    del chunk
+                    gc.collect() # Strict cleanup inside raw sync thread
+                    
+        response.release_conn()
+        tasks[task_id]["status"] = "completed"
+        tasks[task_id]["speed"] = 0.0
     except Exception as e:
         tasks[task_id]["status"] = "error"
         tasks[task_id]["error"] = str(e)
     finally:
         gc.collect()
 
+async def download_file(task_id: str, url: str):
+    # Loop block bypass karne ke liye execution ko framework thread pool me run karenge
+    loop = asyncio.get_event_loop()
+    await loop.run_in_executor(None, sync_download_worker, task_id, url)
+
 @app.post("/start_download")
 async def start_download(req: DownloadRequest, background_tasks: BackgroundTasks):
     task_id = str(uuid.uuid4())
@@ -171,7 +178,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 = 128 * 1024  # Hugging Face RAM Optimization
+                chunk_size = 64 * 1024  
                 while length > 0:
                     read_size = min(chunk_size, length)
                     data = f.read(read_size)
@@ -279,54 +286,60 @@ async def file_sender(file_path, chunk_size=64 * 1024):
             del chunk
             gc.collect()
 
-async def process_gofile_transfer(task_id: str, url: str):
+def sync_gofile_download_part(task_id: str, url: str):
+    """GoFile processing ke liye bhi same raw low RAM wrapper"""
     file_path = tasks[task_id]["file_path"]
-    try:
-        connector = aiohttp.TCPConnector(limit=5)
-        async with aiohttp.ClientSession(connector=connector, read_bufsize=64 * 1024) as session:
-            async with session.get(url, timeout=None) as response:
-                response.raise_for_status()
-                total_size = int(response.headers.get('Content-Length', 0))
-                tasks[task_id]["total_size"] = total_size
-                
-                cd = response.headers.get('Content-Disposition')
-                if cd and 'filename=' in cd:
-                    fname = re.findall('filename="([^"]+)"', cd)
-                    if not fname:
-                        fname = re.findall('filename=([^;]+)', cd)
-                    if fname:
-                        new_filename = fname[0]
-                        file_path = os.path.join(DATA_DIR, f"{task_id}_{new_filename}")
-                        tasks[task_id]["file_path"] = file_path
-                        tasks[task_id]["original_filename"] = new_filename
+    http = urllib3.PoolManager(block=True, maxsize=1)
+    response = http.request('GET', url, preload_content=False, timeout=None)
+    
+    total_size = int(response.headers.get('Content-Length', 0))
+    tasks[task_id]["total_size"] = total_size
+    
+    cd = response.headers.get('Content-Disposition')
+    if cd and 'filename=' in cd:
+        fname = re.findall('filename="([^"]+)"', cd)
+        if not fname:
+            fname = re.findall('filename=([^;]+)', cd)
+        if fname:
+            new_filename = fname[0]
+            file_path = os.path.join(DATA_DIR, f"{task_id}_{new_filename}")
+            tasks[task_id]["file_path"] = file_path
+            tasks[task_id]["original_filename"] = new_filename
 
-                downloaded = 0
-                start_time = time.time()
-                last_time = start_time
-                last_downloaded = 0
-                chunk_counter = 0
-                
-                with open(file_path, 'wb') as f:
-                    async for chunk in response.content.iter_chunked(64 * 1024):
-                        if not chunk:
-                            break
-                        f.write(chunk)
-                        downloaded += len(chunk)
-                        tasks[task_id]["downloaded"] = downloaded
-                        
-                        current_time = time.time()
-                        if current_time - last_time >= 1.0:
-                            tasks[task_id]["speed"] = (downloaded - last_downloaded) / (current_time - last_time)
-                            last_time = current_time
-                            last_downloaded = downloaded
-                        
-                        f.flush()
-                        chunk_counter += 1
-                        if chunk_counter % 10 == 0:
-                            os.fsync(f.fileno())
-                            del chunk
-                            gc.collect()
+    downloaded = 0
+    start_time = time.time()
+    last_time = start_time
+    last_downloaded = 0
+    chunk_counter = 0
+    
+    with open(file_path, 'wb') as f:
+        for chunk in response.stream(64 * 1024):
+            if not chunk:
+                break
+            f.write(chunk)
+            downloaded += len(chunk)
+            tasks[task_id]["downloaded"] = downloaded
+            
+            current_time = time.time()
+            if current_time - last_time >= 1.0:
+                tasks[task_id]["speed"] = (downloaded - last_downloaded) / (current_time - last_time)
+                last_time = current_time
+                last_downloaded = downloaded
+            
+            f.flush()
+            chunk_counter += 1
+            if chunk_counter % 10 == 0:
+                os.fsync(f.fileno())
+                del chunk
+                gc.collect()
+    response.release_conn()
+
+async def process_gofile_transfer(task_id: str, url: str):
+    try:
+        loop = asyncio.get_event_loop()
+        await loop.run_in_executor(None, sync_gofile_download_part, task_id, url)
         
+        file_path = tasks[task_id]["file_path"]
         tasks[task_id]["status"] = "uploading_to_gofile"
         tasks[task_id]["speed"] = 0.0