Spaces:

albumup
/

file

Sleeping

App Files Files Community

albumup commited on Jan 17, 2025

Commit

c9d20aa

verified ·

1 Parent(s): 7b356ed

Update app.py

Browse files

Files changed (1) hide show

app.py +93 -351

app.py CHANGED Viewed

@@ -1,18 +1,62 @@
-from fastapi import FastAPI, File, UploadFile, Request, Form
 from fastapi.responses import HTMLResponse, RedirectResponse, StreamingResponse
-from typing import List
 import requests
 import asyncio
 import os
 import uuid
 import json
 from datetime import datetime
-import mimetypes
 app = FastAPI()
-# In-memory storage for albums
-albums = {}
 HTML_CONTENT = """
 <!DOCTYPE html>
@@ -22,35 +66,23 @@ HTML_CONTENT = """
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>File Upload</title>
     <style>
-        .container {{
             max-width: 800px;
             margin: 0 auto;
             padding: 20px;
-        }}
-        .upload-form {{
             margin-bottom: 20px;
             padding: 20px;
             border: 1px solid #ddd;
             border-radius: 5px;
-        }}
-        .preview {{
-            margin-top: 20px;
-        }}
-        .search-form {{
             margin: 20px 0;
             padding: 20px;
             border: 1px solid #ddd;
             border-radius: 5px;
-        }}
-        .album-list {{
-            margin-top: 20px;
-        }}
-        .album-item {{
-            padding: 10px;
-            border: 1px solid #ddd;
-            margin-bottom: 10px;
-            border-radius: 5px;
-        }}
     </style>
 </head>
 <body>
