up1

Sleeping

App Files Files Community

rkihacker commited on 7 days ago

Commit

25a03e7

verified ·

1 Parent(s): 979306d

Update app.py

Browse files

Files changed (1) hide show

app.py +113 -128

app.py CHANGED Viewed

@@ -1,15 +1,14 @@
 from fastapi import FastAPI, File, UploadFile, Request
-from fastapi.responses import HTMLResponse, JSONResponse, StreamingResponse
 import requests
 import asyncio
 from typing import Dict
 import os
 import mimetypes
-import json
 app = FastAPI()
-# The HTML_CONTENT remains the same as your provided version.
 HTML_CONTENT = """
 <!DOCTYPE html>
 <html lang="en">
@@ -446,7 +445,7 @@ HTML_CONTENT = """
             text-align: center;
         }
-        .quick-open-content img,
         .quick-open-content video,
         .quick-open-content audio {
             max-width: 100%;
@@ -699,46 +698,45 @@ HTML_CONTENT = """
             const formData = new FormData();
             formData.append('file', file);
-            const xhr = new XMLHttpRequest();
-            xhr.open('POST', '/upload', true);
-            xhr.upload.onprogress = (event) => {
-                if (event.lengthComputable) {
-                    const percentComplete = (event.loaded / event.total) * 100;
-                    updateProgress(progressBar.querySelector('.progress'), percentComplete);
-                }
-            };
-            xhr.onload = function() {
-                loadingSpinner.style.display = 'none';
-                uploadBtn.disabled = false;
-                if (xhr.status === 200) {
-                    const response = JSON.parse(xhr.responseText);
-                    if (response.url) {
-                        addResultLink(response.url, file.name, response.originalExtension);
-                        saveToHistory(file.name, response.url, response.originalExtension);
-                        resetUploadState();
-                    } else {
-                        alert('Upload failed: ' + response.error);
-                    }
-                } else {
-                    try {
-                        const errorResponse = JSON.parse(xhr.responseText);
-                        alert(`Error: ${errorResponse.error || 'An unknown error occurred.'}`);
-                    } catch (e) {
-                        alert(`An unexpected error occurred. Status: ${xhr.status}`);
-                    }
-                }
-            };
-            xhr.onerror = function() {
-                loadingSpinner.style.display = 'none';
-                uploadBtn.disabled = false;
-                alert('Network error occurred. Please try again.');
-            };
-            xhr.send(formData);
         }
         function createProgressBar(fileName) {
@@ -757,8 +755,11 @@ HTML_CONTENT = """
             return container;
         }
