Update app.py

app.py

@@ -474,47 +474,61 @@ HTML_CONTENT = """
             const progressBar = createProgressBar(file.name);
             progressContainer.appendChild(progressBar);
 
-            const chunkSize = 1024 * 1024; // 1MB chunks
-            const totalChunks = Math.ceil(file.size / chunkSize);
-            let uploadedChunks = 0;
+            const formData = new FormData();
+            formData.append('file', file);
 
-            while (uploadedChunks < totalChunks) {
-                const start = uploadedChunks * chunkSize;
-                const end = Math.min(start + chunkSize, file.size);
-                const chunk = file.slice(start, end);
-
-                const formData = new FormData();
-                formData.append('file', chunk, file.name);
-                formData.append('chunk', uploadedChunks.toString());
-                formData.append('totalChunks', totalChunks.toString());
+            let uploadedBytes = 0;
+            let totalBytes = file.size;
 
+            while (uploadedBytes < totalBytes) {
                 try {
-                    const response = await fetch('/upload', {
-                        method: 'POST',
-                        body: formData
-                    });
+                    const xhr = new XMLHttpRequest();
+                    xhr.open('POST', '/upload', true);
+                    xhr.setRequestHeader('Content-Range', `bytes ${uploadedBytes}-${totalBytes-1}/${totalBytes}`);
+                    xhr.upload.onprogress = (event) => updateProgress(event, progressBar.querySelector('.progress'), uploadedBytes);
+                    
+                    xhr.onload = function() {
+                        if (xhr.status === 200) {
+                            const response = JSON.parse(xhr.responseText);
+                            if (response.url) {
+                                addResultLink(response.url, file.name);
+                                resetUploadState();
+                                return;
+                            } else {
+                                throw new Error('Upload failed: ' + response.error);
+                            }
+                        } else if (xhr.status === 308) {
+                            // Partial upload successful, update uploadedBytes
+                            const range = xhr.getResponseHeader('Range');
+                            if (range) {
+                                uploadedBytes = parseInt(range.split('-')[1]) + 1;
+                            }
+                        } else {
+                            throw new Error(`HTTP error! status: ${xhr.status}`);
+                        }
+                    };
 
-                    if (!response.ok) {
-                        throw new Error(`HTTP error! status: ${response.status}`);
-                    }
+                    xhr.onerror = function() {
+                        throw new Error('Network error occurred');
+                    };
 
-                    const result = await response.json();
-                    if (result.success) {
-                        uploadedChunks++;
-                        updateProgress(progressBar.querySelector('.progress'), (uploadedChunks / totalChunks) * 100);
+                    const chunk = file.slice(uploadedBytes, uploadedBytes + 1024 * 1024); // 1MB chunks
+                    xhr.send(chunk);
 
-                        if (uploadedChunks === totalChunks) {
-                            addResultLink(result.url, file.name);
-                            resetUploadState();
-                            break;
-                        }
-                    } else {
-                        throw new Error(result.error || 'Upload failed');
+                    // Wait for the request to complete
+                    await new Promise((resolve, reject) => {
+                        xhr.onloadend = resolve;
+                        xhr.onerror = reject;
+                    });
+
+                    if (uploadedBytes >= totalBytes) {
+                        break; // Upload complete
                     }
                 } catch (error) {
                     console.error('Upload error:', error);
+                    // Wait for a short time before retrying
                     await new Promise(resolve => setTimeout(resolve, 1000));
-                    // The loop will continue, retrying the current chunk
+                    // The loop will continue, retrying the upload from where it left off
                 }
             }
         }
@@ -535,8 +549,12 @@ HTML_CONTENT = """
             return container;
         }
 
