update app.py

app.py

@@ -1,185 +1,45 @@
-# from fastapi import FastAPI, UploadFile, File
-# import cv2
-# import torch
-# import pandas as pd
-# from PIL import Image
-# from transformers import AutoImageProcessor, AutoModelForImageClassification
-# from tqdm import tqdm
-# import json
-# import shutil
-# from fastapi.middleware.cors import CORSMiddleware
-# from fastapi.responses import HTMLResponse
-
-# app = FastAPI()
-
-# # Add CORS middleware to allow requests from localhost:8080 (or any origin you specify)
-# app.add_middleware(
-#     CORSMiddleware,
-#     # allow_origins=["http://localhost:8080"],  # Replace with the URL of your Vue.js app
-#     allow_origins=["http://localhost:8080"],  # Replace with the URL of your Vue.js app
-#     allow_credentials=True,
-#     allow_methods=["*"],  # Allows all HTTP methods (GET, POST, etc.)
-#     allow_headers=["*"],  # Allows all headers (such as Content-Type, Authorization, etc.)
-# )
-
-# # Charger le processor et le modèle fine-tuné depuis le chemin local
-# local_model_path = r'./vit-finetuned-ucf101'
-# processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224")
-# model = AutoModelForImageClassification.from_pretrained(local_model_path)
-# # model = AutoModelForImageClassification.from_pretrained("2nzi/vit-finetuned-ucf101") 
-# model.eval()
-
-# # Fonction pour classifier une image
-# def classifier_image(image):
-#     image_pil = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
-#     inputs = processor(images=image_pil, return_tensors="pt")
-#     with torch.no_grad():
-#         outputs = model(**inputs)
-#         logits = outputs.logits
-#     predicted_class_idx = logits.argmax(-1).item()
-#     predicted_class = model.config.id2label[predicted_class_idx]
-#     return predicted_class
-
-# # Fonction pour traiter la vidéo et identifier les séquences de "Surfing"
-# def identifier_sequences_surfing(video_path, intervalle=0.5):
-#     cap = cv2.VideoCapture(video_path)
-#     frame_rate = cap.get(cv2.CAP_PROP_FPS)
-#     total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-#     frame_interval = int(frame_rate * intervalle)
-
-#     resultats = []
-#     sequences_surfing = []
-#     frame_index = 0
-#     in_surf_sequence = False
-#     start_timestamp = None
-
-#     with tqdm(total=total_frames, desc="Traitement des frames de la vidéo", unit="frame") as pbar:
-#         success, frame = cap.read()
-#         while success:
-#             if frame_index % frame_interval == 0:
-#                 timestamp = round(frame_index / frame_rate, 2)  # Maintain precision to the centisecond level
-#                 classe = classifier_image(frame)
-#                 resultats.append({"Timestamp": timestamp, "Classe": classe})
-
-#                 if classe == "Surfing" and not in_surf_sequence:
-#                     in_surf_sequence = True
-#                     start_timestamp = timestamp
-
-#                 elif classe != "Surfing" and in_surf_sequence:
-#                     # Vérifier l'image suivante pour confirmer si c'était une erreur ponctuelle
-#                     success_next, frame_next = cap.read()
-#                     next_timestamp = round((frame_index + frame_interval) / frame_rate, 2)
-#                     classe_next = None
-
-#                     if success_next:
-#                         classe_next = classifier_image(frame_next)
-#                         resultats.append({"Timestamp": next_timestamp, "Classe": classe_next})
-
-#                     # Si l'image suivante est "Surfing", on ignore l'erreur ponctuelle
-#                     if classe_next == "Surfing":
-#                         success = success_next
-#                         frame = frame_next
-#                         frame_index += frame_interval
-#                         pbar.update(frame_interval)
-#                         continue
-#                     else:
-#                         # Sinon, terminer la séquence "Surfing"
-#                         in_surf_sequence = False
-#                         end_timestamp = timestamp
-#                         sequences_surfing.append((start_timestamp, end_timestamp))
-
-#             success, frame = cap.read()
-#             frame_index += 1
-#             pbar.update(1)
-
-#     # Si on est toujours dans une séquence "Surfing" à la fin de la vidéo
-#     if in_surf_sequence:
-#         sequences_surfing.append((start_timestamp, round(frame_index / frame_rate, 2)))
-
-#     cap.release()
-#     dataframe_sequences = pd.DataFrame(sequences_surfing, columns=["Début", "Fin"])
-#     return dataframe_sequences
-
-# # Fonction pour convertir les séquences en format JSON
-# def convertir_sequences_en_json(dataframe):
-#     events = []
-#     blocks = []
-#     for idx, row in dataframe.iterrows():
-#         block = {
-#             "id": f"Surfing{idx + 1}",
-#             "start": round(row["Début"], 2),
-#             "end": round(row["Fin"], 2)
-#         }
-#         blocks.append(block)
-#     event = {
-#         "event": "Surfing",
-#         "blocks": blocks
-#     }
-#     events.append(event)
-#     return events
-
-# @app.post("/analyze_video/")
-# async def analyze_video(file: UploadFile = File(...)):
-#     with open("uploaded_video.mp4", "wb") as buffer:
-#         shutil.copyfileobj(file.file, buffer)
-
-#     dataframe_sequences = identifier_sequences_surfing("uploaded_video.mp4", intervalle=1)
-#     json_result = convertir_sequences_en_json(dataframe_sequences)
-#     return json_result
-
-# @app.get("/", response_class=HTMLResponse)
-# async def index():
-#     return (
-#         """
-#         <html>
-#             <body>
-#                 <h1>Hello world!</h1>
-#                 <p>This `/` is the most simple and default endpoint.</p>
-#                 <p>If you want to learn more, check out the documentation of the API at 
-#                 <a href='/docs'>/docs</a> or 
-#                 <a href='https://2nzi-video-sequence-labeling.hf.space/docs' target='_blank'>external docs</a>.
-#                 </p>
-#             </body>
-#         </html>
-#         """
-#     )
-
-
-# # Lancer l'application avec uvicorn (command line)
-# # uvicorn main:app --reload
-# # http://localhost:8000/docs#/
-# # (.venv) PS C:\Users\antoi\Documents\Work_Learn\Labeling-Deploy\FastAPI> uvicorn main:app --host 0.0.0.0 --port 8000 --workers 1
-
-
-from fastapi import FastAPI, UploadFile, File
+from fastapi import FastAPI, UploadFile, File, HTTPException
 import cv2
 import torch
 import pandas as pd
 from PIL import Image
 from transformers import AutoImageProcessor, AutoModelForImageClassification
 from tqdm import tqdm
