Upload 7 files

storage/common.py

@@ -1,14 +1,14 @@
-from fastapi import HTTPException
-import os
-
-def validate_token(token: str):
-    """
-    Validate the provided token against the HF_TOKEN environment variable.
-    Raises an HTTPException if validation fails.
-    """
-    HF_TOKEN = os.getenv("HF_TOKEN")
-    if HF_TOKEN is None:
-        raise RuntimeError("HF_TOKEN environment variable is not set on the server.")
-
-    if token != HF_TOKEN:
+from fastapi import HTTPException
+import os
+
+def validate_token(token: str):
+    """
+    Validate the provided token against the HF_TOKEN environment variable.
+    Raises an HTTPException if validation fails.
+    """
+    HF_TOKEN = os.getenv("HF_TOKEN")
+    if HF_TOKEN is None:
+        raise RuntimeError("HF_TOKEN environment variable is not set on the server.")
+
+    if token != HF_TOKEN:
         raise HTTPException(status_code=401, detail="Invalid token")

storage/data_routers.py

@@ -1,194 +1,194 @@
-import os
-import io
-import json
-import shutil
-
-import sqlite3
-
-from pathlib import Path
-
-from fastapi import APIRouter, UploadFile, File, Query, HTTPException
-from fastapi.responses import FileResponse, JSONResponse
-
-
-from storage.files.file_manager import FileManager
-from storage.common import validate_token
-
-router = APIRouter(prefix="/data", tags=["Data Manager"])
-DATA_ROOT = Path("/data")
-HF_TOKEN = os.getenv("HF_TOKEN")
-
-
-@router.get("/data_tree", tags=["Data Manager"])
-def get_data_tree(
-    token: str = Query(..., description="Token required for authorization")
-):
-    """
-    Return a formatted tree of folders and files under /data.
-
-    Behavior:
-    - Validate token.
-    - Walk the /data directory and build a recursive tree.
-    - Each entry includes: name, type (file/directory), and children if directory.
-    """
-
-    validate_token(token)
-
-    def build_tree(path: Path):
-        """
-        Build a tree representation of directories and files.
-        Prevents errors by checking if the path is a directory before iterating.
-        """
-    
-        if not path.exists():
-            return {"name": path.name, "type": "missing"}
-    
-        # Si es un fichero → devolvemos un nodo simple
-        if path.is_file():
-            return {
-                "name": path.name,
-                "type": "file"
-            }
-    
-        # Si es un directorio → construimos sus hijos
-        children = []
-        try:
-            entries = sorted(path.iterdir(), key=lambda p: p.name.lower())
-        except Exception:
-            # Si por cualquier razón no podemos listar, lo tratamos como file
-            return {
-                "name": path.name,
-                "type": "file"
-            }
-    
-        for child in entries:
-            children.append(build_tree(child))
-    
-        return {
-            "name": path.name,
-            "type": "directory",
-            "children": children
-        }
-
-    if not DATA_ROOT.exists():
-        return {"error": "/data does not exist"}
-
-    return build_tree(DATA_ROOT)
-
-@router.post("/create_data_item", tags=["Data Manager"])
-def create_data_item(
-    path: str = Query(..., description="Full path starting with /data/"),
-    item_type: str = Query(..., description="directory or file"),
-    token: str = Query(..., description="Token required for authorization")
-):
-    """
-    Create a directory or file under /data.
-
-    Restrictions:
-    - Path must start with /data/.
-    - Writing to /data/db or /data/media (or any of their subpaths) is forbidden.
-    - item_type must be 'directory' or 'file'.
-
-    Behavior:
-    - Validate token.
-    - Check path validity and protection.
-    - Create directory or empty file.
-    - Raise error if path already exists.
-    """
-
-    validate_token(token)
-
-    target = Path(path)
-
-    # Validación básica
-    if not path.startswith("/data/"):
-        raise HTTPException(status_code=400, detail="Path must start with /data/")
-
-    if item_type not in ("directory", "file"):
-        raise HTTPException(status_code=400, detail="item_type must be 'directory' or 'file'")
-
-    # Protección de carpetas sensibles
-    protected = ["/data/db", "/data/media"]
-
-    for p in protected:
-        if path == p or path.startswith(p + "/"):
-            raise HTTPException(
-                status_code=403,
-                detail=f"Access to protected path '{p}' is not allowed"
-            )
-
-    # No permitir sobrescritura
-    if target.exists():
-        raise HTTPException(status_code=409, detail="Path already exists")
-
-    try:
-        if item_type == "directory":
-            target.mkdir(parents=True, exist_ok=False)
-        else:
-            target.parent.mkdir(parents=True, exist_ok=True)
-            with open(target, "wb") as f:
-                f.write(b"")
-    except Exception as exc:
-        raise HTTPException(status_code=500, detail=f"Failed to create item: {exc}")
-
-    return {
-        "status": "ok",
-        "created": str(target),
-        "type": item_type
-    }
-
-@router.delete("/delete_path", tags=["Data Manager"])
-def delete_path(
-    target: str = Query(..., description="Ruta absoluta dentro de /data a borrar"),
-    token: str = Query(..., description="Token requerido para autorización")
-):
-    """
-    Delete a file or directory recursively inside /data, except protected folders.
-
-    Behavior:
-    - Validate token.
-    - Validate path starts with /data/.
-    - Deny deletion of /data/db and /data/media (and anything inside them).
-    - If target is a file → delete file.
-    - If target is a directory → delete recursively.
-    """
-
-    validate_token(token)
-
-    # Normalizar ruta
-    path = Path(target).resolve()
-
-    # Debe estar dentro de /data/
-    if not str(path).startswith(str(DATA_ROOT)):
-        raise HTTPException(status_code=400, detail="Path must be inside /data/")
-
-    # Carpetas protegidas
-    protected = [
-        DATA_ROOT / "db",
-        DATA_ROOT / "media",
-    ]
-
-    for p in protected:
-        if path == p or str(path).startswith(str(p) + "/"):
-            raise HTTPException(
-                status_code=403,
-                detail=f"Deletion forbidden: {p} is protected"
-            )
-
-    # Verificar existencia
-    if not path.exists():
-        raise HTTPException(status_code=404, detail="Target path does not exist")
-
-    try:
-        if path.is_file():
-            path.unlink()
-        else:
-            shutil.rmtree(path)
-
-    except Exception as exc:
-        raise HTTPException(status_code=500, detail=f"Failed to delete: {exc}")
-
-    return {
-        "status": "ok",
-        "deleted": str(path)
+import os
+import io
+import json
+import shutil
+
+import sqlite3
+
+from pathlib import Path
+
+from fastapi import APIRouter, UploadFile, File, Query, HTTPException
+from fastapi.responses import FileResponse, JSONResponse
+
+
+from storage.files.file_manager import FileManager
+from storage.common import validate_token
+
+router = APIRouter(prefix="/data", tags=["Data Manager"])
+DATA_ROOT = Path("/data")
+HF_TOKEN = os.getenv("HF_TOKEN")
+
+
+@router.get("/data_tree", tags=["Data Manager"])
+def get_data_tree(
+    token: str = Query(..., description="Token required for authorization")
+):
+    """
+    Return a formatted tree of folders and files under /data.
+
+    Behavior:
+    - Validate token.
+    - Walk the /data directory and build a recursive tree.
+    - Each entry includes: name, type (file/directory), and children if directory.
+    """
+
+    validate_token(token)
+
+    def build_tree(path: Path):
+        """
+        Build a tree representation of directories and files.
+        Prevents errors by checking if the path is a directory before iterating.
+        """
+    
+        if not path.exists():
+            return {"name": path.name, "type": "missing"}
+    
+        # Si es un fichero → devolvemos un nodo simple
+        if path.is_file():
+            return {
+                "name": path.name,
+                "type": "file"
+            }
+    
+        # Si es un directorio → construimos sus hijos
+        children = []
+        try:
+            entries = sorted(path.iterdir(), key=lambda p: p.name.lower())
+        except Exception:
+            # Si por cualquier razón no podemos listar, lo tratamos como file
+            return {
+                "name": path.name,
+                "type": "file"
+            }
+    
+        for child in entries:
+            children.append(build_tree(child))
+    
+        return {
+            "name": path.name,
+            "type": "directory",
+            "children": children
+        }
+
+    if not DATA_ROOT.exists():
+        return {"error": "/data does not exist"}
+
+    return build_tree(DATA_ROOT)
+
+@router.post("/create_data_item", tags=["Data Manager"])
+def create_data_item(
+    path: str = Query(..., description="Full path starting with /data/"),
+    item_type: str = Query(..., description="directory or file"),
+    token: str = Query(..., description="Token required for authorization")
+):
+    """
+    Create a directory or file under /data.
+
+    Restrictions:
+    - Path must start with /data/.
+    - Writing to /data/db or /data/media (or any of their subpaths) is forbidden.
+    - item_type must be 'directory' or 'file'.
+
+    Behavior:
+    - Validate token.
+    - Check path validity and protection.
+    - Create directory or empty file.
+    - Raise error if path already exists.
+    """
+
+    validate_token(token)
+
+    target = Path(path)
+
+    # Validación básica
+    if not path.startswith("/data/"):
+        raise HTTPException(status_code=400, detail="Path must start with /data/")
+
+    if item_type not in ("directory", "file"):
+        raise HTTPException(status_code=400, detail="item_type must be 'directory' or 'file'")
+
+    # Protección de carpetas sensibles
+    protected = ["/data/db", "/data/media"]
+
+    for p in protected:
+        if path == p or path.startswith(p + "/"):
+            raise HTTPException(
+                status_code=403,
+                detail=f"Access to protected path '{p}' is not allowed"
+            )
+
+    # No permitir sobrescritura
+    if target.exists():
+        raise HTTPException(status_code=409, detail="Path already exists")
+
+    try:
+        if item_type == "directory":
+            target.mkdir(parents=True, exist_ok=False)
+        else:
+            target.parent.mkdir(parents=True, exist_ok=True)
+            with open(target, "wb") as f:
+                f.write(b"")
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"Failed to create item: {exc}")
+
+    return {
+        "status": "ok",
+        "created": str(target),
+        "type": item_type
+    }
+
+@router.delete("/delete_path", tags=["Data Manager"])
+def delete_path(
+    target: str = Query(..., description="Ruta absoluta dentro de /data a borrar"),
+    token: str = Query(..., description="Token requerido para autorización")
+):
+    """
+    Delete a file or directory recursively inside /data, except protected folders.
+
+    Behavior:
+    - Validate token.
+    - Validate path starts with /data/.
+    - Deny deletion of /data/db and /data/media (and anything inside them).
+    - If target is a file → delete file.
+    - If target is a directory → delete recursively.
+    """
+
+    validate_token(token)
+
+    # Normalizar ruta
+    path = Path(target).resolve()
+
+    # Debe estar dentro de /data/
+    if not str(path).startswith(str(DATA_ROOT)):
+        raise HTTPException(status_code=400, detail="Path must be inside /data/")
+
+    # Carpetas protegidas
+    protected = [
+        DATA_ROOT / "db",
+        DATA_ROOT / "media",
+    ]
+
+    for p in protected:
+        if path == p or str(path).startswith(str(p) + "/"):
+            raise HTTPException(
+                status_code=403,
+                detail=f"Deletion forbidden: {p} is protected"
+            )
+
+    # Verificar existencia
+    if not path.exists():
+        raise HTTPException(status_code=404, detail="Target path does not exist")
+
+    try:
+        if path.is_file():
+            path.unlink()
+        else:
+            shutil.rmtree(path)
+
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"Failed to delete: {exc}")
+
+    return {
+        "status": "ok",
+        "deleted": str(path)
     }

