update backend with video upload on HF

app/api/endpoints/videos.py

@@ -0,0 +1,192 @@
+from fastapi import APIRouter, File, UploadFile, Depends, HTTPException, Form
+from firebase_admin import firestore
+import hashlib
+import uuid
+from ...core.auth import require_role, get_user
+from typing import List, Optional, Dict
+from app.services.youtube_downloader import download_youtube_video, parse_urls
+from ...services.processor import process_video
+from typing import Dict
+from ...core.firebase import db  # Modifier cette ligne
+
+
+router = APIRouter()
+
+
+
+@router.get("/videos")
+async def get_videos(user_info=Depends(get_user)):
+    try:
+        # Récupération des vidéos globales
+        videos_ref = db.collection('videos')
+        videos = []
+        
+        # Récupération du statut utilisateur
+        user_status_ref = db.collection('user_video_status').document(user_info['uid'])
+        user_status_doc = user_status_ref.get()
+        user_statuses = user_status_doc.to_dict() if user_status_doc.exists else {"video_status": []}
+        
+        # Fusion des données
+        for doc in videos_ref.stream():
+            video_data = doc.to_dict()
+            video_data['id'] = doc.id
+            
+            # Ajout du statut spécifique à l'utilisateur
+            user_status = next(
+                (status for status in user_status_doc.get('video_status', []) 
+                 if status['uuid'] == doc.id),
+                None
+            )
+            video_data['user_status'] = user_status['status'] if user_status else 'ready'
+            
+            videos.append(video_data)
+            
+        return {"videos": videos}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+
+
+@router.post("/videos/upload")
+async def upload_video(
+    sport_id: str = Form(...),
+    file: Optional[UploadFile] = File(None),
+    youtube_url: Optional[str] = Form(None),
+    user_info=Depends(require_role(["admin", "user_intern"]))
+):
+    try:
+        responses = []
+        urls_to_process = []
+
+        # Collecter toutes les URLs à traiter
+        if youtube_url:
+            # Cas URL YouTube directe - peut contenir plusieurs URLs séparées par des points-virgules
+            urls_to_process.extend(parse_urls(youtube_url))
+        elif file and file.content_type in ['text/plain', 'text/csv']:
+            # Cas fichier texte avec URLs
+            text_content = (await file.read()).decode('utf-8')
+            urls_to_process.extend(parse_urls(text_content))
+        elif file:
+            # Cas upload direct de vidéo
+            content = await file.read()
+            return await process_single_video(content, sport_id, user_info, file.filename)
+        
+        if not urls_to_process and not file:
+            raise HTTPException(status_code=400, detail="Aucune URL YouTube valide trouvée")
+
+        # Traiter chaque URL
+        for url in urls_to_process:
+            try:
+                print(f"[DEBUG] Processing YouTube URL: {url}")
+                content = await download_youtube_video(url)
+                result = await process_single_video(content, sport_id, user_info, f"YouTube: {url}")
+                responses.append({
+                    "url": url,
+                    "status": "success",
+                    "video_id": result["video_id"]
+                })
+            except Exception as e:
+                print(f"[ERROR] Failed to process URL {url}: {str(e)}")
+                responses.append({
+                    "url": url,
+                    "status": "error",
+                    "error": str(e)
+                })
+
+        return {
+            "message": f"Traitement terminé pour {len(responses)} vidéos",
+            "results": responses
+        }
+
+    except Exception as e:
+        print(f"[ERROR] Upload failed: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+async def process_single_video(content: bytes, sport_id: str, user_info: dict, title: str):
+    """Traite une seule vidéo et retourne son ID"""
+    video_uuid = str(uuid.uuid4())
+
+    # Calcul du hash MD5
+    md5_hash = hashlib.md5()
+    md5_hash.update(content)
+    file_hash = md5_hash.hexdigest()
+
+    # Vérification des doublons
+    existing_videos = db.collection('videos').where('md5_hash', '==', file_hash).get()
+    if len(existing_videos) > 0:
+        return {"message": "Cette vidéo existe déjà", "video_id": existing_videos[0].id}
+
+    # Création de l'entrée Firestore
+    video_data = {
+        "uuid": video_uuid,
+        "sport_id": sport_id,
+        "upload_date": firestore.SERVER_TIMESTAMP,
+        "uploaded_by": user_info['uid'],
+        "title": title,
+        "status": "downloading",
+        "md5_hash": file_hash,
+        "paths": {
+            "raw": f"{sport_id}/raw/{video_uuid}_raw.mp4",
+            "compressed": f"{sport_id}/compressed/{video_uuid}_compressed.mp4",
+            "reduced_videos": []
+        },
+        "scenes": [],
+        "reduced_scenes": []
+    }
+
+    db.collection('videos').document(video_uuid).set(video_data)
+    await process_video(video_uuid, content)
+
+    return {"message": "Upload initié", "video_id": video_uuid}
+
+
+
+@router.put("/videos/{video_id}/status")
+async def update_video_status(
+    video_id: str,
+    status: str,
+    user_info=Depends(get_user)
+):
+    try:
+        # Vérifier si la vidéo existe
+        video_ref = db.collection('videos').document(video_id)
+        video_doc = video_ref.get()
+        
+        if not video_doc.exists:
+            raise HTTPException(status_code=404, detail="Vidéo non trouvée")
+        
+        # Mettre à jour ou créer le statut utilisateur
+        user_status_ref = db.collection('user_video_status').document(user_info['uid'])
+        user_status_doc = user_status_ref.get()
+        
+        if user_status_doc.exists:
+            statuses = user_status_doc.get('video_status', [])
+            # Mettre à jour le statut existant ou ajouter un nouveau
+            status_updated = False
+            for s in statuses:
+                if s['uuid'] == video_id:
+                    s['status'] = status
+                    status_updated = True
+                    break
+            
+            if not status_updated:
+                statuses.append({
+                    'uuid': video_id,
+                    'status': status
+                })
+            
+            user_status_ref.update({'video_status': statuses})
+        else:
+            # Créer un nouveau document avec le statut
+            user_status_ref.set({
+                'video_status': [{
+                    'uuid': video_id,
+                    'status': status
+                }]
+            })
+        
+        return {"message": "Statut mis à jour avec succès"}
+    
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

app/core/auth.py

@@ -0,0 +1,42 @@
+from fastapi import Depends, HTTPException, status
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from firebase_admin import auth
+from .firebase import db
+
+security = HTTPBearer()
+
+def get_user(credentials: HTTPAuthorizationCredentials = Depends(security)):
+    try:
+        token = credentials.credentials
+        decoded_token = auth.verify_id_token(token)
+        
+        # Récupérer le rôle depuis Firestore
+        user_id = decoded_token['uid']
+        user_doc = db.collection('users').document(user_id).get()
+        
+        if not user_doc.exists:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="User not found in Firestore"
+            )
+        
+        # Ajouter le rôle aux informations du token
+        user_data = user_doc.to_dict()
+        decoded_token['role'] = user_data.get('role', 'user_extern')
+        
+        return decoded_token
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail=f"Invalid authentication credentials: {str(e)}"
+        )
+
+def require_role(allowed_roles):
+    def role_checker(user_info=Depends(get_user)):
+        if user_info['role'] not in allowed_roles:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="Insufficient permissions"
+            )
+        return user_info
+    return role_checker