-        function updateProgress(progressBar, percent) {
-            progressBar.style.width = percent + '%';
         }
         function resetUploadState() {
@@ -888,7 +889,7 @@ HTML_CONTENT = """
             historyModal.style.display = "block";
         }
-        function quickOpen(url, fileName, originalExtension) {
             quickOpenContent.innerHTML = '';
             const fullUrl = window.location.origin + url;
@@ -946,12 +947,12 @@ 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 to get authentication cookies from Replicate."}, status_code=500)
-    original_extension = os.path.splitext(file.filename)[1][1:].lower()
     supported_types = ['mp4', 'png', 'jpg', 'jpeg', 'gif', 'mp3', 'pdf', 'txt']
-    if original_extension in supported_types:
         temp_filename = file.filename
         content_type = file.content_type
     else:
@@ -960,66 +961,52 @@ async def handle_upload(file: UploadFile = File(...)):
     upload_result = await initiate_upload(cookies, temp_filename, content_type)
     if not upload_result or 'upload_url' not in upload_result:
-        return JSONResponse(content={"error": "Failed to initiate upload with Replicate. The endpoint may be protected or changed."}, status_code=500)
-    # Log the real Replicate URL for debugging
-    print(f"Real Replicate Serving URL: {upload_result.get('serving_url')}")
     file_content = await file.read()
     upload_success = await retry_upload(upload_result['upload_url'], file_content, content_type)
     if not upload_success:
-        return JSONResponse(content={"error": "File upload to Replicate's storage failed after multiple attempts."}, status_code=500)
     original_url = upload_result['serving_url']
     mirrored_url = f"/upload/{original_url.split('/pbxt/')[1]}"
-    if original_extension not in supported_types:
-        # If the original file was unsupported, the mirrored URL from replicate will have .png, remove it.
         mirrored_url = mirrored_url.replace('.png', '')
     return JSONResponse(content={"url": mirrored_url, "originalExtension": original_extension})
 @app.get("/upload/{path:path}")
 async def handle_file_stream(path: str, request: Request):
     original_url = f'https://replicate.delivery/pbxt/{path}'
-    # If the path doesn't have a common extension, it's likely an unsupported type we wrapped in .png
-    if not any(path.lower().endswith(f".{ext}") for ext in ['png', 'jpg', 'jpeg', 'gif', 'mp4', 'mp3', 'pdf', 'txt']):
         original_url += '.png'
     range_header = request.headers.get('Range')
     headers = {'Range': range_header} if range_header else {}
-    try:
-        response = requests.get(original_url, headers=headers, stream=True)
-        response.raise_for_status()
-        def generate():
-            for chunk in response.iter_content(chunk_size=8192):
-                yield chunk
-        response_headers = dict(response.headers)
-        response_headers['Access-Control-Allow-Origin'] = '*'
-        response_headers['Content-Disposition'] = 'inline'
-        if response.status_code == 206:
-            response_headers['Content-Range'] = response.headers.get('Content-Range')
-        # Guess content type from original extension in path for correct browser handling
-        original_extension = os.path.splitext(path)[1][1:]
-        content_type, _ = mimetypes.guess_type(f"file.{original_extension}")
-        if content_type:
-            response_headers['Content-Type'] = content_type
-        return StreamingResponse(generate(), status_code=response.status_code, headers=response_headers)
-    except requests.exceptions.RequestException as e:
-        return JSONResponse(content={"error": f"Failed to fetch file from Replicate: {e}"}, status_code=500)
 @app.get("/embed")
-async def embed_video(url: str, thumbnail: str = "https://i.imgur.com/8liH2yB.png"):
-    # Added a default thumbnail
     html = f'''
     <html>
     <head>
@@ -1037,81 +1024,79 @@ async def embed_video(url: str, thumbnail: str = "https://i.imgur.com/8liH2yB.pn
         <meta property="og:image:type" content="image/png">
         <style>
             body, html {{ margin: 0; padding: 0; height: 100%; background: #000; }}
-            video {{ width: 100%; height: 100%; object-fit: contain; }}
         </style>
     </head>
     <body>
-        <video controls autoplay>
             <source src="{url}" type="video/mp4">
             Your browser does not support the video tag.
         </video>
     </body>
     </html>
     '''
     return HTMLResponse(content=html)
 async def get_cookies() -> Dict[str, str]:
     try:
-        response = requests.get('https://replicate.com/explore', 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'
         })
-        response.raise_for_status()
         return dict(response.cookies)
-    except requests.exceptions.RequestException as e:
-        print(f'Error fetching cookies from Replicate: {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}'
-    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/explore',
-        'Origin': 'https://replicate.com',
-        'Accept': '*/*',
-        'Accept-Language': 'en-US,en;q=0.5',
-        'Accept-Encoding': 'gzip, deflate, br', # More standard encoding
-        'Sec-Fetch-Dest': 'empty',
-        'Sec-Fetch-Mode': 'cors',
-        'Sec-Fetch-Site': 'same-origin',
-    }
     try:
-        response = requests.post(url, cookies=cookies, headers=headers)
-        response.raise_for_status()
         return response.json()
-    except requests.exceptions.HTTPError as http_err:
-        print(f'HTTP error during upload initiation: {http_err}')
-        print(f'Response status: {response.status_code}')
-        print(f'Response text: {response.text}')
-        return {}
-    except json.JSONDecodeError:
-        print('Failed to decode JSON from Replicate API.')
-        print(f'Response status: {response.status_code}')
-        print(f'Response text: {response.text}') # This is the crucial log
-        return {}
     except Exception as e:
-        print(f'An unexpected error occurred during upload initiation: {e}')
-        return {}
-async def upload_file_to_gcs(upload_url: str, file_content: bytes, content_type: str) -> bool:
     try:
         response = requests.put(upload_url, data=file_content, headers={'Content-Type': content_type})
-        response.raise_for_status()
         return response.status_code == 200
-    except requests.exceptions.RequestException as e:
-        print(f'Error during final file upload to GCS: {e}')
         return False
-async def retry_upload(upload_url: str, file_content: bytes, content_type: str, max_retries: int = 3, delay: int = 1) -> bool:
-    for attempt in range(max_retries):
-        success = await upload_file_to_gcs(upload_url, file_content, content_type)
-        if success:
-            return True
-        print(f"Upload attempt {attempt + 1} failed. Retrying in {delay} seconds...")
         await asyncio.sleep(delay)
-        delay *= 2
-    return False

 from fastapi import FastAPI, File, UploadFile, Request
+from fastapi.responses import HTMLResponse, JSONResponse, StreamingResponse, FileResponse
 import requests
+import time
 import asyncio
 from typing import Dict
 import os
 import mimetypes
 app = FastAPI()
 HTML_CONTENT = """
 <!DOCTYPE html>
 <html lang="en">
             text-align: center;
         }
