Update app.py

app.py

@@ -4,6 +4,7 @@ import requests
 import time
 import asyncio
 from typing import Dict
+import aiohttp
 
 app = FastAPI()
 
@@ -423,7 +424,7 @@ HTML_CONTENT = """
             gap: 5px;
         }
 
-                .quick-open-modal {
+                        .quick-open-modal {
             display: none;
             position: fixed;
             z-index: 4;
@@ -696,44 +697,28 @@ HTML_CONTENT = """
             const formData = new FormData();
             formData.append('file', file);
 
-            while (true) {
-                try {
-                    const xhr = new XMLHttpRequest();
-                    xhr.open('POST', '/upload', true);
-                    xhr.upload.onprogress = (event) => updateProgress(event, progressBar.querySelector('.progress'));
-                    
-                    xhr.onload = function() {
-                        if (xhr.status === 200) {
-                            const response = JSON.parse(xhr.responseText);
-                            if (response.url) {
-                                addResultLink(response.url, file.name);
-                                saveToHistory(file.name, response.url);
-                                resetUploadState();
-                                return;
-                            } else {
-                                throw new Error('Upload failed: ' + response.error);
-                            }
-                        } else {
-                            throw new Error(`HTTP error! status: ${xhr.status}`);
-                        }
-                    };
-
-                    xhr.onerror = function() {
-                        throw new Error('Network error occurred');
-                    };
-
-                    xhr.send(formData);
+            try {
+                const response = await fetch('/upload', {
+                    method: 'POST',
+                    body: formData
+                });
 
-                    await new Promise((resolve, reject) => {
-                        xhr.onloadend = resolve;
-                        xhr.onerror = reject;
-                    });
+                if (!response.ok) {
+                    throw new Error(`HTTP error! status: ${response.status}`);
+                }
 
-                    break;
-                } catch (error) {
-                    console.error('Upload error:', error);
-                    await new Promise(resolve => setTimeout(resolve, 1000));
+                const result = await response.json();
+                if (result.url) {
+                    addResultLink(result.url, file.name);
+                    saveToHistory(file.name, result.url);
+                } else {
+                    throw new Error('Upload failed: ' + result.error);
                 }
+            } catch (error) {
+                console.error('Upload error:', error);
+                alert('Upload failed. Please try again.');
+            } finally {
+                resetUploadState();
             }
         }
 
@@ -753,19 +738,13 @@ HTML_CONTENT = """
             return container;
         }
 
-        function updateProgress(event, progressBar) {
-            if (event.lengthComputable) {
-                const percentComplete = (event.loaded / event.total) * 100;
-                progressBar.style.width = percentComplete + '%';
-            }
-        }
-
         function resetUploadState() {
             fileInput.value = '';
             fileName.textContent = '';
             uploadBtn.style.display = 'none';
             uploadBtn.disabled = false;
             loadingSpinner.style.display = 'none';
+            progressContainer.style.display = 'none';
         }
 
         function addResultLink(url, fileName) {
@@ -853,7 +832,7 @@ HTML_CONTENT = """
                 };
                 actionsContainer.appendChild(copyBtn);
 
