Spaces:

coollsd
/

fileuploader

Paused

App Files Files Community

coollsd commited on Sep 19, 2024

Commit

d82c03c

verified ·

1 Parent(s): 4c400a7

Update app.py

Browse files

Files changed (1) hide show

app.py +32 -80

app.py CHANGED Viewed

@@ -1,18 +1,12 @@
-from fastapi import FastAPI, File, UploadFile, Request, Form
 from fastapi.responses import HTMLResponse, JSONResponse, StreamingResponse
 import requests
 import asyncio
 from typing import Dict
-import os
-import shutil
-import mimetypes
 app = FastAPI()
-# Directory to store temporary chunks and final files
-UPLOAD_DIR = "uploads"
-os.makedirs(UPLOAD_DIR, exist_ok=True)
 HTML_CONTENT = """
 <!DOCTYPE html>
 <html lang="en">
@@ -618,87 +612,29 @@ HTML_CONTENT = """
 async def index():
     return HTML_CONTENT
-@app.post("/upload_chunk")
-async def upload_chunk(
-    fileId: str = Form(...),
-    fileName: str = Form(...),
-    totalChunks: int = Form(..., gt=0),
-    chunkIndex: int = Form(..., ge=0),
-    chunkSize: int = Form(..., gt=0),
-    chunkData: UploadFile = File(...)
-):
-    """
-    Endpoint to handle each chunk upload.
-    """
-    # Create a temporary directory based on fileId to store chunks
-    temp_dir = os.path.join(UPLOAD_DIR, fileId)
-    os.makedirs(temp_dir, exist_ok=True)
-    chunk_file_path = os.path.join(temp_dir, f"chunk_{chunkIndex}")
-    # Save the chunk to the temporary directory
-    with open(chunk_file_path, "wb") as f:
-        content = await chunkData.read()
-        f.write(content)
-    return {"status": "chunk received"}
-@app.post("/finalize_upload")
-async def finalize_upload(data: Dict):
-    fileId = data.get('fileId')
-    fileName = data.get('fileName')
-    temp_dir = os.path.join(UPLOAD_DIR, fileId)
-    if not os.path.exists(temp_dir):
-        return JSONResponse(content={"error": "Upload session does not exist"}, status_code=400)
-    # Get list of chunk files and sort them
-    chunk_files = [os.path.join(temp_dir, f) for f in os.listdir(temp_dir) if f.startswith('chunk_')]
-    if not chunk_files:
-        return JSONResponse(content={"error": "No chunks found for this file"}, status_code=400)
-    chunk_files.sort(key=lambda x: int(os.path.basename(x).split("_")[-1]))
-    # Combine chunks into the final file
-    final_file_path = os.path.join(temp_dir, fileName)
-    with open(final_file_path, "wb") as outfile:
-        for chunk_file in chunk_files:
-            with open(chunk_file, "rb") as infile:
-                outfile.write(infile.read())
-    # Proceed with your existing upload logic using 'final_file_path'
-    # For example, read the file and upload to external service
-    # Read the combined file content
-    with open(final_file_path, "rb") as f:
-        file_content = f.read()
-    # Obtain cookies and initiate upload as before
     cookies = await get_cookies()
     if 'csrftoken' not in cookies or 'sessionid' not in cookies:
         return JSONResponse(content={"error": "Failed to obtain necessary cookies"}, status_code=500)
-    # Get the content type based on the file extension
-    content_type = get_content_type(fileName)
-    upload_result = await initiate_upload(cookies, fileName, content_type)
     if not upload_result or 'upload_url' not in upload_result:
         return JSONResponse(content={"error": "Failed to initiate upload"}, status_code=500)
-    upload_success = await retry_upload(upload_result['upload_url'], file_content, content_type)
     if not upload_success:
         return JSONResponse(content={"error": "File upload failed after multiple attempts"}, status_code=500)
     original_url = upload_result['serving_url']
     mirrored_url = f"/rbxg/{original_url.split('/pbxt/')[1]}"
-    # Optionally, remove the temporary directory
-    shutil.rmtree(temp_dir)
     return JSONResponse(content={"url": mirrored_url})
-def get_content_type(filename: str) -> str:
-    return mimetypes.guess_type(filename)[0] or 'application/octet-stream'
 @app.get("/rbxg/{path:path}")
 async def handle_video_stream(path: str, request: Request):
     original_url = f'https://replicate.delivery/pbxt/{path}'
@@ -737,12 +673,25 @@ async def embed_video(url: str, thumbnail: str):
         <meta property="og:image:width" content="1280">
         <meta property="og:image:height" content="720">
         <meta property="og:image:type" content="image/png">
     </head>
     <body>
-        <video controls autoplay>
             <source src="{url}" type="video/mp4">
             Your browser does not support the video tag.
         </video>
     </body>
     </html>
     '''
@@ -768,12 +717,17 @@ async def initiate_upload(cookies: Dict[str, str], filename: str, content_type:
             'Origin': 'https://replicate.com',
             'Accept': '*/*',
             'Accept-Language': 'en-US,en;q=0.5',
-            'Accept-Encoding': 'identity'
         })
         return response.json()
     except Exception as e:
         print(f'Error initiating upload: {e}')
-        return {}
 async def upload_file(upload_url: str, file_content: bytes, content_type: str) -> bool:
     try:
@@ -784,8 +738,7 @@ async def upload_file(upload_url: str, file_content: bytes, content_type: str) -
         return False
 async def retry_upload(upload_url: str, file_content: bytes, content_type: str, max_retries: int = 5, delay: int = 1) -> bool:
-    retries = 0
-    while retries < max_retries:
         try:
             success = await upload_file(upload_url, file_content, content_type)
             if success:
@@ -796,6 +749,5 @@ 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
-        retries += 1
     return False

+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">
 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 to obtain necessary 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 initiate 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": "File upload failed after multiple 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):
     original_url = f'https://replicate.delivery/pbxt/{path}'
         <meta property="og:image:width" content="1280">
         <meta property="og:image:height" content="720">
         <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>
     '''
             '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:
         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:
         await asyncio.sleep(delay)
         delay = min(delay * 2, 60)  # Exponential backoff, capped at 60 seconds
     return False