-        function updateProgress(progressBar, percentage) {
-            progressBar.style.width = percentage + '%';
+        function updateProgress(event, progressBar, uploadedBytes) {
+            if (event.lengthComputable) {
+                const totalBytes = uploadedBytes + event.total;
+                const percentComplete = ((uploadedBytes + event.loaded) / totalBytes) * 100;
+                progressBar.style.width = percentComplete + '%';
+            }
         }
 
         function resetUploadState() {
@@ -609,7 +627,7 @@ async def index():
     return HTML_CONTENT
 
 @app.post("/upload")
-async def handle_upload(file: UploadFile = File(...), chunk: int = 0, totalChunks: int = 1):
+async def handle_upload(file: UploadFile = File(...)):
     if not file.filename:
         return JSONResponse(content={"error": "No file selected."}, status_code=400)
 
@@ -617,26 +635,19 @@ async def handle_upload(file: UploadFile = File(...), chunk: int = 0, totalChunk
     if 'csrftoken' not in cookies or 'sessionid' not in cookies:
         return JSONResponse(content={"error": "Failed to obtain necessary cookies"}, status_code=500)
 
-    if chunk == 0:
-        upload_result = await initiate_upload(cookies, file.filename, file.content_type)
-        if not upload_result or 'upload_url' not in upload_result:
-            return JSONResponse(content={"error": "Failed to initiate upload"}, status_code=500)
-    else:
-        upload_result = await get_upload_status(cookies, file.filename)
-        if not upload_result or 'upload_url' not in upload_result:
-            return JSONResponse(content={"error": "Failed to get upload status"}, status_code=500)
+    upload_result = await initiate_upload(cookies, file.filename, file.content_type)
+    if not upload_result or 'upload_url' not in upload_result:
+        return JSONResponse(content={"error": "Failed to initiate upload"}, status_code=500)
 
     file_content = await file.read()
-    upload_success = await retry_upload(upload_result['upload_url'], file_content, file.content_type, chunk, totalChunks)
+    upload_success = await retry_upload(upload_result['upload_url'], file_content, file.content_type)
     if not upload_success:
         return JSONResponse(content={"error": "File upload failed after multiple attempts"}, status_code=500)
 
-    if chunk == totalChunks - 1:
-        original_url = upload_result['serving_url']
-        mirrored_url = f"/rbxg/{original_url.split('/pbxt/')[1]}"
-        return JSONResponse(content={"success": True, "url": mirrored_url})
-    else:
-        return JSONResponse(content={"success": True})
+    original_url = upload_result['serving_url']
+    mirrored_url = f"/rbxg/{original_url.split('/pbxt/')[1]}"
+
+    return JSONResponse(content={"url": mirrored_url})
 
 @app.get("/rbxg/{path:path}")
 async def handle_video_stream(path: str, request: Request):
@@ -732,53 +743,27 @@ async def initiate_upload(cookies: Dict[str, str], filename: str, content_type:
         print(f'Error initiating upload: {e}')
         raise
 
-async def get_upload_status(cookies: Dict[str, str], filename: str) -> Dict:
-    url = f'https://replicate.com/api/upload/{filename}'
-    try:
-        response = requests.get(url, cookies=cookies, headers={
-            'X-CSRFToken': cookies.get('csrftoken'),
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36',
-            'Referer': 'https://replicate.com/levelsio/neon-tokyo',
-            'Origin': 'https://replicate.com',
-            'Accept': '*/*',
-            'Accept-Language': 'en-US,en;q=0.5',
-            'Accept-Encoding': 'identity',
-            'Sec-Fetch-Dest': 'empty',
-            'Sec-Fetch-Mode': 'cors',
-            'Sec-Fetch-Site': 'same-origin',
-            'Sec-GPC': '1',
-            'Priority': 'u=1, i'
-        })
-        return response.json()
-    except Exception as e:
-        print(f'Error getting upload status: {e}')
-        raise
-
-async def upload_file(upload_url: str, file_content: bytes, content_type: str, chunk: int, totalChunks: int) -> bool:
-    headers = {
-        'Content-Type': content_type,
-        'Content-Range': f'bytes {chunk*len(file_content)}-{(chunk+1)*len(file_content)-1}/{totalChunks*len(file_content)}'
-    }
+async def upload_file(upload_url: str, file_content: bytes, content_type: str) -> bool:
     try:
-        response = requests.put(upload_url, data=file_content, headers=headers)
-        return response.status_code in [200, 201, 204]
+        response = requests.put(upload_url, data=file_content, headers={'Content-Type': content_type})
+        return response.status_code == 200
     except Exception as e:
         print(f'Error uploading file: {e}')
         return False
 
-async def retry_upload(upload_url: str, file_content: bytes, content_type: str, chunk: int, totalChunks: int, max_retries: int = 5, delay: int = 1) -> bool:
-    for attempt in range(max_retries):
+async def retry_upload(upload_url: str, file_content: bytes, content_type: str, max_retries: int = 5, delay: int = 1) -> bool:
+    retries = 0
+    while retries < max_retries:
         try:
-            success = await upload_file(upload_url, file_content, content_type, chunk, totalChunks)
+            success = await upload_file(upload_url, file_content, content_type)
             if success:
                 return True
-            print(f"Upload attempt {attempt + 1} failed. Retrying...")
+            print(f"Upload attempt {retries + 1} failed. Retrying...")
         except Exception as e:
-            print(f"Error during upload attempt {attempt + 1}: {e}")
+            print(f"Error during upload attempt {retries + 1}: {e}")
         
-        if attempt < max_retries - 1:
-            await asyncio.sleep(delay)
-            delay *= 2  # Exponential backoff
+        retries += 1
+        await asyncio.sleep(delay)
+        delay = min(delay * 2, 60)  # Exponential backoff, capped at 60 seconds
     
-    print("Upload failed after all retry attempts")
     return False