storage/db_routers.py

@@ -1,137 +1,137 @@
-import os
-import io
-
-import sqlite3
-import zipfile
-
-from pathlib import Path
-
-from fastapi import APIRouter, UploadFile, File, Query, HTTPException
-from fastapi.responses import JSONResponse, StreamingResponse
-
-from storage.common import validate_token
-
-router = APIRouter(prefix="/db", tags=["Database Manager"])
-HF_TOKEN = os.getenv("HF_TOKEN")
-DB_PATH = Path("/data/db")
-
-@router.get("/download_all_db_files", tags=["Database Manager"])
-async def download_all_db_files(
-    token: str = Query(..., description="Token required for authorization")
-):
-    """
-    Download all .db files from /data/db as a ZIP archive.
-
-    Steps:
-    - Validate the token.
-    - Verify that /data/db exists and contains .db files.
-    - Create an in-memory ZIP containing all .db files.
-    - Return the ZIP as a downloadable file.
-    """
-    validate_token(token)
-
-    if not DB_PATH.exists():
-        raise HTTPException(status_code=404, detail="DB folder does not exist")
-
-    db_files = list(DB_PATH.glob("*.db"))
-    if not db_files:
-        raise HTTPException(status_code=404, detail="No .db files found")
-
-    # Create in-memory ZIP
-    zip_buffer = io.BytesIO()
-
-    with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zipf:
-        for file_path in db_files:
-            zipf.write(file_path, arcname=file_path.name)
-
-    zip_buffer.seek(0)
-
-    return StreamingResponse(
-        zip_buffer,
-        media_type="application/zip",
-        headers={
-            "Content-Disposition": 'attachment; filename="db_files.zip"'
-        }
-    )
-
-
-@router.post("/upload_db_file", tags=["Database Manager"])
-async def upload_db_file(
-    file: UploadFile = File(...),
-    token: str = Query(..., description="Token required for authorization")
-):
-    """
-    Upload a file to the /data/db folder.
-
-    Steps:
-    - Validate the token.
-    - Ensure /data/db exists (create it if missing).
-    - Save the uploaded file inside /data/db using its original filename.
-    - Return a JSON response confirming the upload.
-    """
-    validate_token(token)
-
-    # Crear carpeta /data/db si no existe
-    DB_PATH.mkdir(parents=True, exist_ok=True)
-
-    final_path = DB_PATH / file.filename
-
-    try:
-        # Leer contenido en memoria y guardar
-        file_bytes = await file.read()
-        with open(final_path, "wb") as f:
-            f.write(file_bytes)
-    except Exception as exc:
-        raise HTTPException(status_code=500, detail=f"Failed to save file: {exc}")
-
-    return JSONResponse(
-        status_code=200,
-        content={
-            "status": "ok",
-            "saved_to": str(final_path)
-        }
-    )
-
-@router.post("/execute_query", tags=["Database Manager"])
-async def execute_query(
-    db_filename: str = Query(..., description="SQLite .db file name"),
-    query: str = Query(..., description="SQL query to execute"),
-    token: str = Query(..., description="Token required for authorization")
-):
-    """
-    Execute a SQL query against a specified SQLite database file in /data/db.
-
-    Steps:
-    - Validate the token.
-    - Ensure the requested .db file exists inside /data/db.
-    - Connect to the database using sqlite3.
-    - Execute the provided query.
-    - Return the results as a list of dictionaries (column: value).
-    - Capture and return errors if query execution fails.
-    """
-    validate_token(token)
-
-    db_file_path = DB_PATH / db_filename
-
-    if not db_file_path.exists() or not db_file_path.is_file():
-        raise HTTPException(status_code=404, detail=f"Database file {db_filename} not found")
-
-    try:
-        conn = sqlite3.connect(db_file_path)
-        conn.row_factory = sqlite3.Row  # para devolver columnas por nombre
-        cur = conn.cursor()
-
-        cur.execute(query)
-        rows = cur.fetchall()
-
-        # Convert rows to list of dicts
-        results = [dict(row) for row in rows]
-
-        conn.commit()
-        conn.close()
-    except sqlite3.Error as e:
-        raise HTTPException(status_code=400, detail=f"SQL error: {e}")
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Unexpected error: {e}")
-
+import os
+import io
+
+import sqlite3
+import zipfile
+
+from pathlib import Path
+
+from fastapi import APIRouter, UploadFile, File, Query, HTTPException
+from fastapi.responses import JSONResponse, StreamingResponse
+
+from storage.common import validate_token
+
+router = APIRouter(prefix="/db", tags=["Database Manager"])
+HF_TOKEN = os.getenv("HF_TOKEN")
+DB_PATH = Path("/data/db")
+
+@router.get("/download_all_db_files", tags=["Database Manager"])
+async def download_all_db_files(
+    token: str = Query(..., description="Token required for authorization")
+):
+    """
+    Download all .db files from /data/db as a ZIP archive.
+
+    Steps:
+    - Validate the token.
+    - Verify that /data/db exists and contains .db files.
+    - Create an in-memory ZIP containing all .db files.
+    - Return the ZIP as a downloadable file.
+    """
+    validate_token(token)
+
+    if not DB_PATH.exists():
+        raise HTTPException(status_code=404, detail="DB folder does not exist")
+
+    db_files = list(DB_PATH.glob("*.db"))
+    if not db_files:
+        raise HTTPException(status_code=404, detail="No .db files found")
+
+    # Create in-memory ZIP
+    zip_buffer = io.BytesIO()
+
+    with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zipf:
+        for file_path in db_files:
+            zipf.write(file_path, arcname=file_path.name)
+
+    zip_buffer.seek(0)
+
+    return StreamingResponse(
+        zip_buffer,
+        media_type="application/zip",
+        headers={
+            "Content-Disposition": 'attachment; filename="db_files.zip"'
+        }
+    )
+
+
+@router.post("/upload_db_file", tags=["Database Manager"])
+async def upload_db_file(
+    file: UploadFile = File(...),
+    token: str = Query(..., description="Token required for authorization")
+):
+    """
+    Upload a file to the /data/db folder.
+
+    Steps:
+    - Validate the token.
+    - Ensure /data/db exists (create it if missing).
+    - Save the uploaded file inside /data/db using its original filename.
+    - Return a JSON response confirming the upload.
+    """
+    validate_token(token)
+
+    # Crear carpeta /data/db si no existe
+    DB_PATH.mkdir(parents=True, exist_ok=True)
+
+    final_path = DB_PATH / file.filename
+
+    try:
+        # Leer contenido en memoria y guardar
+        file_bytes = await file.read()
+        with open(final_path, "wb") as f:
+            f.write(file_bytes)
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"Failed to save file: {exc}")
+
+    return JSONResponse(
+        status_code=200,
+        content={
+            "status": "ok",
+            "saved_to": str(final_path)
+        }
+    )
+
+@router.post("/execute_query", tags=["Database Manager"])
+async def execute_query(
+    db_filename: str = Query(..., description="SQLite .db file name"),
+    query: str = Query(..., description="SQL query to execute"),
+    token: str = Query(..., description="Token required for authorization")
+):
+    """
+    Execute a SQL query against a specified SQLite database file in /data/db.
+
+    Steps:
+    - Validate the token.
+    - Ensure the requested .db file exists inside /data/db.
+    - Connect to the database using sqlite3.
+    - Execute the provided query.
+    - Return the results as a list of dictionaries (column: value).
+    - Capture and return errors if query execution fails.
+    """
+    validate_token(token)
+
+    db_file_path = DB_PATH / db_filename
+
+    if not db_file_path.exists() or not db_file_path.is_file():
+        raise HTTPException(status_code=404, detail=f"Database file {db_filename} not found")
+
+    try:
+        conn = sqlite3.connect(db_file_path)
+        conn.row_factory = sqlite3.Row  # para devolver columnas por nombre
+        cur = conn.cursor()
+
+        cur.execute(query)
+        rows = cur.fetchall()
+
+        # Convert rows to list of dicts
+        results = [dict(row) for row in rows]
+
+        conn.commit()
+        conn.close()
+    except sqlite3.Error as e:
+        raise HTTPException(status_code=400, detail=f"SQL error: {e}")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Unexpected error: {e}")
+
     return JSONResponse(content={"results": results})