app/core/config.py

@@ -0,0 +1,13 @@
+from pydantic_settings import BaseSettings
+
+class Settings(BaseSettings):
+    PROJECT_NAME: str = "JunsenAI Backend"
+    API_V1_STR: str = "/api"
+    FIREBASE_CREDENTIALS: str = "serviceAccountKey.json"
+    STORAGE_PATH: str = "media_storage"
+    STORAGE_BUCKET: str = "create-user-e4e2c.appspot.com"  # Ajoutez cette ligne
+
+    class Config:
+        case_sensitive = True
+
+settings = Settings()

app/core/firebase.py

@@ -0,0 +1,38 @@
+import firebase_admin
+from firebase_admin import credentials, firestore, storage
+import os
+import json
+from dotenv import load_dotenv
+from .config import settings
+
+# Charger les variables d'environnement
+load_dotenv()
+
+def get_firebase_app():
+    if not firebase_admin._apps:
+        try:
+            firebase_credentials = os.getenv("FIREBASE_CREDENTIALS")
+            if not firebase_credentials:
+                raise ValueError("FIREBASE_CREDENTIALS environment variable is not set")
+            
+            cred_dict = json.loads(firebase_credentials)
+            cred = credentials.Certificate(cred_dict)
+            return firebase_admin.initialize_app(cred, {
+                'storageBucket': settings.STORAGE_BUCKET
+            })
+        except Exception as e:
+            print(f"Firebase initialization error: {str(e)}")
+            raise
+    return firebase_admin.get_app()
+
+def get_firestore_db():
+    get_firebase_app()
+    return firestore.client()
+
+def get_storage_bucket():
+    get_firebase_app()
+    return storage.bucket()
+
+# Créer des instances uniques
+db = get_firestore_db()
+bucket = get_storage_bucket()