@@ -66,20 +98,13 @@ HTML_CONTENT = """
             </form>
         </div>
-        <!-- Single File Upload -->
-        <div class="upload-form">
-            <h2>Single File Upload</h2>
-            <form action="/upload" method="post" enctype="multipart/form-data">
-                <input type="file" name="file" accept="*/*" required>
-                <button type="submit">Upload</button>
-            </form>
-        </div>
         <!-- Album Upload -->
         <div class="upload-form">
             <h2>Create Album</h2>
             <form action="/album/create" method="post" enctype="multipart/form-data">
                 <input type="text" name="album_name" placeholder="Album Name" required><br><br>
                 <input type="file" name="files" accept="*/*" multiple required><br><br>
                 <button type="submit">Create Album</button>
             </form>
@@ -89,267 +114,28 @@ HTML_CONTENT = """
 </html>
 """
-ALBUM_VIEW_HTML = """
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Album View - {album_name}</title>
-    <style>
-        .container {{
-            max-width: 800px;
-            margin: 0 auto;
-            padding: 20px;
-        }}
-        .file-grid {{
-            display: grid;
-            grid-template-columns: repeat(auto-fill, minmax(250px, 1fr));
-            gap: 20px;
-        }}
-        .file-item {{
-            border: 1px solid #ddd;
-            padding: 10px;
-            text-align: center;
-            border-radius: 5px;
-        }}
-        .download-all {{
-            margin: 20px 0;
-        }}
-        .back-link {{
-            margin-bottom: 20px;
-            display: block;
-        }}
-        .button {{
-            display: inline-block;
-            padding: 8px 16px;
-            background-color: #007bff;
-            color: white;
-            text-decoration: none;
-            border-radius: 4px;
-            margin: 5px;
-        }}
-        .button:hover {{
-            background-color: #0056b3;
-        }}
-        .preview-container {{
-            margin-bottom: 10px;
-            max-width: 100%;
-            height: 200px;
-            overflow: hidden;
-            display: flex;
-            align-items: center;
-            justify-content: center;
-            background-color: #f8f9fa;
-            border-radius: 4px;
-        }}
-        .preview-container img {{
-            max-width: 100%;
-            max-height: 100%;
-            object-fit: contain;
-        }}
-        .preview-container video {{
-            max-width: 100%;
-            max-height: 100%;
-            object-fit: contain;
-        }}
-        .modal {{
-            display: none;
-            position: fixed;
-            z-index: 1000;
-            top: 0;
-            left: 0;
-            width: 100%;
-            height: 100%;
-            background-color: rgba(0,0,0,0.9);
-            overflow: auto;
-        }}
-        .modal-content {{
-            margin: auto;
-            display: block;
-            max-width: 90%;
-            max-height: 90vh;
-            margin-top: 50px;
-        }}
-        .close {{
-            position: absolute;
-            right: 35px;
-            top: 15px;
-            color: #f1f1f1;
-            font-size: 40px;
-            font-weight: bold;
-            cursor: pointer;
-        }}
-    </style>
-    <script>
-        function openModal(url) {{
-            const modal = document.getElementById('previewModal');
-            const modalContent = document.getElementById('modalContent');
-            const contentType = getContentType(url);
-            if (contentType === 'image') {{
-                modalContent.innerHTML = `<img src="${{url}}" style="max-width:100%;max-height:90vh;">`;
-            }} else if (contentType === 'video') {{
-                modalContent.innerHTML = `<video controls style="max-width:100%;max-height:90vh;">
-                    <source src="${{url}}" type="video/mp4">
-                    Your browser does not support the video tag.
-                </video>`;
-            }}
-            modal.style.display = 'block';
-        }}
-        function closeModal() {{
-            const modal = document.getElementById('previewModal');
-            modal.style.display = 'none';
-            const modalContent = document.getElementById('modalContent');
-            modalContent.innerHTML = '';
-        }}
-        function getContentType(url) {{
-            const ext = url.split('.').pop().toLowerCase();
-            if (['jpg', 'jpeg', 'png', 'gif', 'webp'].includes(ext)) return 'image';
-            if (['mp4', 'webm', 'ogg'].includes(ext)) return 'video';
-            return 'other';
-        }}
-    </script>
-</head>
-<body>
-    <div class="container">
-        <a href="/" class="back-link button">← Back to Home</a>
-        <h1>{album_name}</h1>
-        <div class="download-all">
-            <a href="/album/{album_id}/download" class="button" target="_blank">Download All Files</a>
-        </div>
-        <div class="file-grid">
-            {file_list}
-        </div>
-    </div>
-    <!-- Modal for previews -->
-    <div id="previewModal" class="modal" onclick="closeModal()">
-        <span class="close">&times;</span>
-        <div id="modalContent" class="modal-content">
-        </div>
-    </div>
-</body>
-</html>
-"""
-SEARCH_RESULTS_HTML = """
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Search Results</title>
-    <style>
-        .container {{
-            max-width: 800px;
-            margin: 0 auto;
-            padding: 20px;
-        }}
-        .album-item {{
-            border: 1px solid #ddd;
-            padding: 15px;
-            margin-bottom: 15px;
-            border-radius: 5px;
-        }}
-        .back-link {{
-            margin-bottom: 20px;
-            display: block;
-        }}
-        .button {{
-            display: inline-block;
-            padding: 8px 16px;
-            background-color: #007bff;
-            color: white;
-            text-decoration: none;
-            border-radius: 4px;
-            margin: 5px;
-        }}
-        .button:hover {{
-            background-color: #0056b3;
-        }}
-    </style>
-</head>
-<body>
-    <div class="container">
-        <a href="/" class="back-link button">← Back to Home</a>
-        <h1>Search Results</h1>
-        <p>Found {result_count} albums for "{query}"</p>
-        <div class="search-results">
-            {results}
-        </div>
-    </div>
-</body>
-</html>
-"""
-def get_file_type(filename):
-    mime_type, _ = mimetypes.guess_type(filename)
-    if mime_type:
-        if mime_type.startswith('image/'):
-            return 'image'
-        elif mime_type.startswith('video/'):
-            return 'video'
-    return 'other'
 @app.get("/", response_class=HTMLResponse)
 async def index():
     return HTML_CONTENT
-@app.get("/search", response_class=HTMLResponse)
-async def search_albums(query: str = ""):
-    query = query.lower()
     matching_albums = {
-        album_id: album for album_id, album in albums.items()
-        if query in album['name'].lower()
     }
-    results_html = ""
-    for album_id, album in matching_albums.items():
-        results_html += f"""
-        <div class="album-item">
-            <h3>{album['name']}</h3>
-            <p>Created: {album['created_at']}</p>
-            <p>Files: {len(album['files'])}</p>
-            <a href="/album/{album_id}" class="button">View Album</a>
-        </div>
-        """
-    return SEARCH_RESULTS_HTML.format(
-        query=query,
-        result_count=len(matching_albums),
-        results=results_html
-    )
-@app.post("/upload")
-async def handle_upload(request: Request, file: UploadFile = File(...)):
-    if not file:
-        return {"error": "No file uploaded"}, 400
-    cookies = await get_cookies()
-    if 'csrftoken' not in cookies or 'sessionid' not in cookies:
-        return {"error": "Failed to get cookies"}, 500
-    upload_result = await initiate_upload(cookies, file.filename, file.content_type)
-    if not upload_result or 'upload_url' not in upload_result:
-        return {"error": "Failed to initiate upload"}, 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 {"error": "Upload failed"}, 500
-    base_url = str(request.base_url).rstrip('/')
-    redirect_url = f"{base_url}/upload/{upload_result['serving_url'].split('/pbxt/')[1]}"
-    return RedirectResponse(url=redirect_url, status_code=303)
 @app.post("/album/create")
 async def create_album(
     request: Request,
     album_name: str = Form(...),
     files: List[UploadFile] = File(...)
 ):
     album_id = str(uuid.uuid4())
@@ -372,76 +158,48 @@ async def create_album(
                     'uploaded_at': datetime.now().isoformat()
                 })
-    albums[album_id] = {
         'name': album_name,
         'created_at': datetime.now().isoformat(),
-        'files': album_files
     }
     base_url = str(request.base_url).rstrip('/')
     return RedirectResponse(url=f"{base_url}/album/{album_id}", status_code=303)
-@app.get("/album/{album_id}", response_class=HTMLResponse)
-async def view_album(album_id: str):
-    if album_id not in albums:
-        return "Album not found", 404
-    album = albums[album_id]
-    file_list_html = ""
-    for file in album['files']:
-        file_url = f"/upload/{file['path']}"
-        file_type = get_file_type(file['filename'])
-        preview_html = ""
-        if file_type == 'image':
-            preview_html = f"""
-                <div class="preview-container">
-                    <img src="{file_url}" alt="{file['filename']}" onclick="openModal('{file_url}')">
-                </div>
-            """
-        elif file_type == 'video':
-            preview_html = f"""
-                <div class="preview-container">
-                    <video onclick="openModal('{file_url}')" style="cursor: pointer;">
-                        <source src="{file_url}" type="{file['content_type']}">
-                        Your browser does not support the video tag.
-                    </video>
-                </div>
-            """
-        else:
-            preview_html = f"""
-                <div class="preview-container">
-                    <p>No preview available for {file['filename']}</p>
-                </div>
-            """
-        file_list_html += f"""
-        <div class="file-item">
-            {preview_html}
-            <p>{file['filename']}</p>
-            <a href="{file_url}" class="button" onclick="openModal('{file_url}'); return false;">View</a>
-            <a href="{file_url}?download=true" class="button" target="_blank">Download</a>
-        </div>
-        """
-    return ALBUM_VIEW_HTML.format(
-        album_name=album['name'],
-        album_id=album_id,
-        file_list=file_list_html
-    )
 @app.get("/album/{album_id}/download")
 async def download_album(album_id: str):
-    if album_id not in albums:
-        return {"error": "Album not found"}, 404
     import io
     import zipfile
     zip_buffer = io.BytesIO()
     with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
-        for file in albums[album_id]['files']:
             response = requests.get(f"https://replicate.delivery/pbxt/{file['path']}")
             zip_file.writestr(file['filename'], response.content)
@@ -451,27 +209,11 @@ async def download_album(album_id: str):
         io.BytesIO(zip_buffer.getvalue()),
         media_type="application/zip",
         headers={
-            "Content-Disposition": f"attachment; filename={albums[album_id]['name']}.zip"
         }
     )
-@app.get("/upload/{path:path}")
-async def handle_stream(path: str, request: Request):
-    original_url = f'https://replicate.delivery/pbxt/{path}'
-    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'] = '*'
-    return StreamingResponse(generate(), headers=headers, status_code=response.status_code)
 async def get_cookies():
     try:
         response = requests.get('https://replicate.com/levelsio/neon-tokyo', headers={

+from fastapi import FastAPI, File, UploadFile, Request, Form, HTTPException, Depends
 from fastapi.responses import HTMLResponse, RedirectResponse, StreamingResponse
+from typing import List, Optional
+from pydantic import BaseModel
+from pydantic_settings import BaseSettings
 import requests
 import asyncio
 import os
 import uuid
 import json
 from datetime import datetime
+import httpx
+from functools import lru_cache
+class Settings(BaseSettings):
+    database_url: str = "https://dataerrr99.deno.dev"
+    app_name: str = "Album Sharing App"
+@lru_cache
+def get_settings():
+    return Settings()
+class Album(BaseModel):
+    id: str
+    name: str
+    created_at: str
+    is_private: bool
+    files: List[dict]
+    owner: str
 app = FastAPI()
+# In-memory cache for faster access
+albums_cache = {}
+async def sync_with_database():
+    settings = get_settings()
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.get(f"{settings.database_url}/albums")
+            if response.status_code == 200:
+                data = response.json()
+                albums_cache.clear()
+                albums_cache.update(data)
+    except Exception as e:
+        print(f"Database sync error: {e}")
+async def save_to_database(album_id: str, album_data: dict):
+    settings = get_settings()
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                f"{settings.database_url}/albums",
+                json={album_id: album_data}
+            )
+            if response.status_code != 200:
+                raise HTTPException(status_code=500, detail="Failed to save to database")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
 HTML_CONTENT = """
 <!DOCTYPE html>
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>File Upload</title>
     <style>
