Update app.py

app.py

@@ -152,7 +152,19 @@ 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"}
-    return FileResponse(tasks[task_id]["file_path"], filename=tasks[task_id].get("original_filename"))
+    
+    # Hugging Face reverse proxy buffering ko explicit bypass karne ke liye headers
+    headers = {
+        "X-Accel-Buffering": "no",
+        "Cache-Control": "no-cache, no-store, must-revalidate",
+        "Pragma": "no-cache",
+        "Expires": "0"
+    }
+    return FileResponse(
+        tasks[task_id]["file_path"], 
+        filename=tasks[task_id].get("original_filename"),
+        headers=headers
+    )
 
 @app.get("/stream/{task_id}")
 async def stream(task_id: str, request: Request):
@@ -163,6 +175,17 @@ async def stream(task_id: str, request: Request):
     file_size = os.path.getsize(file_path)
     range_header = request.headers.get("Range")
     
+    # Fast output transfer ke liye chunk size 1MB se 4MB ke beech hona chahiye (Overhead kam karne ke liye)
+    STREAM_CHUNK_SIZE = 2 * 1024 * 1024  
+    
+    # Common performance headers jo proxy networks ko instantaneous routing ke liye force karte hain
+    base_headers = {
+        "X-Accel-Buffering": "no",
+        "Cache-Control": "no-cache, no-store, must-revalidate",
+        "Pragma": "no-cache",
+        "Accept-Ranges": "bytes"
+    }
+    
     if range_header:
         byte1, byte2 = 0, None
         match = range_header.replace("bytes=", "").split("-")
@@ -175,28 +198,38 @@ async def stream(task_id: str, request: Request):
         if byte2 is not None:
             length = byte2 + 1 - byte1
             
-        def file_iterator(start, length):
+        def file_iterator(start, length_left):
             with open(file_path, "rb") as f:
                 f.seek(start)
-                chunk_size = 64 * 1024  
-                while length > 0:
-                    read_size = min(chunk_size, length)
+                while length_left > 0:
+                    read_size = min(STREAM_CHUNK_SIZE, length_left)
                     data = f.read(read_size)
                     if not data:
                         break
                     yield data
-                    length -= len(data)
+                    length_left -= len(data)
                     del data
-                    gc.collect()
                     
-        headers = {
+        base_headers.update({
             "Content-Range": f"bytes {byte1}-{byte1+length-1}/{file_size}",
-            "Accept-Ranges": "bytes",
             "Content-Length": str(length),
-        }
-        return StreamingResponse(file_iterator(byte1, length), status_code=206, headers=headers)
+        })
+        return StreamingResponse(file_iterator(byte1, length), status_code=206, headers=base_headers)
     else:
-        return FileResponse(file_path)
+        def full_file_iterator():
+            with open(file_path, "rb") as f:
+                while True:
+                    data = f.read(STREAM_CHUNK_SIZE)
+                    if not data:
+                        break
+                    yield data
+                    del data
+
+        base_headers.update({
+            "Content-Length": str(file_size),
+            "Content-Disposition": f'attachment; filename="{tasks[task_id].get("original_filename")}"'
+        })
+        return StreamingResponse(full_file_iterator(), media_type="application/octet-stream", headers=base_headers)
 
 @app.get("/storage")
 async def get_storage():