app/models/video.py

@@ -0,0 +1,30 @@
+from pydantic import BaseModel
+from typing import List, Optional
+from datetime import datetime
+
+class Scene(BaseModel):
+    start: str
+    end: str
+    recognized_sport: str
+    confidence: float
+
+class ReducedScene(BaseModel):
+    clip_id: str
+    scenes: List[Scene]
+
+class VideoPaths(BaseModel):
+    raw: str
+    compressed: str
+    reduced_videos: List[str]
+
+class Video(BaseModel):
+    uuid: str
+    sport_id: str
+    upload_date: datetime
+    uploaded_by: str
+    title: str
+    status: str
+    md5_hash: Optional[str]
+    paths: VideoPaths
+    scenes: List[Scene] = []
+    reduced_scenes: List[ReducedScene] = []

app/services/processor.py

@@ -0,0 +1,64 @@
+from firebase_admin import firestore
+import os
+from ..core.config import settings
+from ..core.firebase import db
+from huggingface_hub import HfApi, create_repo
+import tempfile
+from .video_processing.hf_upload import HFUploader
+from .video_processing.compression import compress_video
+
+async def process_video(video_uuid: str, content: bytes):
+    temp_files = []
+    try:
+        video_ref = db.collection('videos').document(video_uuid)
+        video_data = video_ref.get().to_dict()
+        
+        hf_uploader = HFUploader()
+        sport_id = video_data['sport_id']
+        
+        # Ensure folder structure exists
+        hf_uploader.ensure_folder_structure(sport_id)
+            
+        # Create temp files
+        temp_raw_file = tempfile.NamedTemporaryFile(suffix='.mp4', delete=False)
+        temp_compressed_file = tempfile.NamedTemporaryFile(suffix='.mp4', delete=False)
+        temp_files.extend([temp_raw_file.name, temp_compressed_file.name])
+        
+        # Write raw video and close file
+        temp_raw_file.write(content)
+        temp_raw_file.close()
+        
+        # Compress video
+        compress_video(temp_raw_file.name, temp_compressed_file.name)
+        temp_compressed_file.close()
+        
+        # Upload both versions
+        raw_url = hf_uploader.upload_video(
+            temp_raw_file.name,
+            f"{sport_id}/raw/{video_uuid}.mp4"
+        )
+        
+        compressed_url = hf_uploader.upload_video(
+            temp_compressed_file.name,
+            f"{sport_id}/compressed/{video_uuid}.mp4"
+        )
+        
+        # Update Firestore
+        video_ref.update({
+            "raw_video_url": raw_url,
+            "compressed_video_url": compressed_url,
+            "status": "ready"
+        })
+                
+    except Exception as e:
+        print(f"Erreur lors du traitement de la vidéo {video_uuid}: {str(e)}")
+        video_ref.update({"status": "error", "error": str(e)})
+        
+    finally:
+        # Clean up temp files
+        for temp_file in temp_files:
+            try:
+                if os.path.exists(temp_file):
+                    os.unlink(temp_file)
+            except Exception as e:
+                print(f"Erreur lors de la suppression du fichier temporaire {temp_file}: {str(e)}")

