up1

Sleeping

App Files Files Community

rkihacker commited on 12 days ago

Commit

979306d

verified ·

1 Parent(s): ec82bbb

Update app.py

Browse files

Files changed (1) hide show

app.py +96 -90

app.py CHANGED Viewed

@@ -5,9 +5,11 @@ import asyncio
 from typing import Dict
 import os
 import mimetypes
 app = FastAPI()
 HTML_CONTENT = """
 <!DOCTYPE html>
 <html lang="en">
@@ -697,45 +699,46 @@ 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, 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) {
@@ -754,11 +757,8 @@ HTML_CONTENT = """
             return container;
         }
-        function updateProgress(event, progressBar) {
-            if (event.lengthComputable) {
-                const percentComplete = (event.loaded / event.total) * 100;
-                progressBar.style.width = percentComplete + '%';
-            }
         }
         function resetUploadState() {
@@ -946,12 +946,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 cookies from Replicate."}, 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:
@@ -960,29 +960,32 @@ 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."}, status_code=500)
-    # Log the real Replicate URL
-    print(f"Real Replicate URL: {upload_result['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 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.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')
@@ -1003,6 +1006,7 @@ async def handle_file_stream(path: str, request: Request):
         if response.status_code == 206:
             response_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:
@@ -1014,7 +1018,8 @@ async def handle_file_stream(path: str, request: Request):
 @app.get("/embed")
-async def embed_video(url: str, thumbnail: str):
     html = f'''
     <html>
     <head>
@@ -1032,80 +1037,81 @@ async def embed_video(url: str, thumbnail: str):
         <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'
         })
         response.raise_for_status()
         return dict(response.cookies)
     except requests.exceptions.RequestException 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': 'gzip, deflate, br',
-            'Sec-Fetch-Dest': 'empty',
-            'Sec-Fetch-Mode': 'cors',
-            'Sec-Fetch-Site': 'same-origin',
-        })
         response.raise_for_status()
         return response.json()
-    except requests.exceptions.RequestException as e:
-        print(f'Error initiating upload: {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 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:
     for attempt in range(max_retries):
-        try:
-            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...")
-        except Exception as e:
-            print(f"Error during upload attempt {attempt + 1}: {e}")
         await asyncio.sleep(delay)
-        delay = min(delay * 2, 60)
     return False

 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">
             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) {
             return container;
         }
+        function updateProgress(progressBar, percent) {
+            progressBar.style.width = percent + '%';
         }
         function resetUploadState() {
     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:
     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')
         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:
 @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>
         <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