Spaces:

coollsd
/

fileuploader

Running

App Files Files Community

coollsd commited on about 15 hours ago

Commit

5d1fa44

•

1 Parent(s): 5e36128

Update app.py

Browse files

Files changed (1) hide show

app.py +124 -130

app.py CHANGED Viewed

@@ -1,17 +1,12 @@
-from fastapi import FastAPI, File, UploadFile, Request, HTTPException
 from fastapi.responses import HTMLResponse, JSONResponse, StreamingResponse
-import aiohttp
 import asyncio
 from typing import Dict
-import io
-import logging
 app = FastAPI()
-# Set up logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
 HTML_CONTENT = """
 <!DOCTYPE html>
 <html lang="en">
@@ -428,7 +423,7 @@ HTML_CONTENT = """
             gap: 5px;
         }
-                        .quick-open-modal {
             display: none;
             position: fixed;
             z-index: 4;
@@ -440,7 +435,7 @@ HTML_CONTENT = """
             overflow: auto;
         }
-                .quick-open-content {
             margin: 5% auto;
             padding: 20px;
             width: 90%;
@@ -701,28 +696,44 @@ HTML_CONTENT = """
             const formData = new FormData();
             formData.append('file', file);
-            try {
-                const response = await fetch('/upload', {
-                    method: 'POST',
-                    body: formData
-                });
-                if (!response.ok) {
-                    throw new Error(`HTTP error! status: ${response.status}`);
-                }
-                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();
             }
         }
@@ -742,13 +753,19 @@ HTML_CONTENT = """
             return container;
         }
         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) {
@@ -836,7 +853,7 @@ HTML_CONTENT = """
                 };
                 actionsContainer.appendChild(copyBtn);
-                const openBtn = document.createElement('button');
                 openBtn.textContent = 'Open';
                 openBtn.className = 'small-btn';
                 openBtn.onclick = () => {
@@ -869,7 +886,7 @@ HTML_CONTENT = """
             historyModal.style.display = "block";
         }
-                function quickOpen(url, fileName) {
             quickOpenContent.innerHTML = '';
             const fullUrl = window.location.origin + url;
@@ -914,6 +931,7 @@ HTML_CONTENT = """
 </body>
 </html>
 """
 @app.get("/", response_class=HTMLResponse)
 async def index():
     return HTML_CONTENT
@@ -921,28 +939,25 @@ async def index():
 @app.post("/upload")
 async def handle_upload(file: UploadFile = File(...)):
     if not file.filename:
-        raise HTTPException(status_code=400, detail="No file selected.")
-    try:
-        cookies = await get_cookies()
-        if 'csrftoken' not in cookies or 'sessionid' not in cookies:
-            raise HTTPException(status_code=500, detail="Failed to get 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")
-        upload_success = await chunked_upload(upload_result['upload_url'], file, file.content_type)
-        if not upload_success:
-            raise HTTPException(status_code=500, detail="Failed to upload file after multiple attempts")
-        original_url = upload_result['serving_url']
-        mirrored_url = f"/rbxg/{original_url.split('/pbxt/')[1]}"
-        return JSONResponse(content={"url": mirrored_url})
-    except Exception as e:
-        logger.error(f"Upload error: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))
 @app.get("/rbxg/{path:path}")
 async def handle_video_stream(path: str, request: Request):
@@ -950,17 +965,20 @@ async def handle_video_stream(path: str, request: Request):
     range_header = request.headers.get('Range')
     headers = {'Range': range_header} if range_header else {}
-    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'
-            if response.status == 206:
-                headers['Content-Range'] = response.headers.get('Content-Range')
-            return StreamingResponse(io.BytesIO(content), status_code=response.status, headers=headers)
 @app.get("/embed")
 async def embed_video(url: str, thumbnail: str):
@@ -1004,80 +1022,56 @@ async def embed_video(url: str, thumbnail: str):
     return HTMLResponse(content=html)
 async def get_cookies() -> Dict[str, str]:
-    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'
-        }) as response:
-            return {k: v.value for k, v in response.cookies.items()}
 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}'
-    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'
-    }
-    async with aiohttp.ClientSession() as session:
-        async with session.post(url, cookies=cookies, headers=headers) as response:
-            if response.status != 200:
-                raise HTTPException(status_code=response.status, detail=f"Failed to initiate upload: {await response.text()}")
-            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 get_file_size(file)
-        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 in [200, 201, 204]:
-                            break
-                        elif response.status == 308:  # Resume Incomplete
-                            continue
-                        else:
-                            raise aiohttp.ClientError(f"Unexpected status code: {response.status}")
-                except aiohttp.ClientError as e:
-                    if attempt == 4:  # Last attempt
-                        logger.error(f"Upload failed: {str(e)}")
-                        return False
-                    await asyncio.sleep(2 ** attempt)  # Exponential backoff
-            else:
-                return False
-        # Verify the upload
-        async with session.put(upload_url, headers={'Content-Range': f'bytes */{file_size}'}) as response:
-            if response.status not in [200, 201, 204]:
-                logger.error(f"Upload verification failed: {response.status}")
-                return False
-    return True
-async def get_file_size(file: UploadFile) -> int:
-    size = 0
-    while chunk := await file.read(8192):
-        size += len(chunk)
-    await file.seek(0)
-    return size
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)

+from fastapi import FastAPI, File, UploadFile, Request
 from fastapi.responses import HTMLResponse, JSONResponse, StreamingResponse
+import requests
+import time
 import asyncio
 from typing import Dict
 app = FastAPI()
 HTML_CONTENT = """
 <!DOCTYPE html>
 <html lang="en">
             gap: 5px;
         }