app/services/video_processing/compression.py

@@ -0,0 +1,25 @@
+import subprocess
+from fastapi import HTTPException
+
+def compress_video(input_path: str, output_path: str, resolution: str = "192x144"):
+    """Compress video using FFmpeg for maximum reduction, with audio removed."""
+    command = [
+        "ffmpeg",
+        "-y",  # Force overwrite without asking
+        "-i", input_path,
+        "-vf", f"scale={resolution}",
+        "-an",  # Remove audio
+        "-c:v", "libx265",
+        "-preset", "medium",  # Changed from veryslow for better speed/compression balance
+        "-crf", "32",
+        "-maxrate", "150k",
+        "-bufsize", "200k",
+        "-r", "10",
+        output_path
+    ]
+    
+    try:
+        subprocess.run(command, check=True, capture_output=True, text=True)
+    except subprocess.CalledProcessError as e:
+        print(f"Compression error: {e.stderr}")
+        raise HTTPException(status_code=500, detail="Video compression failed")

app/services/video_processing/hf_upload.py

@@ -0,0 +1,42 @@
+from huggingface_hub import HfApi, create_repo
+import os
+
+class HFUploader:
+    def __init__(self):
+        self.hf_api = HfApi()
+        self.repo_id = "HUGGINGFACE_REPO_ID"
+        self._ensure_repo_exists()
+
+    def _ensure_repo_exists(self):
+        try:
+            self.hf_api.repo_info(repo_id=self.repo_id, repo_type="dataset")
+        except Exception:
+            create_repo(self.repo_id, private=False, repo_type="dataset", 
+                       token=os.getenv("HUGGINGFACE_TOKEN"))
+
+    def ensure_folder_structure(self, sport_id: str):
+        paths = [
+            f"{sport_id}/raw",
+            f"{sport_id}/compressed"
+        ]
+        for path in paths:
+            try:
+                self.hf_api.upload_file(
+                    path_or_fileobj="",
+                    path_in_repo=f"{path}/.gitkeep",
+                    repo_id=self.repo_id,
+                    repo_type="dataset",
+                    token=os.getenv("HUGGINGFACE_TOKEN")
+                )
+            except Exception:
+                pass
+
+    def upload_video(self, file_path: str, destination_path: str):
+        self.hf_api.upload_file(
+            path_or_fileobj=file_path,
+            path_in_repo=destination_path,
+            repo_id=self.repo_id,
+            repo_type="dataset",
+            token=os.getenv("HUGGINGFACE_TOKEN")
+        )
+        return f"https://huggingface.co/datasets/{self.repo_id}/raw/main/{destination_path}"

app/services/youtube_downloader.py

