Update storage/media_routers.py

storage/media_routers.py

@@ -139,17 +139,16 @@ def download_cast_csv(
 async def upload_video(
     video: UploadFile = File(...),
     token: str = Query(..., description="Token required for authorization")
-    ):
+):
     """
     Saves an uploaded video by hashing it with SHA1 and placing it under:
     /data/media/<sha1>/clip/<original_filename>
 
-    Steps:
+    Behavior:
     - Compute SHA1 of the uploaded video.
-    - Ensure /data/media exists.
-    - Create folder /data/media/<sha1> if missing.
-    - Create folder /data/media/<sha1>/clip if missing.
-    - Save the video inside /data/media/<sha1>/clip/.
+    - Ensure folder structure exists.
+    - Delete any existing .mp4 files under /clip.
+    - Save the uploaded video in the clip folder.
     """
     MEDIA_ROOT = Path("/data/media")
     file_manager = FileManager(MEDIA_ROOT)
@@ -159,10 +158,10 @@ async def upload_video(
     # Read content into memory (needed to compute hash twice)
     file_bytes = await video.read()
 
-    # Create an in-memory file handler
+    # Create an in-memory file handler for hashing
     file_handler = io.BytesIO(file_bytes)
 
-    # Compute SHA1 using your FileManager method
+    # Compute SHA1
     try:
         sha1 = file_manager.compute_sha1(file_handler)
     except Exception as exc:
@@ -179,10 +178,17 @@ async def upload_video(
     clip_dir = video_root / "clip"
     clip_dir.mkdir(parents=True, exist_ok=True)
 
-    # Final file path
+    # Delete old MP4 files
+    try:
+        for old_mp4 in clip_dir.glob("*.mp4"):
+            old_mp4.unlink()
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"Failed to delete old videos: {exc}")
+
+    # Save new video path
     final_path = clip_dir / video.filename
 
-    # Save file using your FileManager.upload_file
+    # Save file
     save_result = file_manager.upload_file(io.BytesIO(file_bytes), final_path)
 
     if not save_result["operation_success"]:
@@ -322,3 +328,212 @@ def list_all_videos(
         })
 
     return results
