Finish minimal working state

Author: aspects19

.gitignore

@@ -1,3 +1,4 @@
 .env
-app/__pycache__/
+__pycache__/
 .venv/
+test.py

app/main.py

@@ -1,25 +1,54 @@
 import uvicorn
-from fastapi import FastAPI, HTTPException, Depends
+from fastapi import FastAPI, Request, HTTPException, Depends
 from sqlalchemy.orm import Session
 import crud, models, schemas
+from pydantic import BaseModel
 from database import engine, get_db, SessionLocal
+from fastapi.responses import HTMLResponse, FileResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+import yt_dlp
+from modules.downloader import download_audio, download_video, get_domain, sanitize_filename
 
 app = FastAPI()
+templates = Jinja2Templates(directory="templates")
 
 models.Base.metadata.create_all(bind=engine)
 
+class VideoRequest(BaseModel):
+    url: str
+
+
 @app.get("/")
-def read_root():
-    return {"Hello": "World"}
+async def home(request: Request):
+    return templates.TemplateResponse("index.html", {"request": request})
+
 
-@app.post("/users/", response_model=schemas.User)
-def create_user(user: schemas.UserCreate, db: Session = Depends(get_db)):
-    return crud.create_user(db=db, user=user)
+@app.post("/download")
+async def download(request: VideoRequest):
+    """ Download a video or audio based on the frontend request """
+    url = request.url
+    ydl_opts = {
+        'quiet': True,
+        'extract_flat': True,
+    }
+    
+    try:
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            info = ydl.extract_info(url, download=False)
+            if not info:
+                raise HTTPException(status_code=400, detail="Could not retrieve video info")
+            
+            video_data = {
+                "title": info.get("title"),
+                "author": info.get("uploader"),
+                "thumbnail": info.get("thumbnail"),
+                "resolutions": sorted(set(f["format_note"] for f in info.get("formats", []) if "format_note" in f))
+            }
+            return video_data
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
 
-@app.get("/users/", response_model=list[schemas.User])
-def read_users(skip:int=0, limit:int=100, db: Session = Depends(get_db)):
-    users = crud.get_users(db, skip=skip, limit=limit)
-    return users
 
 @app.get("/users/{user_id}/",response_model=schemas.User)
 def get_user(user_id:int, db:Session=Depends(get_db)):

app/modules/downloader.py