-                                const openBtn = document.createElement('button');
+                const openBtn = document.createElement('button');
                 openBtn.textContent = 'Open';
                 openBtn.className = 'small-btn';
                 openBtn.onclick = () => {
@@ -869,7 +848,7 @@ HTML_CONTENT = """
                 };
                 actionsContainer.appendChild(quickOpenBtn);
 
-                if (item.fileName.toLowerCase().endsWith('.mp4')) {
+                                if (item.fileName.toLowerCase().endsWith('.mp4')) {
                     const embedBtn = document.createElement('button');
                     embedBtn.textContent = 'Embed';
                     embedBtn.className = 'small-btn';
@@ -943,16 +922,15 @@ async def handle_upload(file: UploadFile = File(...)):
 
     cookies = await get_cookies()
     if 'csrftoken' not in cookies or 'sessionid' not in cookies:
-        return JSONResponse(content={"error": "Failed"}, status_code=500)
+        return JSONResponse(content={"error": "Failed to get cookies"}, 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 upload"}, status_code=500)
+        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)
+    upload_success = await chunked_upload(upload_result['upload_url'], file, file.content_type)
     if not upload_success:
-        return JSONResponse(content={"error": "FAILED GOD MAN AFTER alot of attempts"}, status_code=500)
+        return JSONResponse(content={"error": "Failed to upload file after multiple attempts"}, status_code=500)
 
     original_url = upload_result['serving_url']
     mirrored_url = f"/rbxg/{original_url.split('/pbxt/')[1]}"
@@ -965,20 +943,17 @@ async def handle_video_stream(path: str, request: Request):
     range_header = request.headers.get('Range')
 
     headers = {'Range': range_header} if range_header else {}
-    response = requests.get(original_url, headers=headers, stream=True)
-
-    def generate():
-        for chunk in response.iter_content(chunk_size=8192):
-            yield chunk
+    async with aiohttp.ClientSession() as session:
+        async with session.get(original_url, headers=headers) as response:
+            content = await response.read()
+            headers = dict(response.headers)
+            headers['Access-Control-Allow-Origin'] = '*'
+            headers['Content-Disposition'] = 'inline'
 
-    headers = dict(response.headers)
-    headers['Access-Control-Allow-Origin'] = '*'
-    headers['Content-Disposition'] = 'inline'
+            if response.status == 206:
+                headers['Content-Range'] = response.headers.get('Content-Range')
 
-    if response.status_code == 206:
-        headers['Content-Range'] = response.headers.get('Content-Range')
-
-    return StreamingResponse(generate(), status_code=response.status_code, headers=headers)
+            return StreamingResponse(content, status_code=response.status, headers=headers)
 
 @app.get("/embed")
 async def embed_video(url: str, thumbnail: str):
@@ -1022,19 +997,16 @@ async def embed_video(url: str, thumbnail: str):
     return HTMLResponse(content=html)
 
 async def get_cookies() -> Dict[str, str]:
-    try:
-        response = requests.get('https://replicate.com/levelsio/neon-tokyo', headers={
+    async with aiohttp.ClientSession() as session:
+        async with session.get('https://replicate.com/levelsio/neon-tokyo', headers={
             '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'
-        })
-        return dict(response.cookies)
-    except Exception as e:
-        print(f'Error fetching the page: {e}')
-        return {}
+        }) as response:
+            return dict(response.cookies)
 
 async def initiate_upload(cookies: Dict[str, str], filename: str, content_type: str) -> Dict:
     url = f'https://replicate.com/api/upload/{filename}?content_type={content_type}'
-    try:
-        response = requests.post(url, cookies=cookies, headers={
+    async with aiohttp.ClientSession() as session:
+        async with session.post(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',
@@ -1047,31 +1019,37 @@ async def initiate_upload(cookies: Dict[str, str], filename: str, content_type:
             'Sec-Fetch-Site': 'same-origin',
             'Sec-GPC': '1',
             'Priority': 'u=1, i'
-        })
-        return response.json()
-    except Exception as e:
-        print(f'Error initiating upload: {e}')
-        raise
-
-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
-
-async def retry_upload(upload_url: str, file_content: bytes, content_type: str, max_retries: int = 5, delay: int = 1) -> bool:
-    while True:
-        try:
-            success = await upload_file(upload_url, file_content, content_type)
-            if success:
-                return True
-            print("Upload failed. Retrying...")
-        except Exception as e:
-            print(f"Error during upload: {e}")
-        
-        await asyncio.sleep(delay)
-        delay = min(delay * 2, 60)
-    
-    return False
+        }) as response:
+            return await response.json()
+
+async def chunked_upload(upload_url: str, file: UploadFile, content_type: str, chunk_size: int = 1024 * 1024) -> bool:
+    async with aiohttp.ClientSession() as session:
+        file_size = await file.seek(0, 2)
+        await file.seek(0)
+
+        for start in range(0, file_size, chunk_size):
+            end = min(start + chunk_size, file_size)
+            chunk = await file.read(end - start)
+
+            headers = {
+                'Content-Type': content_type,
+                'Content-Range': f'bytes {start}-{end-1}/{file_size}'
+            }
+
+            for attempt in range(5):  # 5 retries
+                try:
+                    async with session.put(upload_url, data=chunk, headers=headers) as response:
+                        if response.status == 200:
+                            break
+                except aiohttp.ClientError:
+                    if attempt == 4:  # Last attempt
+                        return False
+                    await asyncio.sleep(2 ** attempt)  # Exponential backoff
+            else:
+                return False
+
+    return True
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)