@@ -0,0 +1,87 @@
+import yt_dlp
+import io
+import asyncio
+from typing import List
+import os
+
+async def download_youtube_video(url: str) -> bytes:
+    try:
+        print(f"[DEBUG] Téléchargement de {url}")
+        
+        # Créer un dossier temporaire pour le téléchargement
+        temp_dir = "temp_downloads"
+        os.makedirs(temp_dir, exist_ok=True)
+        
+        # Configuration de yt-dlp
+        ydl_opts = {
+            'format': 'bestvideo[ext=mp4][vcodec^=avc1]+bestaudio[ext=m4a]/mp4',
+            'merge_output_format': 'mp4',
+            'quiet': True,
+            'no_warnings': True,
+            'outtmpl': os.path.join(temp_dir, '%(title)s.%(ext)s'),
+        }
+
+        def custom_download(d):
+            if d['status'] == 'finished':
+                print(f"[DEBUG] Téléchargement terminé pour {url}")
+
+        ydl_opts['progress_hooks'] = [custom_download]
+        
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            # Télécharger la vidéo
+            info = ydl.extract_info(url, download=True)
+            video_path = ydl.prepare_filename(info)
+            
+            # Lire le fichier en bytes
+            with open(video_path, 'rb') as f:
+                content = f.read()
+            
+            # Nettoyer le fichier temporaire
+            os.remove(video_path)
+            
+            return content
+            
+    except Exception as e:
+        print(f"[ERROR] Erreur téléchargement YouTube: {str(e)}")
+        raise Exception(f"Erreur téléchargement YouTube: {str(e)}")
+    finally:
+        # Nettoyer le dossier temporaire si vide
+        try:
+            os.rmdir(temp_dir)
+        except:
+            pass
+
+def parse_urls(content: str) -> List[str]:
+    urls = [url.strip() for url in content.replace(';', '\n').split('\n')]
+    return [url for url in urls if url and ('youtube.com' in url or 'youtu.be' in url)]
+
+async def test_download():
+    test_url = "https://www.youtube.com/watch?v=ksIfusO_DgA"  # URL de test de surf
+    try:
+        content = await download_youtube_video(test_url)
+        print(f"[SUCCESS] Vidéo téléchargée avec succès! Taille: {len(content)} bytes")
+        return True
+    except Exception as e:
+        print(f"[ERROR] Test échoué: {str(e)}")
+        return False
+
+def test_parse_urls():
+    test_content = """
+    https://www.youtube.com/watch?v=ksIfusO_DgA&ab_channel=NobodySurf%3ASurfingVideos
+    https://www.youtube.com/watch?v=GHDLZwccg8E&ab_channel=RIPITUP
+    """
+    urls = parse_urls(test_content)
+    print(f"[DEBUG] URLs trouvées: {urls}")
+    return len(urls) == 2
+
+if __name__ == "__main__":
+    # Test de parse_urls
+    print("\nTest de parse_urls:")
+    if test_parse_urls():
+        print("[SUCCESS] Test parse_urls réussi!")
+    else:
+        print("[ERROR] Test parse_urls échoué")
+
+    # Test de download_youtube_video
+    print("\nTest de download_youtube_video:")
+    asyncio.run(test_download())

main.py