@@ -0,0 +1,123 @@
+import yt_dlp
+import os
+import re
+import time
+import subprocess
+from PIL import Image
+
+# Limit to 5 concurrent downloads
+
+
+def clear_downloads():
+    """Clears files in the downloads folder."""
+    for file in os.listdir('downloads'):
+        delete_file(f"downloads/{file}")
+
+def crop_to_square(image_path, out_path):
+    """Crops an image to a square format."""
+    with Image.open(image_path) as img:
+        width, height = img.size
+        new_size = min(width, height)
+        left = (width - new_size) / 2
+        top = (height - new_size) / 2
+        right = (width + new_size) / 2
+        bottom = (height + new_size) / 2
+        img = img.crop((left, top, right, bottom))
+        img.save(out_path)
+
+def sanitize_filename(text: str):
+    """Sanitizes filenames by removing invalid characters."""
+    return re.sub(r'[\\/:"*?<>|]+', '', text).replace(' ', '_')
+
+def get_video_formats(url: str, domain: str):
+    """Retrieves available video resolutions."""
+    ydl_opts = {'quiet': True}
+    # if domain.startswith("you"):
+    #     ydl_opts['cookiefile'] = '/cookies/youtube.txt'
+    # elif domain == 'instagram.com':
+    #     ydl_opts['cookiefile'] = '/cookies/insta.txt'
+    
+    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+        info_dict = ydl.extract_info(url, download=False)
+        return [
+            {
+                'format_id': fmt['format_id'],
+                'resolution': fmt.get('resolution', 'N/A'),
+                'ext': fmt['ext']
+            } for fmt in info_dict.get('formats', [])
+        ]
+
+def get_domain(url: str):
+    """Extracts domain name from URL."""
+    match = re.match(r'^(https?:\/\/)?(www\.)?([a-zA-Z0-9.-]+\.[a-zA-Z]{2,})(\/.*)?$', url)
+    return match.group(3) if match else None
+
+def delete_file(f_path):
+    """Attempts to delete a file."""
+    try:
+        os.remove(f_path)
+    except:
+        time.sleep(5)
+
+def download_audio(video_url, output_path, thumb):
+    """Downloads audio with metadata and thumbnail."""
+    
+    try:
+        ydl_opts = {
+            'format': 'bestaudio/best',
+            'postprocessors': [
+                {'key': 'FFmpegExtractAudio', 'preferredcodec': 'mp3', 'preferredquality': '320'},
+                {'key': 'FFmpegMetadata'},
+                {'key': 'EmbedThumbnail'}
+            ],
+            'outtmpl': output_path[:-4],
+            'writethumbnail': True,
+            # 'cookiefile': 'cookies/youtube.txt'
+        }
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            ydl.download([video_url])
+        # audio_thumb = f"{thumb[:-4]}_audio.jpg"
+        # try:
+        #     crop_to_square(thumb, audio_thumb)
+        # except:
+        #     pass
+        # delete_file(audio_thumb)
+    except Exception as e:
+        print(f"Audio download failed: {e}")
+
+def download_video(url, output_path="downloads/%(title)s.%(ext)s",):
+    """Downloads video with user-selected format."""
+
+    ydl_opts = {
+            'format': 'bestvideo+bestaudio/best',
+            'merge_output_format': 'mp4',
+            'outtmpl': output_path
+        }
+    try:
+        
+        # if domain == "instagram.com":
+        #     ydl_opts['cookiefile'] = 'cookies/insta.txt'
+        # elif domain.startswith("youtu"):
+        #     ydl_opts['cookiefile'] = 'cookies/youtube.txt'
+        
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            ydl.download([url])
+    except Exception as e:
+        print(f"Video download failed: {e}")
+
+def download_image(url, output_path, domain):
+    """Downloads an image from Instagram, Twitter, or X."""
+    
+    try:
+        if domain in ["instagram.com", "twitter.com", "x.com"]:
+            output_path = output_path.replace("mp4", "jpg")
+            command = [
+                "gallery-dl", "--config", "gallery-dl.conf",
+                "--filename", output_path.replace("downloads/", ""),
+                "--directory", "downloads/", url
+            ]
+            subprocess.run(command)
+    except Exception as e:
+        print(f"Image download failed: {e}")
+    delete_file(output_path)
+

app/schemas.py

@@ -15,5 +15,11 @@ class User(UserBase):
     id : int
     created_at : datetime
 
+class DownloadRequest(BaseModel):
+    url: str
+    title: str
+    format_type: str
+    resolution: str
+
     class Config:
         from_attributes = True

public/favicon.ico

@@ -3,9 +3,11 @@ anyio==4.8.0
 certifi==2025.1.31
 click==8.1.8
 dnspython==2.7.0
+dotenv==0.9.9
 email_validator==2.2.0
 fastapi==0.115.10
 fastapi-cli==0.0.7
+greenlet==3.1.1
 h11==0.14.0
 httpcore==1.0.7
 httptools==0.6.4
@@ -15,6 +17,7 @@ Jinja2==3.1.5
 markdown-it-py==3.0.0
 MarkupSafe==3.0.2
 mdurl==0.1.2
+psycopg2-binary==2.9.10
 pydantic==2.10.6
 pydantic_core==2.27.2
 Pygments==2.19.1
@@ -25,10 +28,12 @@ rich==13.9.4
 rich-toolkit==0.13.2
 shellingham==1.5.4
 sniffio==1.3.1
+SQLAlchemy==2.0.38
 starlette==0.46.0
 typer==0.15.2
 typing_extensions==4.12.2
 uvicorn==0.34.0
 uvloop==0.21.0
 watchfiles==1.0.4
 websockets==15.0
+yt-dlp==2025.2.19

requirements.txt