storage/embeddings_routers.py

@@ -1,162 +1,162 @@
-import os
-import io
-import json
-import shutil
-
-import sqlite3
-
-from pathlib import Path
-
-from fastapi import APIRouter, UploadFile, File, Query, HTTPException
-from fastapi.responses import FileResponse, JSONResponse
-
-
-from storage.files.file_manager import FileManager
-from storage.common import validate_token
-
-router = APIRouter(prefix="/embeddings", tags=["Embeddings Manager"])
-EMBEDDINGS_ROOT = Path("/data/embeddings")
-file_manager = FileManager(EMBEDDINGS_ROOT)
-HF_TOKEN = os.getenv("HF_TOKEN")
-
-
-@router.get("/list_embeddings", tags=["Embeddings Manager"])
-def list_all_embeddings(
-    token: str = Query(..., description="Token required for authorization")
-):
-    """
-    List all embeddings stored under /data/embeddings.
-
-    For each video hash folder, returns:
-    - video: folder name (hash)
-    - faces: true/false depending on whether faces/embeddings.json exists
-    - voices: true/false depending on whether voices/embeddings.json exists
-
-    Notes:
-    - A video folder may contain only faces, only voices, or neither.
-    - Missing folders are treated as false.
-    """
-    validate_token(token)
-
-    results = []
-
-    # If embeddings root does not exist, return empty list
-    if not EMBEDDINGS_ROOT.exists():
-        return []
-
-    for video_dir in EMBEDDINGS_ROOT.iterdir():
-        if not video_dir.is_dir():
-            continue  # Skip anything that is not a folder
-
-        faces_path = video_dir / "faces" / "embeddings.json"
-        voices_path = video_dir / "voices" / "embeddings.json"
-
-        results.append({
-            "video": video_dir.name,
-            "faces": faces_path.exists(),
-            "voices": voices_path.exists()
-        })
-
-    return results
-
-
-@router.post("/upload_embeddings", tags=["Embeddings Manager"])
-async def upload_embeddings(
-    file: UploadFile = File(...),
-    embedding_type: str = Query(..., description="faces or voices"),
-    video_hash: str = Query(..., description="Hash of the video"),
-    token: str = Query(..., description="Token required for authorization")
-):
-    """
-    Upload embeddings JSON for a given video and type (faces or voices).
-
-    Behavior:
-    - Validate the token.
-    - Validate embedding_type.
-    - Ensure directory structure: /data/embeddings/<video_hash>/<embedding_type>/
-    - Delete any existing .json file inside that folder.
-    - Save the uploaded embeddings as embeddings.json.
-    """
-    validate_token(token)
-
-    # Validación del tipo
-    if embedding_type not in ("faces", "voices"):
-        raise HTTPException(status_code=400, detail="embedding_type must be 'faces' or 'voices'")
-
-    # Rutas objetivo
-    video_path = EMBEDDINGS_ROOT / video_hash
-    type_path = video_path / embedding_type
-
-    # Crear carpetas si no existen
-    type_path.mkdir(parents=True, exist_ok=True)
-
-    # Eliminar JSONs previos
-    for existing in type_path.glob("*.json"):
-        try:
-            existing.unlink()
-        except Exception as exc:
-            raise HTTPException(status_code=500, detail=f"Failed to delete old embeddings: {exc}")
-
-    # Guardar como embeddings.json
-    final_path = type_path / "embeddings.json"
-
-    try:
-        file_bytes = await file.read()
-        with open(final_path, "wb") as f:
-            f.write(file_bytes)
-    except Exception as exc:
-        raise HTTPException(status_code=500, detail=f"Failed to save embeddings: {exc}")
-
-    return JSONResponse(
-        status_code=200,
-        content={
-            "status": "ok",
-            "saved_to": str(final_path)
-        }
-    )
-
-def get_embeddings_json(video_hash: str, embedding_type: str):
-    """
-    Returns the parsed embeddings.json for a given video and type.
-
-    Behavior:
-    - Validate embedding_type.
-    - Build the file path: /data/embeddings/<video_hash>/<embedding_type>/embeddings.json
-    - Raise HTTPException if missing.
-    - Load and return parsed JSON.
-    """
-
-    if embedding_type not in ("faces", "voices"):
-        raise HTTPException(status_code=400, detail="embedding_type must be 'faces' or 'voices'")
-
-    target_file = EMBEDDINGS_ROOT / video_hash / embedding_type / "embeddings.json"
-
-    if not target_file.exists():
-        raise HTTPException(
-            status_code=404,
-            detail=f"embeddings.json not found for video={video_hash}, type={embedding_type}"
-        )
-
-    try:
-        with open(target_file, "r", encoding="utf-8") as f:
-            data = json.load(f)
-    except Exception as exc:
-        raise HTTPException(status_code=500, detail=f"Failed to read embeddings: {exc}")
-
-    return data
-
-
-@router.get("/get_embedding", tags=["Embeddings Manager"])
-def get_embeddings(
-    video_hash: str = Query(..., description="Hash of the video"),
-    embedding_type: str = Query(..., description="faces or voices"),
-    token: str = Query(..., description="Token required for authorization")
-):
-    """
-    Endpoint to retrieve embeddings.json for a given video hash and type.
-    """
-    validate_token(token)
-
-    data = get_embeddings_json(video_hash, embedding_type)
-
+import os
+import io
+import json
+import shutil
+
+import sqlite3
+
+from pathlib import Path
+
+from fastapi import APIRouter, UploadFile, File, Query, HTTPException
+from fastapi.responses import FileResponse, JSONResponse
+
+
+from storage.files.file_manager import FileManager
+from storage.common import validate_token
+
+router = APIRouter(prefix="/embeddings", tags=["Embeddings Manager"])
+EMBEDDINGS_ROOT = Path("/data/embeddings")
+file_manager = FileManager(EMBEDDINGS_ROOT)
+HF_TOKEN = os.getenv("HF_TOKEN")
+
+
+@router.get("/list_embeddings", tags=["Embeddings Manager"])
+def list_all_embeddings(
+    token: str = Query(..., description="Token required for authorization")
+):
+    """
+    List all embeddings stored under /data/embeddings.
+
+    For each video hash folder, returns:
+    - video: folder name (hash)
+    - faces: true/false depending on whether faces/embeddings.json exists
+    - voices: true/false depending on whether voices/embeddings.json exists
+
+    Notes:
+    - A video folder may contain only faces, only voices, or neither.
+    - Missing folders are treated as false.
+    """
+    validate_token(token)
+
+    results = []
+
+    # If embeddings root does not exist, return empty list
+    if not EMBEDDINGS_ROOT.exists():
+        return []
+
+    for video_dir in EMBEDDINGS_ROOT.iterdir():
+        if not video_dir.is_dir():
+            continue  # Skip anything that is not a folder
+
+        faces_path = video_dir / "faces" / "embeddings.json"
+        voices_path = video_dir / "voices" / "embeddings.json"
+
+        results.append({
+            "video": video_dir.name,
+            "faces": faces_path.exists(),
+            "voices": voices_path.exists()
+        })
+
+    return results
+
+
+@router.post("/upload_embeddings", tags=["Embeddings Manager"])
+async def upload_embeddings(
+    file: UploadFile = File(...),
+    embedding_type: str = Query(..., description="faces or voices"),
+    video_hash: str = Query(..., description="Hash of the video"),
+    token: str = Query(..., description="Token required for authorization")
+):
+    """
+    Upload embeddings JSON for a given video and type (faces or voices).
+
+    Behavior:
+    - Validate the token.
+    - Validate embedding_type.
+    - Ensure directory structure: /data/embeddings/<video_hash>/<embedding_type>/
+    - Delete any existing .json file inside that folder.
+    - Save the uploaded embeddings as embeddings.json.
+    """
+    validate_token(token)
+
+    # Validación del tipo
+    if embedding_type not in ("faces", "voices"):
+        raise HTTPException(status_code=400, detail="embedding_type must be 'faces' or 'voices'")
+
+    # Rutas objetivo
+    video_path = EMBEDDINGS_ROOT / video_hash
+    type_path = video_path / embedding_type
+
+    # Crear carpetas si no existen
+    type_path.mkdir(parents=True, exist_ok=True)
+
+    # Eliminar JSONs previos
+    for existing in type_path.glob("*.json"):
+        try:
+            existing.unlink()
+        except Exception as exc:
+            raise HTTPException(status_code=500, detail=f"Failed to delete old embeddings: {exc}")
+
+    # Guardar como embeddings.json
+    final_path = type_path / "embeddings.json"
+
+    try:
+        file_bytes = await file.read()
+        with open(final_path, "wb") as f:
+            f.write(file_bytes)
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"Failed to save embeddings: {exc}")
+
+    return JSONResponse(
+        status_code=200,
+        content={
+            "status": "ok",
+            "saved_to": str(final_path)
+        }
+    )
+
+def get_embeddings_json(video_hash: str, embedding_type: str):
+    """
+    Returns the parsed embeddings.json for a given video and type.
+
+    Behavior:
+    - Validate embedding_type.
+    - Build the file path: /data/embeddings/<video_hash>/<embedding_type>/embeddings.json
+    - Raise HTTPException if missing.
+    - Load and return parsed JSON.
+    """
+
+    if embedding_type not in ("faces", "voices"):
+        raise HTTPException(status_code=400, detail="embedding_type must be 'faces' or 'voices'")
+
+    target_file = EMBEDDINGS_ROOT / video_hash / embedding_type / "embeddings.json"
+
+    if not target_file.exists():
+        raise HTTPException(
+            status_code=404,
+            detail=f"embeddings.json not found for video={video_hash}, type={embedding_type}"
+        )
+
+    try:
+        with open(target_file, "r", encoding="utf-8") as f:
+            data = json.load(f)
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"Failed to read embeddings: {exc}")
+
+    return data
+
+
+@router.get("/get_embedding", tags=["Embeddings Manager"])
+def get_embeddings(
+    video_hash: str = Query(..., description="Hash of the video"),
+    embedding_type: str = Query(..., description="faces or voices"),
+    token: str = Query(..., description="Token required for authorization")
+):
+    """
+    Endpoint to retrieve embeddings.json for a given video hash and type.
+    """
+    validate_token(token)
+
+    data = get_embeddings_json(video_hash, embedding_type)
+
     return data