+        .container {
             max-width: 800px;
             margin: 0 auto;
             padding: 20px;
+        }
+        .upload-form {
             margin-bottom: 20px;
             padding: 20px;
             border: 1px solid #ddd;
             border-radius: 5px;
+        }
+        .search-form {
             margin: 20px 0;
             padding: 20px;
             border: 1px solid #ddd;
             border-radius: 5px;
+        }
     </style>
 </head>
 <body>
             </form>
         </div>
         <!-- Album Upload -->
         <div class="upload-form">
             <h2>Create Album</h2>
             <form action="/album/create" method="post" enctype="multipart/form-data">
                 <input type="text" name="album_name" placeholder="Album Name" required><br><br>
+                <input type="checkbox" name="is_private" id="is_private">
+                <label for="is_private">Make Album Private</label><br><br>
                 <input type="file" name="files" accept="*/*" multiple required><br><br>
                 <button type="submit">Create Album</button>
             </form>
 </html>
 """
+@app.on_event("startup")
+async def startup_event():
+    await sync_with_database()
 @app.get("/", response_class=HTMLResponse)
 async def index():
     return HTML_CONTENT
+@app.get("/search")
+async def search_albums(query: str = "", include_private: bool = False):
     matching_albums = {
+        album_id: album for album_id, album in albums_cache.items()
+        if (query.lower() in album['name'].lower() and
+            (not album['is_private'] or include_private))
     }
+    return {"albums": matching_albums}
 @app.post("/album/create")
 async def create_album(
     request: Request,
     album_name: str = Form(...),
+    is_private: bool = Form(False),
     files: List[UploadFile] = File(...)
 ):
     album_id = str(uuid.uuid4())
                     'uploaded_at': datetime.now().isoformat()
                 })
+    album_data = {
         'name': album_name,
         'created_at': datetime.now().isoformat(),
+        'is_private': is_private,
+        'files': album_files,
+        'owner': 'anonymous'  # You can implement user authentication later
     }
+    albums_cache[album_id] = album_data
+    await save_to_database(album_id, album_data)
     base_url = str(request.base_url).rstrip('/')
     return RedirectResponse(url=f"{base_url}/album/{album_id}", status_code=303)
+@app.get("/album/{album_id}")
+async def view_album(album_id: str, request: Request):
+    if album_id not in albums_cache:
+        raise HTTPException(status_code=404, detail="Album not found")
+    album = albums_cache[album_id]
+    if album['is_private']:
+        # Implement authentication check here
+        pass
+    return album
 @app.get("/album/{album_id}/download")
 async def download_album(album_id: str):
+    if album_id not in albums_cache:
+        raise HTTPException(status_code=404, detail="Album not found")
+    album = albums_cache[album_id]
+    if album['is_private']:
+        # Implement authentication check here
+        pass
     import io
     import zipfile
     zip_buffer = io.BytesIO()
     with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+        for file in album['files']:
             response = requests.get(f"https://replicate.delivery/pbxt/{file['path']}")
             zip_file.writestr(file['filename'], response.content)
         io.BytesIO(zip_buffer.getvalue()),
         media_type="application/zip",
         headers={
+            "Content-Disposition": f"attachment; filename={album['name']}.zip"
         }
     )
+# Helper functions remain the same as in previous version
 async def get_cookies():
     try:
         response = requests.get('https://replicate.com/levelsio/neon-tokyo', headers={