@@ -0,0 +1,133 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            margin: 20px;
+            background: #070514;
+            color: #abb2b0;
+        }
+    </style>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>YouTube Downloader</title>
+</head>
+<body>
+    <h1>Flow-Fetch Universal downloader</h1>
+    <p>Download videos from YouTube, Facebook, Instagram, Twitter, Vimeo, Dailymotion, and many more.</p>
+    <p>Just paste the URL and download the video in any format you want.</p>
+    <p>It's free, fast, and easy to use.</p>
+    <input type="text" id="youtube-url" placeholder="Paste YouTube link here">
+    <button onclick="fetchVideoInfo()">Check Video</button>
+
+    <div id="video-info" style="display: none;">
+        <h3 id="video-title"></h3>
+        <p id="video-author"></p>
+        <img id="video-thumbnail" src="" alt="Thumbnail">
+        
+        <h4>Choose Resolution</h4>
+        <select id="resolution-select"></select>
+        <button onclick="downloadVideo()">Download</button>
+    </div>
+
+    <script>
+        let videoData = {};  // Store video details
+
+        async function fetchVideoInfo() {
+            const url = document.getElementById("youtube-url").value;
+            const videoID = extractYouTubeID(url);
+            if (!videoID) {
+                alert("Invalid YouTube URL");
+                return;
+            }
+
+            try {
+                // Get video info using oEmbed
+                const oEmbedResponse = await fetch(`https://www.youtube.com/oembed?url=${url}&format=json`);
+                if (!oEmbedResponse.ok) throw new Error("Invalid YouTube URL");
+                const oEmbedData = await oEmbedResponse.json();
+
+                // Generate potential resolutions
+                const resolutions = {
+                    "144p": `https://img.youtube.com/vi/${videoID}/default.jpg`,
+                    "240p": `https://img.youtube.com/vi/${videoID}/mqdefault.jpg`,
+                    "360p": `https://img.youtube.com/vi/${videoID}/hqdefault.jpg`,
+                    "480p": `https://img.youtube.com/vi/${videoID}/sddefault.jpg`,
+                    "720p": `https://img.youtube.com/vi/${videoID}/maxresdefault.jpg`
+                };
+
+                // Check available thumbnails (to determine available resolutions)
+                const availableResolutions = {};
+                for (const [res, imgUrl] of Object.entries(resolutions)) {
+                    const response = await fetch(imgUrl, { method: "HEAD" });
+                    if (response.ok) availableResolutions[res] = imgUrl;
+                }
+
+                // Store video data
+                videoData = {
+                    url: url,
+                    title: oEmbedData.title,
+                    author: oEmbedData.author_name,
+                    thumbnail: Object.values(availableResolutions).pop(), // Highest available thumbnail
+                    resolutions: Object.keys(availableResolutions)
+                };
+
+                // Update UI
+                document.getElementById("video-title").innerText = videoData.title;
+                document.getElementById("video-author").innerText = `By: ${videoData.author}`;
+                document.getElementById("video-thumbnail").src = videoData.thumbnail;
+                
+                // Populate resolution options
+                const resolutionSelect = document.getElementById("resolution-select");
+                resolutionSelect.innerHTML = "";
+                videoData.resolutions.forEach(res => {
+                    const option = document.createElement("option");
+                    option.value = res;
+                    option.innerText = res;
+                    resolutionSelect.appendChild(option);
+                });
+
+                document.getElementById("video-info").style.display = "block";
+
+            } catch (error) {
+                alert("Error fetching video info: " + error.message);
+            }
+        }
+
+        function extractYouTubeID(url) {
+            const match = url.match(/(?:youtube\.com\/(?:[^\/]+\/.+\/|(?:v|e(?:mbed)?)\/|.*[?&]v=)|youtu\.be\/)([^"&?\/\s]{11})/);
+            return match ? match[1] : null;
+        }
+
+        async function downloadVideo() {
+            const selectedResolution = document.getElementById("resolution-select").value;
+            const formatType = "video";
+
+            // Send request to FastAPI backend
+            const response = await fetch("/download", {
+                method: "GET",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ 
+                    url: videoData.url, 
+                    resolution: selectedResolution,
+                    format_type: formatType,
+                })
+            });
+
+            if (response.ok) {
+                const blob = await response.blob();
+                const a = document.createElement("a");
+                a.href = URL.createObjectURL(blob);
+                a.download = videoData.title.replace(/[^a-z0-9]/gi, '_') + ".mp4";
+                document.body.appendChild(a);
+                a.click();
+                document.body.removeChild(a);
+            } else {
+                alert("Download failed!");
+                console.error(response);
+            }
+        }
+    </script>
+</body>
+</html>