storage/media_routers.py

@@ -624,8 +624,8 @@ def list_all_audios(
     return results
 
 
-@router.post("/upload_audio_subtype", tags=["Media Manager"])
-async def upload_audio_subtype(
+@router.post("/upload_audio_version", tags=["Media Manager"])
+async def upload_audio_version(
     audio: UploadFile = File(...),
     sha1: str = Query(..., description="SHA1 of the video folder"),
     version: str = Query(..., description="Version: Salamandra or MoE"),
@@ -676,8 +676,8 @@ async def upload_audio_subtype(
     )
 
 
-@router.get("/download_audio_subtype", tags=["Media Manager"])
-def download_audio_subtype(
+@router.get("/download_audio_version", tags=["Media Manager"])
+def download_audio_version(
     sha1: str,
     version: str,
     token: str = Query(..., description="Token required for authorization")
@@ -794,8 +794,8 @@ def download_audio_ad(
     )
 
 
-@router.get("/list_subtype_audios", tags=["Media Manager"])
-def list_subtype_audios(
+@router.get("/list_version_audios", tags=["Media Manager"])
+def list_version_audios(
     sha1: str = Query(..., description="SHA1 of the video folder"),
     token: str = Query(..., description="Token required for authorization")
 ):
@@ -835,8 +835,8 @@ def list_subtype_audios(
     return results
 
 
-@router.post("/upload_subtype_video", tags=["Media Manager"])
-async def upload_subtype_video(
+@router.post("/upload_version_video", tags=["Media Manager"])
+async def upload_version_video(
     sha1: str = Query(..., description="SHA1 associated to the media folder"),
     version: str = Query(..., description="Version: Salamandra or MoE"),
     video: UploadFile = File(...),
@@ -882,8 +882,8 @@ async def upload_subtype_video(
     }
 
 
-@router.get("/download_subtype_video", tags=["Media Manager"])
-def download_subtype_video(
+@router.get("/download_version_video", tags=["Media Manager"])
+def download_version_video(
     sha1: str,
     version: str,
     token: str = Query(..., description="Token required for authorization")
@@ -924,8 +924,8 @@ def download_subtype_video(
     )
 
 
-@router.get("/list_subtype_videos", tags=["Media Manager"])
-def list_subtype_videos(
+@router.get("/list_version_videos", tags=["Media Manager"])
+def list_version_videos(
     sha1: str,
     token: str = Query(..., description="Token required for authorization")
 ):