Update app.py

app.py

@@ -385,7 +385,7 @@ HTML_CONTENT = """
             <div class="loading-spinner" id="loadingSpinner"></div>
         </form>
         <div class="result-container" id="resultContainer"></div>
-        <div class="file-types">
+                <div class="file-types">
             Allowed file types: .zip, .mp4, .txt, .mp3, all image types, .pdf
         </div>
     </div>
@@ -409,7 +409,7 @@ HTML_CONTENT = """
         const progressContainer = document.getElementById('progressContainer');
         const loadingSpinner = document.getElementById('loadingSpinner');
         const resultContainer = document.getElementById('resultContainer');
-                const dropZone = document.getElementById('dropZone');
+        const dropZone = document.getElementById('dropZone');
         const modal = document.getElementById('embedModal');
         const span = document.getElementsByClassName("close")[0];
         const embedLinkInput = document.getElementById('embedLink');
@@ -486,45 +486,39 @@ HTML_CONTENT = """
             const formData = new FormData();
             formData.append('file', file);
 
-            let retries = 0;
-            const maxRetries = 5;
-            const retryDelay = 1000;
+            let uploadedBytes = 0;
+            const chunkSize = 1024 * 1024; // 1MB chunks
+            const totalSize = file.size;
+
+            while (uploadedBytes < totalSize) {
+                const chunk = file.slice(uploadedBytes, uploadedBytes + chunkSize);
+                formData.set('file', chunk, file.name);
 
-            while (retries < maxRetries) {
                 try {
-                    const xhr = new XMLHttpRequest();
-                    xhr.open('POST', '/upload', true);
-                    xhr.upload.onprogress = (event) => updateProgress(event, progressBar.querySelector('.progress'));
-                    
-                    const uploadPromise = new Promise((resolve, reject) => {
-                        xhr.onload = function() {
-                            if (xhr.status === 200) {
-                                const response = JSON.parse(xhr.responseText);
-                                if (response.url) {
-                                    resolve(response.url);
-                                } else {
-                                    reject(new Error('Upload failed: ' + response.error));
-                                }
-                            } else {
-                                reject(new Error(`HTTP error! status: ${xhr.status}`));
-                            }
-                        };
-                        xhr.onerror = () => reject(new Error('Network error occurred'));
+                    const response = await fetch('/upload', {
+                        method: 'POST',
+                        body: formData,
+                        headers: {
+                            'Content-Range': `bytes ${uploadedBytes}-${uploadedBytes + chunk.size - 1}/${totalSize}`
+                        }
                     });
 
-                    xhr.send(formData);
+                    if (!response.ok) {
+                        throw new Error(`HTTP error! status: ${response.status}`);
+                    }
 
-                    const url = await uploadPromise;
-                    addResultLink(url, file.name);
-                    break; // Success, exit the retry loop
-                } catch (error) {
-                    console.error('Upload error:', error);
-                    retries++;
-                    if (retries >= maxRetries) {
-                        alert('Upload failed after multiple attempts: ' + error.message);
+                    const result = await response.json();
+                    if (result.url) {
+                        addResultLink(result.url, file.name);
                         break;
                     }
-                    await new Promise(resolve => setTimeout(resolve, retryDelay));
+
+                    uploadedBytes += chunk.size;
+                    updateProgress(uploadedBytes, totalSize, progressBar.querySelector('.progress'));
+                } catch (error) {
+                    console.error('Upload error:', error);
+                    await new Promise(resolve => setTimeout(resolve, 1000)); // Wait 1 second before retrying
+                    // The loop will continue from where it left off
                 }
             }
 
@@ -547,11 +541,9 @@ HTML_CONTENT = """
             return container;
         }
 