@@ -1,100 +1,77 @@
-
-from fastapi import FastAPI, Depends, HTTPException, status, Response
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
-from firebase_admin import auth, credentials, firestore
-import firebase_admin
-import os
-from dotenv import load_dotenv
-
-# Charger les variables d'environnement depuis le fichier .env
-load_dotenv()
-
-# Récupérer les variables d'environnement pour initialiser Firebase
-firebase_credentials = os.getenv("FIREBASE_CREDENTIALS")
-
-# Vérification de la présence de la clé
-if not firebase_credentials:
-    raise ValueError("La variable d'environnement FIREBASE_CREDENTIALS n'est pas définie.")
-
-# Charger les informations de la clé Firebase
-import json
-try:
-    firebase_credentials_dict = json.loads(firebase_credentials)
-    if not isinstance(firebase_credentials_dict, dict):
-        raise ValueError("FIREBASE_CREDENTIALS n'est pas un JSON valide.")
-except json.JSONDecodeError as e:
-    raise ValueError("FIREBASE_CREDENTIALS n'est pas un JSON valide.") from e
-
-# Initialisation Firebase Admin
-cred = credentials.Certificate(firebase_credentials_dict)
-firebase_admin.initialize_app(cred)
-db = firestore.client()
-
-app = FastAPI()
-
-# Configuration CORS
-allowed_origins = [
-    "*"
-]
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=allowed_origins,
-    allow_credentials=True,
-    allow_methods=["POST", "GET"],
-    allow_headers=["*"]
-)
-
-# Fonction pour vérifier le token Firebase et récupérer le rôle depuis Firestore
-def get_user(res: Response,
-             cred: HTTPAuthorizationCredentials = Depends(HTTPBearer(auto_error=False))):
-    if cred is None:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Bearer authentication required",
-            headers={'WWW-Authenticate': 'Bearer realm="auth_required"'},
-        )
-    try:
-        # Vérification et décodage du token Firebase
-        decoded_token = auth.verify_id_token(cred.credentials)
-        user_id = decoded_token['uid']
-
-        # Récupération du rôle de l'utilisateur depuis Firestore
-        user_doc = db.collection('users').document(user_id).get()
-        if not user_doc.exists:
-            raise HTTPException(status_code=401, detail="Utilisateur non trouvé dans Firestore")
-
-        # Extraction du rôle et ajout aux informations utilisateur
-        user_data = user_doc.to_dict()
-        user_role = user_data.get('role', 'user_extern')  # Par défaut à 'user_extern' si le rôle n'existe pas
-        decoded_token['role'] = user_role
-        res.headers['WWW-Authenticate'] = 'Bearer realm="auth_required"'
-
-        return decoded_token
-    except Exception as err:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail=f"Invalid authentication credentials. {err}",
-            headers={'WWW-Authenticate': 'Bearer error="invalid_token"'},
-        )
-
-# Fonction de dépendance pour vérifier le rôle
-def require_role(allowed_roles):
-    def role_checker(user_info=Depends(get_user)):
-        if user_info['role'] not in allowed_roles:
-            raise HTTPException(status_code=403, detail="Accès non autorisé")
-        return user_info
-    return role_checker
-
-# Route publique
-@app.get("/")
-async def root():
-    return {"message": "This is the root."}
-
-@app.get("/api/protected/user")
-async def protected_user_route(user_info=Depends(get_user)):
-    return {"message": "Protected user route accessed successfully", "user_info": user_info}
-
-@app.get("/api/protected/admin")
-async def protected_admin_route(user_info=Depends(require_role(["admin"]))):
-    return {"message": "Protected admin route accessed successfully", "user_info": user_info}
+from fastapi import FastAPI, Depends, HTTPException, status, Response
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from firebase_admin import auth, credentials, firestore
+from firebase_admin import auth
+from app.core.firebase import db, get_firebase_app  # Modifier cette ligne
+from app.api.endpoints.videos import router as videos_router
+
+
+get_firebase_app()
+
+app = FastAPI()
+
+# Configuration CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["POST", "GET"],
+    allow_headers=["*"]
+)
+
+# Configuration CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["POST", "GET"],
+    allow_headers=["*"]
+)
+
+def get_user(res: Response,
+             cred: HTTPAuthorizationCredentials = Depends(HTTPBearer(auto_error=False))):
+    if cred is None:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Bearer authentication required",
+            headers={'WWW-Authenticate': 'Bearer realm="auth_required"'},
+        )
+    try:
+        decoded_token = auth.verify_id_token(
+            cred.credentials, 
+            check_revoked=True, 
+            clock_skew_seconds=1800
+        )
+        user_id = decoded_token['uid']
+        
+        user_doc = db.collection('users').document(user_id).get()
+        if not user_doc.exists:
+            raise HTTPException(status_code=401, detail="Utilisateur non trouvé dans Firestore")
+        
+        user_data = user_doc.to_dict()
+        user_role = user_data.get('role', 'user_extern')
+        decoded_token['role'] = user_role
+        res.headers['WWW-Authenticate'] = 'Bearer realm="auth_required"'
+        
+        return decoded_token
+    except Exception as err:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail=f"Invalid authentication credentials. {err}",
+            headers={'WWW-Authenticate': 'Bearer error="invalid_token"'},
+        )
+
+def require_role(allowed_roles):
+    def role_checker(user_info=Depends(get_user)):
+        if user_info['role'] not in allowed_roles:
+            raise HTTPException(status_code=403, detail="Accès non autorisé")
+        return user_info
+    return role_checker
+
+# Inclure le router videos
+app.include_router(videos_router, prefix="/api")
+
+@app.get("/")
+async def root():
+    return {"message": "API is running"}

requirements.txt

@@ -1,5 +1,20 @@
 fastapi
 uvicorn
-python-dotenv
+python-multipart
 firebase-admin
-python-multipart
+python-dotenv
+huggingface-hub
+yt-dlp
+ffmpeg-python
+pydantic
+
+
+# fastapi==0.110.0
+# uvicorn==0.27.1
+# python-multipart==0.0.9
+# firebase-admin==6.4.0
+# python-dotenv==1.0.1
+# huggingface-hub==0.21.4
+# yt-dlp==2024.3.10
+# ffmpeg-python==0.2.0
+# pydantic==2.6.3