-import json
 import shutil
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import HTMLResponse
+from huggingface_hub import HfApi
+import os
+from dotenv import load_dotenv
+
+# Charger les variables d'environnement, y compris la clé API Hugging Face
+load_dotenv()
+
+api_key = os.getenv("HUGGINGFACE_API_KEY")
+if not api_key:
+    raise ValueError("La clé API Hugging Face n'est pas définie dans le fichier .env.")
+
+# Initialiser l'API Hugging Face
+hf_api = HfApi()
 
 app = FastAPI()
 
-# Add CORS middleware to allow requests from localhost:8080 (or any origin you specify)
+# Add CORS middleware to allow requests from Vue.js frontend
 app.add_middleware(
     CORSMiddleware,
-    # allow_origins=["http://localhost:8080"],  # Replace with the URL of your Vue.js app
-    allow_origins=["https://labeling-163849140747.europe-west9.run.app/"],  # Replace with the URL of your Vue.js app
+    allow_origins=[
+        "http://localhost:8080",
+        "https://labeling2-163849140747.europe-west9.run.app/",
+    ],
     allow_credentials=True,
-    allow_methods=["*"],  # Allows all HTTP methods (GET, POST, etc.)
-    allow_headers=["*"],  # Allows all headers (such as Content-Type, Authorization, etc.)
+    allow_methods=["*"],  # Permet toutes les méthodes HTTP (GET, POST, etc.)
+    allow_headers=["*"],  # Permet tous les en-têtes (Content-Type, Authorization, etc.)
 )
 
-# Charger le processor et le modèle fine-tuné depuis le chemin local
+# Charger le processeur d'image et le modèle fine-tuné localement
 local_model_path = r'./vit-finetuned-ucf101'
 processor = AutoImageProcessor.from_pretrained("google/vit-base-patch16-224")
 model = AutoModelForImageClassification.from_pretrained(local_model_path)
-# model = AutoModelForImageClassification.from_pretrained("2nzi/vit-finetuned-ucf101") 
 model.eval()
 
 # Fonction pour classifier une image
@@ -200,7 +60,6 @@ def identifier_sequences_surfing(video_path, intervalle=0.5):
     total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
     frame_interval = int(frame_rate * intervalle)
 
-    resultats = []
     sequences_surfing = []
     frame_index = 0
     in_surf_sequence = False
@@ -210,42 +69,21 @@ def identifier_sequences_surfing(video_path, intervalle=0.5):
         success, frame = cap.read()
         while success:
             if frame_index % frame_interval == 0:
-                timestamp = round(frame_index / frame_rate, 2)  # Maintain precision to the centisecond level
+                timestamp = round(frame_index / frame_rate, 2)
                 classe = classifier_image(frame)
-                resultats.append({"Timestamp": timestamp, "Classe": classe})
 
                 if classe == "Surfing" and not in_surf_sequence:
                     in_surf_sequence = True
                     start_timestamp = timestamp
-
                 elif classe != "Surfing" and in_surf_sequence:
-                    # Vérifier l'image suivante pour confirmer si c'était une erreur ponctuelle
-                    success_next, frame_next = cap.read()
-                    next_timestamp = round((frame_index + frame_interval) / frame_rate, 2)
-                    classe_next = None
-
-                    if success_next:
-                        classe_next = classifier_image(frame_next)
-                        resultats.append({"Timestamp": next_timestamp, "Classe": classe_next})
-
-                    # Si l'image suivante est "Surfing", on ignore l'erreur ponctuelle
-                    if classe_next == "Surfing":
-                        success = success_next
-                        frame = frame_next
-                        frame_index += frame_interval
-                        pbar.update(frame_interval)
-                        continue
-                    else:
-                        # Sinon, terminer la séquence "Surfing"
-                        in_surf_sequence = False
-                        end_timestamp = timestamp
-                        sequences_surfing.append((start_timestamp, end_timestamp))
+                    in_surf_sequence = False
+                    end_timestamp = timestamp
+                    sequences_surfing.append((start_timestamp, end_timestamp))
 
             success, frame = cap.read()
             frame_index += 1
             pbar.update(1)
 
-    # Si on est toujours dans une séquence "Surfing" à la fin de la vidéo
     if in_surf_sequence:
         sequences_surfing.append((start_timestamp, round(frame_index / frame_rate, 2)))
 
@@ -271,25 +109,61 @@ def convertir_sequences_en_json(dataframe):
     events.append(event)
     return events
 
-
-import os
-import tempfile
-
+# Endpoint pour analyser la vidéo et uploader sur Hugging Face
 @app.post("/analyze_video/")
-async def analyze_video(file: UploadFile = File(...)):
-    # Utiliser tempfile pour créer un fichier temporaire
-    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4", dir="/tmp") as tmp:
-        shutil.copyfileobj(file.file, tmp)
-        tmp_path = tmp.name
-
-    # Analyser la vidéo
-    dataframe_sequences = identifier_sequences_surfing(tmp_path, intervalle=1)
-    json_result = convertir_sequences_en_json(dataframe_sequences)
+async def analyze_video(user_name: str, file: UploadFile = File(...)):
+    try:
+        # Sauvegarder la vidéo temporairement
+        temp_file_path = f"/tmp/{file.filename}"
+        with open(temp_file_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+
+        # Uploader la vidéo sur Hugging Face Hub
+        dataset_name = "2nzi/Video-Sequence-Labeling"
+        target_path_in_repo = f"{user_name}/raw/{file.filename}"
+
+        hf_api.upload_file(
+            path_or_fileobj=temp_file_path,
+            path_in_repo=target_path_in_repo,
+            repo_id=dataset_name,
+            repo_type="dataset",
+            token=api_key
+        )
+
+        # Analyser la vidéo pour trouver des séquences "Surfing"
+        dataframe_sequences = identifier_sequences_surfing(temp_file_path, intervalle=1)
+        json_result = convertir_sequences_en_json(dataframe_sequences)
+
+        # Supprimer le fichier temporaire après l'upload
+        os.remove(temp_file_path)
+
+        return {"message": "Video uploaded and analyzed successfully!", 
+                "file_url": f"https://huggingface.co/datasets/{dataset_name}/resolve/main/{target_path_in_repo}", 
+                "analysis": json_result}
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to upload or analyze video: {str(e)}")
+
+# Fonction pour uploader une vidéo vers un dataset Hugging Face
+def upload_to_hf_dataset(user_name: str, video_path: str):
+    dataset_name = "2nzi/Video-Sequence-Labeling"
+    repo_path = f"{user_name}/raw/{os.path.basename(video_path)}"
+
+    try:
+        hf_api.upload_file(
+            path_or_fileobj=video_path,
+            path_in_repo=repo_path,
+            repo_id=dataset_name,
+            repo_type="dataset",
+            token=api_key
+        )
+        
+        # Retourner l'URL de la vidéo après l'upload
+        url = f"https://huggingface.co/datasets/{dataset_name}/resolve/main/{repo_path}"
+        return {"status": "success", "url": url}
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
 
-    # Supprimer le fichier temporaire après utilisation
-    os.remove(tmp_path)
-
-    return {"filename": file.filename, "result": json_result}
 
 @app.get("/", response_class=HTMLResponse)
 async def index():
@@ -308,8 +182,7 @@ async def index():
         """
     )
 
-
 # Lancer l'application avec uvicorn (command line)
 # uvicorn main:app --reload
 # http://localhost:8000/docs#/
-# (.venv) PS C:\Users\antoi\Documents\Work_Learn\Labeling-Deploy\FastAPI> uvicorn main:app --host 0.0.0.0 --port 8000 --workers 1
+# (.venv) PS C:\Users\antoi\Documents\Work_Learn\Labeling-Deploy\FastAPI> uvicorn main:app --host 0.0.0.0 --port 8000 --workers 1