+                .quick-open-modal {
             display: none;
             position: fixed;
             z-index: 4;
             overflow: auto;
         }
+        .quick-open-content {
             margin: 5% auto;
             padding: 20px;
             width: 90%;
             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);
+                    await new Promise((resolve, reject) => {
+                        xhr.onloadend = resolve;
+                        xhr.onerror = reject;
+                    });
+                    break;
+                } catch (error) {
+                    console.error('Upload error:', error);
+                    await new Promise(resolve => setTimeout(resolve, 1000));
                 }
             }
         }
             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';
         }
         function addResultLink(url, fileName) {
                 };
                 actionsContainer.appendChild(copyBtn);
+                                const openBtn = document.createElement('button');
                 openBtn.textContent = 'Open';
                 openBtn.className = 'small-btn';
                 openBtn.onclick = () => {
             historyModal.style.display = "block";
         }
+        function quickOpen(url, fileName) {
             quickOpenContent.innerHTML = '';
             const fullUrl = window.location.origin + url;
 </body>
 </html>
 """
 @app.get("/", response_class=HTMLResponse)
 async def index():
     return HTML_CONTENT
 @app.post("/upload")
 async def handle_upload(file: UploadFile = File(...)):
     if not file.filename:
+        return JSONResponse(content={"error": "No file selected."}, status_code=400)
+    cookies = await get_cookies()
+    if 'csrftoken' not in cookies or 'sessionid' not in cookies:
+        return JSONResponse(content={"error": "Failed"}, 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)
+    file_content = await file.read()
+    upload_success = await retry_upload(upload_result['upload_url'], file_content, file.content_type)
+    if not upload_success:
+        return JSONResponse(content={"error": "FAILED GOD MAN AFTER alot of attempts"}, status_code=500)
+    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):
     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
+    headers = dict(response.headers)
+    headers['Access-Control-Allow-Origin'] = '*'
+    headers['Content-Disposition'] = 'inline'
+    if response.status_code == 206:
+        headers['Content-Range'] = response.headers.get('Content-Range')
+    return StreamingResponse(generate(), status_code=response.status_code, headers=headers)
 @app.get("/embed")
 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={
             '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 {}
 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={
+            '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 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