+
+@router.post("/upload_original_audio", tags=["Media Manager"])
+async def upload_audio(
+    audio: UploadFile = File(...),
+    token: str = Query(..., description="Token required for authorization")
+):
+    """
+    Saves an uploaded audio file by hashing it with SHA1 and placing it under:
+    /data/media/<sha1>/audio/<original_filename>
+
+    Behavior:
+    - Compute SHA1 of the uploaded audio.
+    - Ensure folder structure exists.
+    - Delete any existing audio files under /audio.
+    - Save the uploaded audio in the audio folder.
+    """
+    MEDIA_ROOT = Path("/data/media")
+    file_manager = FileManager(MEDIA_ROOT)
+    HF_TOKEN = os.getenv("HF_TOKEN")
+    validate_token(token)
+
+    # Read content into memory (needed to compute hash twice)
+    file_bytes = await audio.read()
+
+    # Create an in-memory file handler for hashing
+    file_handler = io.BytesIO(file_bytes)
+
+    # Compute SHA1
+    try:
+        sha1 = file_manager.compute_sha1(file_handler)
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"SHA1 computation failed: {exc}")
+
+    # Ensure /data/media exists
+    MEDIA_ROOT.mkdir(parents=True, exist_ok=True)
+
+    # Path: /data/media/<sha1>
+    audio_root = MEDIA_ROOT / sha1
+    audio_root.mkdir(parents=True, exist_ok=True)
+
+    # Path: /data/media/<sha1>/audio
+    audio_dir = audio_root / "audio"
+    audio_dir.mkdir(parents=True, exist_ok=True)
+
+    # Delete old audio files
+    AUDIO_EXTENSIONS = ("*.mp3", "*.wav", "*.m4a", "*.aac", "*.ogg", "*.flac")
+    try:
+        for pattern in AUDIO_EXTENSIONS:
+            for old_audio in audio_dir.glob(pattern):
+                old_audio.unlink()
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"Failed to delete old audio files: {exc}")
+
+    # Final save path
+    final_path = audio_dir / audio.filename
+
+    # Save file
+    save_result = file_manager.upload_file(io.BytesIO(file_bytes), final_path)
+
+    if not save_result["operation_success"]:
+        raise HTTPException(status_code=500, detail=save_result["error"])
+
+    return JSONResponse(
+        status_code=200,
+        content={
+            "status": "ok",
+            "sha1": sha1,
+            "saved_to": str(final_path)
+        }
+    )
+
+@router.get("/download_original_audio", tags=["Media Manager"])
+def download_audio(
+    sha1: str,
+    token: str = Query(..., description="Token required for authorization")
+    ):
+    """
+    Download a stored audio file by its SHA-1 directory name.
+
+    This endpoint looks for audio stored under the path:
+        /data/media/<sha1>/audio/
+    and returns the first audio file found in that folder.
+
+    The method performs the following steps:
+    - Checks if the SHA-1 folder exists inside the media root.
+    - Validates that the "audio" subfolder exists.
+    - Searches for the first supported audio file.
+    - Uses FileManager.get_file to ensure the file is accessible.
+    - Returns the audio file as a FileResponse.
+
+    Parameters
+    ----------
+    sha1 : str
+        The SHA-1 hash corresponding to the directory where the audio is stored.
+
+    Returns
+    -------
+    FileResponse
+        A streaming response containing the audio file.
+
+    Raises
+    ------
+    HTTPException
+        - 404 if the SHA-1 folder does not exist.
+        - 404 if the audio folder is missing.
+        - 404 if no audio files are found.
+        - 404 if the file cannot be retrieved using FileManager.
+    """
+    MEDIA_ROOT = Path("/data/media")
+    file_manager = FileManager(MEDIA_ROOT)
+    HF_TOKEN = os.getenv("HF_TOKEN")
+    validate_token(token)
+
+    sha1_folder = MEDIA_ROOT / sha1
+    audio_folder = sha1_folder / "audio"
+
+    if not sha1_folder.exists() or not sha1_folder.is_dir():
+        raise HTTPException(status_code=404, detail="SHA1 folder not found")
+
+    if not audio_folder.exists() or not audio_folder.is_dir():
+        raise HTTPException(status_code=404, detail="Audio folder not found")
+
+    # Supported audio extensions
+    AUDIO_EXTENSIONS = ["*.mp3", "*.wav", "*.aac", "*.m4a", "*.ogg", "*.flac"]
+
+    audio_files = []
+    for pattern in AUDIO_EXTENSIONS:
+        audio_files.extend(list(audio_folder.glob(pattern)))
+
+    if not audio_files:
+        raise HTTPException(status_code=404, detail="No audio files found")
+
+    audio_path = audio_files[0]
+
+    # Convert to relative path for FileManager
+    relative_path = audio_path.relative_to(MEDIA_ROOT)
+
+    handler = file_manager.get_file(relative_path)
+    if handler is None:
+        raise HTTPException(status_code=404, detail="Audio file not accessible")
+
+    handler.close()
+
+    # Guess media type based on extension (simple)
+    media_type = "audio/" + audio_path.suffix.lstrip(".")
+
+    return FileResponse(
+        path=audio_path,
+        media_type=media_type,
+        filename=audio_path.name
+    )
+
+@router.get("/list_original_audios", tags=["Media Manager"])
+def list_all_audios(
+    token: str = Query(..., description="Token required for authorization")
+):
+    """
+    List all audio files stored under /data/media.
+
+    For each SHA1 folder, the endpoint returns:
+    - sha1: folder name
+    - audio_files: list of audio files inside /audio
+    - latest_audio: the most recently modified audio file
+    - audio_count: total number of audio files
+
+    Notes:
+    - Folders may not have an /audio folder.
+    - SHA1 folders without audio files are still returned.
+    """
+    validate_token(token)
+
+    results = []
+
+    MEDIA_ROOT = Path("/data/media")
+    AUDIO_EXTENSIONS = ["*.mp3", "*.wav", "*.aac", "*.m4a", "*.ogg", "*.flac"]
+
+    # If media root does not exist, return empty list
+    if not MEDIA_ROOT.exists():
+        return []
+
+    for sha1_dir in MEDIA_ROOT.iterdir():
+        if not sha1_dir.is_dir():
+            continue  # skip non-folders
+
+        audio_dir = sha1_dir / "audio"
+
+        audio_files = []
+        latest_audio = None
+
+        if audio_dir.exists() and audio_dir.is_dir():
+            # Collect all audio files with supported extensions
+            files = []
+            for pattern in AUDIO_EXTENSIONS:
+                files.extend(list(audio_dir.glob(pattern)))
+
+            # Sort by modification time (newest first)
+            files.sort(key=lambda f: f.stat().st_mtime, reverse=True)
+
+            audio_files = [f.name for f in files]
+
+            if files:
+                latest_audio = files[0].name
+
+        results.append({
+            "sha1": sha1_dir.name,
+            "audio_name": latest_audio,
+        })
+
+    return results