-        function updateProgress(event, progressBar) {
-            if (event.lengthComputable) {
-                const percentComplete = (event.loaded / event.total) * 100;
-                progressBar.style.width = percentComplete + '%';
-            }
+        function updateProgress(uploadedBytes, totalBytes, progressBar) {
+            const percentComplete = (uploadedBytes / totalBytes) * 100;
+            progressBar.style.width = percentComplete + '%';
         }
 
         function resetUploadState() {
@@ -624,7 +616,14 @@ async def index():
     return HTML_CONTENT
 
 @app.post("/upload")
-async def handle_upload(file: UploadFile = File(...)):
+async def handle_upload(file: UploadFile = File(...), request: Request):
+    content_range = request.headers.get('Content-Range')
+    if not content_range:
+        raise HTTPException(status_code=400, detail="Content-Range header is missing")
+
+    _, range_str = content_range.split(' ')
+    start_byte, end_byte, total_size = map(int, range_str.replace('bytes', '').split('-')[0].split('/'))
+
     if not file:
         raise HTTPException(status_code=400, detail="No file part")
     if file.filename == '':
@@ -634,19 +633,25 @@ async def handle_upload(file: UploadFile = File(...)):
     if 'csrftoken' not in cookies or 'sessionid' not in cookies:
         raise HTTPException(status_code=500, detail="Failed to obtain necessary cookies")
 
-    upload_result = await initiate_upload(cookies, file.filename, file.content_type)
-    if not upload_result or 'upload_url' not in upload_result:
-        raise HTTPException(status_code=500, detail="Failed to initiate upload")
+    if start_byte == 0:
+        upload_result = await initiate_upload(cookies, file.filename, file.content_type)
+        if not upload_result or 'upload_url' not in upload_result:
+            raise HTTPException(status_code=500, detail="Failed to initiate upload")
+    else:
+        upload_result = {'upload_url': file.filename}  # Use filename as a key to retrieve the upload URL
 
     file_content = await file.read()
-    upload_success = await retry_upload(upload_result['upload_url'], file_content, file.content_type)
+    upload_success = await upload_chunk(upload_result['upload_url'], file_content, start_byte, end_byte, total_size)
     if not upload_success:
-        raise HTTPException(status_code=500, detail="File upload failed after multiple attempts")
-
-    original_url = upload_result['serving_url']
-    mirrored_url = f"/rbxg/{original_url.split('/pbxt/')[1]}"
+        raise HTTPException(status_code=500, detail="Chunk upload failed")
 
-    return JSONResponse(content={"url": mirrored_url})
+    if end_byte + 1 >= total_size:
+        original_url = upload_result.get('serving_url')
+        if original_url:
+            mirrored_url = f"/rbxg/{original_url.split('/pbxt/')[1]}"
+            return JSONResponse(content={"url": mirrored_url})
+    
+    return JSONResponse(content={"status": "chunk uploaded"})
 
 @app.get("/rbxg/{path:path}")
 async def handle_video_stream(path: str, request: Request):
@@ -742,12 +747,16 @@ async def initiate_upload(cookies: Dict[str, str], filename: str, content_type:
         print(f'Error initiating upload: {e}')
         raise
 
-async def upload_file(upload_url: str, file_content: bytes, content_type: str) -> bool:
+async def upload_chunk(upload_url: str, chunk_content: bytes, start_byte: int, end_byte: int, total_size: int) -> bool:
     try:
-        response = requests.put(upload_url, data=file_content, headers={'Content-Type': content_type})
-        return response.status_code == 200
+        headers = {
+            'Content-Type': 'application/octet-stream',
+                        'Content-Range': f'bytes {start_byte}-{end_byte}/{total_size}'
+        }
+        response = requests.put(upload_url, data=chunk_content, headers=headers)
+        return response.status_code in [200, 201, 204]
     except Exception as e:
-        print(f'Error uploading file: {e}')
+        print(f'Error uploading chunk: {e}')
         return False
 
 async def retry_upload(upload_url: str, file_content: bytes, content_type: str, max_retries: int = 5, delay: int = 1) -> bool:
@@ -765,4 +774,12 @@ async def retry_upload(upload_url: str, file_content: bytes, content_type: str,
         await asyncio.sleep(delay)
         delay = min(delay * 2, 60)  # Exponential backoff, capped at 60 seconds
     
-    return False
+    return False
+
+async def upload_file(upload_url: str, file_content: bytes, content_type: str) -> bool:
+    try:
+        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