update app

Dockerfile

@@ -1,25 +1,31 @@
-# Utiliser une image Python officielle
-FROM python:3.9-slim
-
-# Installer les dépendances système nécessaires
-RUN apt-get update && apt-get install -y \
-    ffmpeg \
-    && rm -rf /var/lib/apt/lists/*
-
-# Définir le répertoire de travail
-WORKDIR /code
-
-# Copier les fichiers de dépendances
-COPY requirements.txt .
-
-# Installer les dépendances Python
-RUN pip install --no-cache-dir -r requirements.txt
-
-# Copier le reste du code
-COPY . .
-
-# Exposer le port
-EXPOSE 7860
-
-# Commande pour démarrer l'application
+# FROM python:3.9
+# WORKDIR /code
+# COPY ./requirements.txt /code/requirements.txt
+# RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+# COPY . /code
+# CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
+# Utiliser une image Python officielle
+FROM python:3.9-slim
+
+# Installer les dépendances système nécessaires
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    && rm -rf /var/lib/apt/lists/*
+
+# Définir le répertoire de travail
+WORKDIR /code
+
+# Copier les fichiers de dépendances
+COPY requirements.txt .
+
+# Installer les dépendances Python
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copier le reste du code
+COPY . .
+
+# Exposer le port
+EXPOSE 7860
+
+# Commande pour démarrer l'application
 CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

app/api/endpoints/videos.py

@@ -7,7 +7,8 @@ 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
+from ...core.firebase import db
+from ...services.clip_assignment import ClipAssignmentService
 
 
 router = APIRouter()
@@ -106,6 +107,7 @@ async def upload_video(
 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())
+    active_assignement = True
 
     # Calcul du hash MD5
     md5_hash = hashlib.md5()
@@ -136,7 +138,11 @@ async def process_single_video(content: bytes, sport_id: str, user_info: dict, t
     }
 
     db.collection('videos').document(video_uuid).set(video_data)
-    await process_video(video_uuid, content)
+    await process_video(video_uuid, content,  user_info['uid'], sport_id)
+
+    if user_info['role'] in ["admin", "user_intern"] and active_assignement:
+        clip_service = ClipAssignmentService()
+        await clip_service.assign_clips_to_user(user_info["uid"], user_info["role"])
 
     return {"message": "Upload initié", "video_id": video_uuid}
 
@@ -188,5 +194,53 @@ async def update_video_status(
         
         return {"message": "Statut mis à jour avec succès"}
     
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    
+
+@router.post("/clips/assign")
+async def assign_clips(user_info=Depends(require_role(["admin", "user_intern"]))):
+    try:
+        clip_service = ClipAssignmentService()
+        await clip_service.assign_clips_to_user(user_info["uid"], user_info["role"])
+        return {"message": "Clips assignés avec succès"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.delete("/clips/{clip_id}/user")
+async def remove_clip(clip_id: str, user_info=Depends(require_role(["admin"]))):
+    try:
+        clip_service = ClipAssignmentService()
+        await clip_service.remove_clip_from_user(user_info["uid"], clip_id)
+        return {"message": "Clip retiré avec succès"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    
+@router.post("/clips/sync")
+async def sync_user_clips(user_info=Depends(require_role(["admin", "user_intern"]))):
+    """Synchronise les clips disponibles pour l'utilisateur lors de sa connexion"""
+    try:
+        clip_service = ClipAssignmentService()
+        await clip_service.assign_clips_to_user(user_info["uid"], user_info["role"])
+        return {"message": "Clips synchronisés avec succès"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    
+
+@router.get("/clips/debug/{user_id}")
+async def debug_user_clips(user_id: str, user_info=Depends(require_role(["admin"]))):
+    """Endpoint de débogage pour vérifier les clips d'un utilisateur"""
+    try:
+        user_ref = db.collection('users').document(user_id)
+        user_doc = user_ref.get()
+        
+        if not user_doc.exists:
+            raise HTTPException(status_code=404, detail="Utilisateur non trouvé")
+            
+        user_data = user_doc.to_dict()
+        return {
+            "clips_count": len(user_data.get("clips", [])),
+            "clips": user_data.get("clips", [])
+        }
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))

app/core/auth.py

@@ -2,15 +2,24 @@ from fastapi import Depends, HTTPException, status
 from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
 from firebase_admin import auth
 from .firebase import db
+import time
 
 security = HTTPBearer()
 
 def get_user(credentials: HTTPAuthorizationCredentials = Depends(security)):
+    if not credentials:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Bearer authentication required"
+        )
     try:
-        token = credentials.credentials
-        decoded_token = auth.verify_id_token(token)
+        # Utiliser une valeur valide pour clock_skew_seconds (entre 0 et 60)
+        decoded_token = auth.verify_id_token(
+            credentials.credentials,
+            check_revoked=True,
+            clock_skew_seconds=60  # Valeur maximale autorisée
+        )
         
-        # Récupérer le rôle depuis Firestore
         user_id = decoded_token['uid']
         user_doc = db.collection('users').document(user_id).get()
         
@@ -20,11 +29,11 @@ def get_user(credentials: HTTPAuthorizationCredentials = Depends(security)):
                 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,

app/services/clip_assignment.py

@@ -0,0 +1,73 @@
+from firebase_admin import firestore
+from ..core.firebase import db
+from typing import List, Dict
+
+class ClipAssignmentService:
+    def __init__(self):
+        self.db = db
+
+    async def assign_clips_to_user(self, user_id: str, role: str):
+        """
+        Affecte les clips à un utilisateur en fonction de son rôle
+        Pour le moment, admin et user_intern ont accès à tous les clips
+        """
+        if role not in ["admin", "user_intern"]:
+            return
+            
+        try:
+            # Récupérer tous les clips disponibles
+            clips_ref = self.db.collection("clips")
+            clips = clips_ref.stream()
+            
+            # Récupérer l'utilisateur
+            user_ref = self.db.collection("users").document(user_id)
+            user_data = user_ref.get().to_dict() or {}
+            
+            # Initialiser la liste des clips si elle n'existe pas
+            if "clips" not in user_data:
+                user_data["clips"] = []
+                
+            # Créer un set des clip_ids existants pour l'utilisateur
+            existing_clip_ids = {clip["clip_id"] for clip in user_data["clips"]}
+            
+            # Ajouter les nouveaux clips
+            for clip in clips:
+                clip_data = clip.to_dict()
+                clip_id = clip_data["clip_id"]
+                
+                if clip_id not in existing_clip_ids:
+                    user_data["clips"].append({
+                        "clip_id": clip_id,
+                        "sport_id": clip_data["sport_id"],
+                        "url": clip_data["url"],
+                        "status": "ready",
+                        "annotations": []
+                    })
+            
+            # Mettre à jour le document utilisateur
+            user_ref.set(user_data, merge=True)
+            
+            return {"message": "Clips assignés avec succès"}
+            
+        except Exception as e:
+            print(f"Erreur lors de l'assignation des clips: {str(e)}")
+            raise e
+
+    async def remove_clip_from_user(self, user_id: str, clip_id: str):
+        """Retire un clip spécifique d'un utilisateur"""
+        try:
+            user_ref = self.db.collection("users").document(user_id)
+            user_data = user_ref.get().to_dict()
+            
+            if "clips" in user_data:
+                user_data["clips"] = [
+                    clip for clip in user_data["clips"] 
+                    if clip["clip_id"] != clip_id
+                ]
+                user_ref.set(user_data, merge=True)
+                
+            return {"message": "Clip retiré avec succès"}
+            
+        except Exception as e:
+            print(f"Erreur lors du retrait du clip: {str(e)}")
+            raise e

app/services/processor.py

@@ -6,8 +6,13 @@ from huggingface_hub import HfApi, create_repo
 import tempfile
 from .video_processing.hf_upload import HFUploader
 from .video_processing.compression import compress_video
+from .video_processing.scene_detection import SceneDetector
+from .video_processing.scene_classifier import SceneClassifier
+from .video_processing.clip_generator import ClipGenerator
+from .video_processing.scrape_hf import extract_video_urls
+import time
 
-async def process_video(video_uuid: str, content: bytes):
+async def process_video(video_uuid: str, content: bytes, user_id: str, sport_id: str):
     temp_files = []
     try:
         video_ref = db.collection('videos').document(video_uuid)
@@ -31,24 +36,136 @@ async def process_video(video_uuid: str, content: bytes):
         # Compress video
         compress_video(temp_raw_file.name, temp_compressed_file.name)
         temp_compressed_file.close()
+
+        # Detect scenes
+        scene_detector = SceneDetector()
+        scene_classifier = SceneClassifier()
+        scenes_data = scene_detector.detect_scenes(temp_compressed_file.name)
         
-        # 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(
+        # Classify each scene
+        for scene in scenes_data["scenes"]:
+            classification = scene_classifier.classify_scene(
+                temp_compressed_file.name, 
+                scene
+            )
+            scene["recognized_sport"] = classification["recognized_sport"]
+            scene["confidence"] = classification["confidence"]
+
+        # Generate clips
+        clip_generator = ClipGenerator()
+        generated_clips = clip_generator.generate_clips(
             temp_compressed_file.name,
-            f"{sport_id}/compressed/{video_uuid}.mp4"
+            scenes_data["scenes"],
+            sport_id
         )
+
+        # Create and upload clips
+        final_clips_data = []
+        user_ref = db.collection("users").document(user_id)
+        user_data = user_ref.get().to_dict() or {"clips": []}
+
+        if "clips" not in user_data:
+            user_data["clips"] = []
+
+        # Upload both versions first
+        raw_path = f"{sport_id}/raw/{video_uuid}.mp4"
+        compressed_path = f"{sport_id}/compressed/{video_uuid}.mp4"
         
-        # Update Firestore
-        video_ref.update({
-            "raw_video_url": raw_url,
-            "compressed_video_url": compressed_url,
-            "status": "ready"
-        })
+        hf_uploader.upload_video(temp_raw_file.name, raw_path)
+        hf_uploader.upload_video(temp_compressed_file.name, compressed_path)
+
+        # Attendre que HF indexe les fichiers
+        time.sleep(3)
+
+        # Construire l'URL de base pour le scraping
+        base_viewer_url = f"https://huggingface.co/datasets/{hf_uploader.repo_id}/viewer/default/files"
+        
+        # Récupérer toutes les URLs
+        max_retries = 3
+        raw_url = None
+        compressed_url = None
+        
+        for attempt in range(max_retries):
+            try:
+                urls = extract_video_urls(base_viewer_url)
+                
+                # Chercher les URLs correspondantes
+                raw_url = next((url for url in urls if raw_path in url), None)
+                compressed_url = next((url for url in urls if compressed_path in url), None)
+                
+                if raw_url and compressed_url:
+                    print(f"[SUCCESS] URLs trouvées à la tentative {attempt + 1}")
+                    break
+                    
+                print(f"[RETRY] Tentative {attempt + 1}/{max_retries}")
+                time.sleep(2)
+            except Exception as e:
+                print(f"[ERROR] Tentative {attempt + 1} échouée: {str(e)}")
+                if attempt == max_retries - 1:
+                    raise e
+                time.sleep(2)
+
+        # Process clips
+        for clip_data in generated_clips:
+            clip_number = clip_data["clip_number"]
+            clip_file_path = clip_data["file_path"]
+            temp_files.append(clip_file_path)
+            
+            clip_path = f"{sport_id}/clips/{video_uuid}_clip_{clip_number}.mp4"
+            hf_uploader.upload_video(clip_file_path, clip_path)
+            
+            # Attendre et scraper l'URL du clip
+            time.sleep(2)
+            clip_url = None
+            
+            for attempt in range(max_retries):
+                try:
+                    urls = extract_video_urls(base_viewer_url)
+                    clip_url = next((url for url in urls if clip_path in url), None)
+                    if clip_url:
+                        break
+                    time.sleep(2)
+                except Exception:
+                    if attempt == max_retries - 1:
+                        raise
+                    time.sleep(2)
+            
+            if clip_url:
+                final_clips_data.append({
+                    "clip_id": f"{video_uuid}_clip_{clip_number}",
+                    "video_uuid": video_uuid,
+                    "url": clip_url,
+                    "duration": clip_data["duration"],
+                    "confidence": clip_data["confidence"],
+                    "segments": clip_data["segments"]
+                })
+
+                clip_ref = db.collection("clips").document(f"{video_uuid}_clip_{clip_number}")
+                clip_ref.set({
+                    "clip_id": f"{video_uuid}_clip_{clip_number}",
+                    "sport_id": sport_id,
+                    "url": clip_url,
+                    "duration": clip_data["duration"]
+                })
+
+        # Update user data
+        user_ref.set(user_data)
+
+        # Update video data with scraped URLs
+        update_data = {
+            "scenes": scenes_data,
+            "clips": final_clips_data,
+            "clips_count": len(final_clips_data),
+            "status": "ready",
+            "last_updated": firestore.SERVER_TIMESTAMP
+        }
+
+        if raw_url:
+            update_data["raw_video_url"] = raw_url
+        if compressed_url:
+            update_data["compressed_video_url"] = compressed_url
+
+        video_ref.update(update_data)
                 
     except Exception as e:
         print(f"Erreur lors du traitement de la vidéo {video_uuid}: {str(e)}")
@@ -61,4 +178,4 @@ async def process_video(video_uuid: str, content: bytes):
                 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)}")
+                print(f"[WARNING] Erreur lors de la suppression du fichier temporaire {temp_file}: {str(e)}")

app/services/video_processing/clip_generator.py

@@ -0,0 +1,213 @@
+import cv2
+from moviepy.editor import VideoFileClip, concatenate_videoclips
+import tempfile
+import os
+
+class ClipGenerator:
+    def __init__(self, target_duration: int = 60, min_confidence: float = 0.9):
+        self.target_duration = target_duration  # durée cible en secondes
+        self.min_confidence = min_confidence
+        print(f"[DEBUG] Initialized ClipGenerator with target_duration={target_duration}s, min_confidence={min_confidence}")
+
+    def _time_to_seconds(self, time_str: str) -> float:
+        h, m, s = time_str.split(':')
+        return int(h) * 3600 + int(m) * 60 + float(s)
+
+    def _seconds_to_time(self, seconds: float) -> str:
+        h = int(seconds // 3600)
+        m = int((seconds % 3600) // 60)
+        s = seconds % 60
+        return f"{h:02d}:{m:02d}:{s:06.3f}"
+
+    def generate_clips(self, video_path: str, scenes: list, sport_id: str) -> list:
+        print(f"\n[DEBUG] Starting clip generation for {sport_id}")
+        print(f"[DEBUG] Input scenes: {len(scenes)}")
+        
+        # Debug chaque scène avant filtrage
+        for scene in scenes:
+            print(f"[DEBUG] Pre-filter scene:")
+            print(f"  - Start: {scene['start']}")
+            print(f"  - End: {scene['end']}")
+            print(f"  - Sport: {scene['recognized_sport']}")
+            print(f"  - Confidence: {scene['confidence']}")
+            print(f"  - Would pass sport filter: {scene['recognized_sport'] == sport_id}")
+            print(f"  - Would pass confidence filter: {scene['confidence'] >= self.min_confidence}")
+        
+        filtered_scenes = [
+            scene for scene in scenes 
+            if scene["recognized_sport"].lower() == sport_id.lower()
+            and scene["confidence"] >= self.min_confidence
+        ]
+        
+        print(f"[DEBUG] Filtered scenes: {len(filtered_scenes)}")
+        for scene in filtered_scenes:
+            print(f"[DEBUG] Scene: {scene['start']} -> {scene['end']} (conf: {scene['confidence']:.2%}) sport_id: {sport_id}")
+
+        if not filtered_scenes:
+            print("[DEBUG] No valid scenes found after filtering")
+            return []
+
+        clips_data = []
+        current_segments = []
+        current_duration = 0
+        clip_number = 1
+
+        for scene in filtered_scenes:
+            print(f"\n[DEBUG] Processing scene {scene['start']} -> {scene['end']}")
+            scene_start = self._time_to_seconds(scene["start"])
+            scene_end = self._time_to_seconds(scene["end"])
+            scene_duration = scene_end - scene_start
+            print(f"[DEBUG] Scene duration: {scene_duration:.2f}s")
+            print(f"[DEBUG] Current accumulated duration: {current_duration:.2f}s")
+
+            if current_duration + scene_duration > self.target_duration:
+                remaining_duration = self.target_duration - current_duration
+                print(f"[DEBUG] Scene would exceed target duration. Remaining space: {remaining_duration:.2f}s")
+                
+                if remaining_duration > 0:
+                    segment_end = self._seconds_to_time(scene_start + remaining_duration)
+                    current_segments.append({
+                        "start": scene["start"],
+                        "end": segment_end,
+                        "confidence": scene["confidence"]
+                    })
+                    print(f"[DEBUG] Added partial segment: {scene['start']} -> {segment_end}")
+
+                clip_data = self._create_clip(video_path, current_segments, clip_number)
+                clips_data.append(clip_data)
+                print(f"[DEBUG] Created clip {clip_number} with {len(current_segments)} segments")
+
+                clip_number += 1
+                current_segments = []
+                current_duration = 0
+
+                remaining_scene_duration = scene_duration - remaining_duration
+                print(f"[DEBUG] Remaining scene duration to process: {remaining_scene_duration:.2f}s")
+
+                while remaining_scene_duration > 0:
+                    if remaining_scene_duration >= self.target_duration:
+                        segment_start = self._seconds_to_time(scene_start + scene_duration - remaining_scene_duration)
+                        segment_end = self._seconds_to_time(scene_start + scene_duration - remaining_scene_duration + self.target_duration)
+                        segment = {
+                            "start": segment_start,
+                            "end": segment_end,
+                            "confidence": scene["confidence"]
+                        }
+                        print(f"[DEBUG] Creating full clip from remaining: {segment_start} -> {segment_end}")
+                        clip_data = self._create_clip(video_path, [segment], clip_number)
+                        clips_data.append(clip_data)
+                        clip_number += 1
+                        remaining_scene_duration -= self.target_duration
+                    else:
+                        segment_start = self._seconds_to_time(scene_end - remaining_scene_duration)
+                        current_segments = [{
+                            "start": segment_start,
+                            "end": scene["end"],
+                            "confidence": scene["confidence"]
+                        }]
+                        print(f"[DEBUG] Keeping remainder for next clip: {segment_start} -> {scene['end']}")
+                        current_duration = remaining_scene_duration
+                        break
+            else:
+                current_segments.append({
+                    "start": scene["start"],
+                    "end": scene["end"],
+                    "confidence": scene["confidence"]
+                })
+                current_duration += scene_duration
+                print(f"[DEBUG] Added full scene to current clip. New duration: {current_duration:.2f}s")
+
+        if current_segments:
+            print(f"\n[DEBUG] Processing remaining segments")
+            clip_data = self._create_clip(video_path, current_segments, clip_number)
+            clips_data.append(clip_data)
+            print(f"[DEBUG] Created final clip {clip_number} with {len(current_segments)} segments")
+
+        print(f"\n[DEBUG] Generated {len(clips_data)} clips in total")
+        return clips_data
+
+    def _create_clip(self, video_path: str, segments: list, clip_number: int) -> dict:
+        """Crée un clip à partir des segments donnés."""
+        total_duration = sum(
+            self._time_to_seconds(segment["end"]) - self._time_to_seconds(segment["start"])
+            for segment in segments
+        )
+        
+        print(f"[DEBUG] Creating clip {clip_number}")
+        print(f"[DEBUG] Total duration: {total_duration:.2f}s")
+        
+        # Créer les sous-clips pour chaque segment
+        subclips = []
+        video = VideoFileClip(video_path)
+        
+        for segment in segments:
+            start_time = self._time_to_seconds(segment["start"])
+            end_time = self._time_to_seconds(segment["end"])
+            print(f"[DEBUG] Extracting segment: {segment['start']} -> {segment['end']}")
+            subclip = video.subclip(start_time, end_time)
+            subclips.append(subclip)
+        
+        # Concaténer tous les sous-clips
+        final_clip = concatenate_videoclips(subclips)
+        
+        # Créer un fichier temporaire pour le clip
+        temp_clip_file = tempfile.NamedTemporaryFile(suffix='.mp4', delete=False)
+        final_clip.write_videofile(
+            temp_clip_file.name,
+            codec='libx264',
+            audio_codec='aac',
+            temp_audiofile='temp-audio.m4a',
+            remove_temp=True
+        )
+        
+        # Fermer les clips pour libérer la mémoire
+        final_clip.close()
+        for subclip in subclips:
+            subclip.close()
+        video.close()
+        
+        total_confidence = sum(segment["confidence"] for segment in segments)
+        avg_confidence = total_confidence / len(segments)
+
+        return {
+            "segments": segments,
+            "clip_number": clip_number,
+            "confidence": avg_confidence,
+            "duration": total_duration,
+            "file_path": temp_clip_file.name  # Ajouter le chemin du fichier
+        }
+    
+if __name__ == "__main__":
+    # Test local
+    test_video_path = "test_video.mp4"  # Remplacer par un chemin réel
+    test_scenes = [
+        {
+            "start": "00:00:00.000",
+            "end": "00:00:30.000",
+            "recognized_sport": "surf",
+            "confidence": 0.95
+        },
+        {
+            "start": "00:00:40.000",
+            "end": "00:01:20.000",
+            "recognized_sport": "surf",
+            "confidence": 0.92
+        },
+        {
+            "start": "00:01:30.000",
+            "end": "00:02:00.000",
+            "recognized_sport": "not_surf",
+            "confidence": 0.88
+        }
+    ]
+
+    clip_generator = ClipGenerator(target_duration=60, min_confidence=0.9)
+    clips = clip_generator.generate_clips(test_video_path, test_scenes, "surf")
+
+    print("\nClips générés :")
+    for i, clip in enumerate(clips, 1):
+        print(f"\nClip {i}:")
+        print(f"Confidence: {clip['confidence']:.2%}")
+        print("Segments:")
+        for segment in clip['segments']:
+            print(f"  {segment['start']} -> {segment['end']} (conf: {segment['confidence']:.2%})")

app/services/video_processing/compression.py

@@ -1,7 +1,7 @@
 import subprocess
 from fastapi import HTTPException
 
-def compress_video(input_path: str, output_path: str, resolution: str = "192x144"):
+def compress_video(input_path: str, output_path: str, resolution: str = "256x144"):
     """Compress video using FFmpeg for maximum reduction, with audio removed."""
     command = [
         "ffmpeg",

app/services/video_processing/hf_upload.py

@@ -1,57 +1,58 @@
-from huggingface_hub import HfApi, create_repo
-import os
-
-class HFUploader:
-    def __init__(self):
-        self.hf_api = HfApi()
-        self.repo_id = os.getenv("HUGGINGFACE_REPO_ID")
-        self._ensure_repo_exists()
-
-
-    def _ensure_repo_exists(self):
-        try:
-            # Vérifie si le repo existe
-            self.hf_api.repo_info(repo_id=self.repo_id, repo_type="dataset")
-            print(f"Repository {self.repo_id} exists")
-        except Exception as e:
-            if "404" in str(e):  # Repo n'existe pas
-                try:
-                    create_repo(
-                        self.repo_id, 
-                        private=False, 
-                        repo_type="dataset",
-                        token=os.getenv("HUGGINGFACE_TOKEN")
-                    )
-                    print(f"Created repository {self.repo_id}")
-                except Exception as create_error:
-                    if "You already created this dataset repo" not in str(create_error):
-                        raise create_error
-            else:
-                raise e
-
-    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")
-        )
+from huggingface_hub import HfApi, create_repo
+import os
+
+class HFUploader:
+    def __init__(self):
+        self.hf_api = HfApi()
+        self.repo_id = os.getenv("HUGGINGFACE_REPO_ID")
+        self._ensure_repo_exists()
+
+
+    def _ensure_repo_exists(self):
+        try:
+            # Vérifie si le repo existe
+            self.hf_api.repo_info(repo_id=self.repo_id, repo_type="dataset")
+            print(f"Repository {self.repo_id} exists")
+        except Exception as e:
+            if "404" in str(e):  # Repo n'existe pas
+                try:
+                    create_repo(
+                        self.repo_id, 
+                        private=False, 
+                        repo_type="dataset",
+                        token=os.getenv("HUGGINGFACE_TOKEN")
+                    )
+                    print(f"Created repository {self.repo_id}")
+                except Exception as create_error:
+                    if "You already created this dataset repo" not in str(create_error):
+                        raise create_error
+            else:
+                raise e
+
+    def ensure_folder_structure(self, sport_id: str):
+        paths = [
+            f"{sport_id}/raw",
+            f"{sport_id}/compressed",
+            f"{sport_id}/clips"
+        ]
+        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/video_processing/scene_classifier.py

@@ -0,0 +1,87 @@
+import cv2
+import torch
+from transformers import AutoImageProcessor, AutoModelForImageClassification
+from collections import Counter
+from PIL import Image
+import os
+
+class SceneClassifier:
+    def __init__(self, model_path: str = "2nzi/Image_Surf_NotSurf"):
+        # print(f"[DEBUG] Initializing SceneClassifier with model: {model_path}")
+        try:
+            # Initialiser le processeur et le modèle
+            self.processor = AutoImageProcessor.from_pretrained(
+                "google/vit-base-patch16-224",
+                use_fast=True
+            )
+            self.model = AutoModelForImageClassification.from_pretrained(
+                model_path,
+                trust_remote_code=True
+            )
+            self.id_to_label = self.model.config.id2label
+            # print("[DEBUG] Model loaded successfully")
+        except Exception as e:
+            # print(f"[ERROR] Failed to load model: {str(e)}")
+            raise
+
+    def _time_to_seconds(self, time_str: str) -> float:
+        h, m, s = time_str.split(':')
+        return int(h) * 3600 + int(m) * 60 + float(s)
+
+    def _extract_frames(self, video_path: str, start_time: str, end_time: str, num_frames: int = 5) -> list:
+        cap = cv2.VideoCapture(video_path)
+        start_sec = self._time_to_seconds(start_time)
+        end_sec = self._time_to_seconds(end_time)
+        scene_duration = end_sec - start_sec
+        frame_interval = scene_duration / (num_frames + 1)
+
+        frames = []
+        for i in range(num_frames):
+            timestamp = start_sec + frame_interval * (i + 1)
+            cap.set(cv2.CAP_PROP_POS_MSEC, timestamp * 1000)
+            success, frame = cap.read()
+            if success:
+                image_pil = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+                frames.append(image_pil)
+            else:
+                print(f"[WARNING] Failed to extract frame at {timestamp} seconds")
+
+        cap.release()
+        return frames
+
+    def _classify_frame(self, frame: Image) -> dict:
+        inputs = self.processor(images=frame, return_tensors="pt")
+        with torch.no_grad():
+            outputs = self.model(**inputs)
+            probs = torch.nn.functional.softmax(outputs.logits, dim=-1)
+            confidence, predicted_class = torch.max(probs, dim=-1)
+
+        return {
+            "label": self.id_to_label[predicted_class.item()],
+            "confidence": float(confidence.item())
+        }
+
+    def classify_scene(self, video_path: str, scene: dict) -> dict:
+        print(f"[DEBUG] Classifying scene: {scene['start']} -> {scene['end']}")
+        frames = self._extract_frames(video_path, scene["start"], scene["end"])
+        if not frames:
+            print("[WARNING] No frames extracted for classification")
+            return {"recognized_sport": "Unknown", "confidence": 0.0}
+
+        classifications = [self._classify_frame(frame) for frame in frames]
+        labels = [c["label"] for c in classifications]
+        
+        label_counts = Counter(labels)
+        predominant_label, count = label_counts.most_common(1)[0]
+        
+        confidence_avg = sum(
+            c["confidence"] for c in classifications 
+            if c["label"] == predominant_label
+        ) / count
+
+        result = {
+            "recognized_sport": predominant_label,
+            "confidence": confidence_avg
+        }
+        print(f"[DEBUG] Classification result: {result}")
+        return result

app/services/video_processing/scene_detection.py

@@ -0,0 +1,69 @@
+import os
+import tempfile
+from fastapi import HTTPException
+from scenedetect import detect, ContentDetector, SceneManager, open_video, scene_manager
+
+class SceneDetector:
+    def __init__(self, min_scene_duration: float = 1.5, threshold: int = 30):
+        self.min_scene_duration = min_scene_duration
+        self.threshold = threshold
+
+    def detect_scenes(self, video_path: str) -> dict:
+        """Pipeline complet de détection et de filtrage des scènes."""
+        print(f"\n[DEBUG] Starting scene detection on video: {video_path}")
+        print(f"[DEBUG] Video file exists: {os.path.exists(video_path)}")
+        
+        try:
+            # Ouvrir la vidéo
+            video = open_video(video_path)
+            
+            # Configurer le détecteur de scènes
+            scene_manager = SceneManager()
+            scene_manager.add_detector(
+                ContentDetector(threshold=self.threshold)
+            )
+            
+            # Détecter les scènes
+            scene_manager.detect_scenes(video)
+            scenes = scene_manager.get_scene_list()
+            
+            # Formater les scènes
+            formatted_scenes = []
+            for scene in scenes:
+                start_time = scene[0].get_timecode()
+                end_time = scene[1].get_timecode()
+                duration = scene[1].get_seconds() - scene[0].get_seconds()
+                
+                if duration >= self.min_scene_duration:
+                    formatted_scenes.append({
+                        "start": str(start_time),
+                        "end": str(end_time),
+                        "recognized_sport": "",  # Sera rempli par le classificateur
+                        "confidence": None  # Sera rempli par le classificateur
+                    })
+
+            result = {
+                "total_scenes": len(formatted_scenes),
+                "scenes": formatted_scenes
+            }
+
+            # Debug logs
+            print("\n[DEBUG] Scene Detection Results:")
+            print(f"Total scenes detected: {result['total_scenes']}")
+            if result['scenes']:
+                print("\nFirst 3 scenes details:")
+                for i, scene in enumerate(result['scenes'][:3]):
+                    print(f"\nScene {i+1}:")
+                    print(f"  Start: {scene['start']}")
+                    print(f"  End: {scene['end']}")
+                    print(f"  Sport: {scene['recognized_sport']}")
+                    print(f"  Confidence: {scene['confidence']}")
+            else:
+                print("No scenes detected!")
+            print("\n")
+
+            return result
+
+        except Exception as e:
+            print(f"[ERROR] Scene detection failed: {str(e)}")
+            raise HTTPException(status_code=500, detail=f"Scene detection failed: {str(e)}")

app/services/video_processing/scrape_hf.py

@@ -0,0 +1,24 @@
+from bs4 import BeautifulSoup
+import requests
+
+def extract_video_urls(url):
+    # Récupérer le contenu de la page
+    response = requests.get(url)
+    html_content = response.text
+    
+    # Créer un objet BeautifulSoup
+    soup = BeautifulSoup(html_content, 'html.parser')
+    
+    # Trouver toutes les balises source
+    video_sources = soup.find_all('source')
+    
+    # Extraire les URLs
+    video_urls = []
+    for source in video_sources:
+        url = source.get('src')
+        if url:
+            # Nettoyer l'URL en retirant le #t=0.001
+            clean_url = url.split('#')[0]
+            video_urls.append(clean_url)
+    
+    return video_urls

main.py

@@ -20,56 +20,6 @@ app.add_middleware(
     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("/")