+                .quick-open-content img,
         .quick-open-content video,
         .quick-open-content audio {
             max-width: 100%;
             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, response.originalExtension);
+                                saveToHistory(file.name, response.url, response.originalExtension);
+                                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));
+                }
+            }
         }
         function createProgressBar(fileName) {
             return container;
         }
+        function updateProgress(event, progressBar) {
+            if (event.lengthComputable) {
+                const percentComplete = (event.loaded / event.total) * 100;
+                progressBar.style.width = percentComplete + '%';
+            }
         }
         function resetUploadState() {
             historyModal.style.display = "block";
         }
+                function quickOpen(url, fileName, originalExtension) {
             quickOpenContent.innerHTML = '';
             const fullUrl = window.location.origin + url;
     cookies = await get_cookies()
     if 'csrftoken' not in cookies or 'sessionid' not in cookies:
+        return JSONResponse(content={"error": "Failed"}, status_code=500)
+    original_extension = os.path.splitext(file.filename)[1][1:]
     supported_types = ['mp4', 'png', 'jpg', 'jpeg', 'gif', 'mp3', 'pdf', 'txt']
+    if original_extension.lower() in supported_types:
         temp_filename = file.filename
         content_type = file.content_type
     else:
     upload_result = await initiate_upload(cookies, temp_filename, 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, 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"/upload/{original_url.split('/pbxt/')[1]}"
+    if original_extension.lower() not in supported_types:
         mirrored_url = mirrored_url.replace('.png', '')
     return JSONResponse(content={"url": mirrored_url, "originalExtension": original_extension})
 @app.get("/upload/{path:path}")
 async def handle_file_stream(path: str, request: Request):
     original_url = f'https://replicate.delivery/pbxt/{path}'
+    if not path.lower().endswith(('.png', '.jpg', '.jpeg', '.gif', '.mp4', '.mp3', '.pdf', '.txt')):
         original_url += '.png'
     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')
+    original_extension = os.path.splitext(path)[1][1:]
+    content_type, _ = mimetypes.guess_type(f"file.{original_extension}")
+    if content_type:
+        headers['Content-Type'] = content_type
+    return StreamingResponse(generate(), status_code=response.status_code, headers=headers)
 @app.get("/embed")
+async def embed_video(url: str, thumbnail: str):
     html = f'''
     <html>
     <head>
         <meta property="og:image:type" content="image/png">
         <style>
             body, html {{ margin: 0; padding: 0; height: 100%; background: #000; }}
+            #thumbnail {{ width: 100%; height: 100%; object-fit: contain; cursor: pointer; }}
+            #video {{ display: none; width: 100%; height: 100%; object-fit: contain; }}
         </style>
     </head>
     <body>
+        <img id="thumbnail" src="{thumbnail}" onclick="playVideo()">
+        <video id="video" controls autoplay>
             <source src="{url}" type="video/mp4">
             Your browser does not support the video tag.
         </video>
+        <script>
+            function playVideo() {{
+                document.getElementById('thumbnail').style.display = 'none';
+                document.getElementById('video').style.display = 'block';
+                document.getElementById('video').play();
+            }}
+        </script>
     </body>
     </html>
     '''
     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