feat: Implement sound normalization service and API endpoints

- Added SoundNormalizerService for normalizing audio files with support for one-pass and two-pass normalization methods.
- Introduced API endpoints for normalizing all sounds and specific sounds by ID, including support for force normalization and handling of already normalized sounds.
- Created comprehensive test suite for the sound normalizer service and its API endpoints, covering various scenarios including success, errors, and edge cases.
- Refactored sound scanning service to utilize SHA-256 for file hashing instead of MD5 for improved security.
- Enhanced logging and error handling throughout the sound normalization process.
This commit is contained in:
JSC
2025-07-28 09:18:18 +02:00
parent 36949a1f1c
commit 0fffce53b4
8 changed files with 2031 additions and 75 deletions

View File

@@ -0,0 +1,166 @@
"""Sound normalization API endpoints."""
from typing import Annotated
from fastapi import APIRouter, Depends, HTTPException, Query, status
from sqlmodel.ext.asyncio.session import AsyncSession
from app.core.database import get_db
from app.core.dependencies import get_current_active_user_flexible
from app.models.user import User
from app.services.sound_normalizer import NormalizationResults, SoundNormalizerService
router = APIRouter(prefix="/sounds/normalize", tags=["sound-normalization"])
async def get_sound_normalizer_service(
session: Annotated[AsyncSession, Depends(get_db)],
) -> SoundNormalizerService:
"""Get the sound normalizer service."""
return SoundNormalizerService(session)
@router.post("/all")
async def normalize_all_sounds(
current_user: Annotated[User, Depends(get_current_active_user_flexible)],
normalizer_service: Annotated[
SoundNormalizerService, Depends(get_sound_normalizer_service)
],
force: bool = Query(
False, description="Force normalization of already normalized sounds"
),
one_pass: bool | None = Query(
None, description="Use one-pass normalization (overrides config)"
),
) -> dict[str, NormalizationResults | str]:
"""Normalize all unnormalized sounds."""
# Only allow admins to normalize sounds
if current_user.role not in ["admin", "superadmin"]:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="Only administrators can normalize sounds",
)
try:
results = await normalizer_service.normalize_all_sounds(
force=force,
one_pass=one_pass,
)
return {
"message": "Sound normalization completed",
"results": results,
}
except Exception as e:
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
detail=f"Failed to normalize sounds: {e!s}",
) from e
@router.post("/type/{sound_type}")
async def normalize_sounds_by_type(
sound_type: str,
current_user: Annotated[User, Depends(get_current_active_user_flexible)],
normalizer_service: Annotated[
SoundNormalizerService, Depends(get_sound_normalizer_service)
],
force: bool = Query(
False, description="Force normalization of already normalized sounds"
),
one_pass: bool | None = Query(
None, description="Use one-pass normalization (overrides config)"
),
) -> dict[str, NormalizationResults | str]:
"""Normalize all sounds of a specific type (SDB, TTS, EXT)."""
# Only allow admins to normalize sounds
if current_user.role not in ["admin", "superadmin"]:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="Only administrators can normalize sounds",
)
# Validate sound type
valid_types = ["SDB", "TTS", "EXT"]
if sound_type not in valid_types:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail=f"Invalid sound type. Must be one of: {', '.join(valid_types)}",
)
try:
results = await normalizer_service.normalize_sounds_by_type(
sound_type=sound_type,
force=force,
one_pass=one_pass,
)
return {
"message": f"Normalization of {sound_type} sounds completed",
"results": results,
}
except Exception as e:
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
detail=f"Failed to normalize {sound_type} sounds: {e!s}",
) from e
@router.post("/{sound_id}")
async def normalize_sound_by_id(
sound_id: int,
current_user: Annotated[User, Depends(get_current_active_user_flexible)],
normalizer_service: Annotated[
SoundNormalizerService, Depends(get_sound_normalizer_service)
],
force: bool = Query(
False, description="Force normalization of already normalized sound"
),
one_pass: bool | None = Query(
None, description="Use one-pass normalization (overrides config)"
),
) -> dict[str, str]:
"""Normalize a specific sound by ID."""
# Only allow admins to normalize sounds
if current_user.role not in ["admin", "superadmin"]:
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="Only administrators can normalize sounds",
)
try:
# Get the sound
sound = await normalizer_service.sound_repo.get_by_id(sound_id)
if not sound:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"Sound with ID {sound_id} not found",
)
# Normalize the sound
result = await normalizer_service.normalize_sound(
sound=sound,
force=force,
one_pass=one_pass,
)
# Check result status
if result["status"] == "error":
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
detail=f"Failed to normalize sound: {result['error']}",
)
return {
"message": f"Sound normalization {result['status']}: {sound.filename}",
"status": result["status"],
"reason": result["reason"] or "",
"normalized_filename": result["normalized_filename"] or "",
}
except HTTPException:
# Re-raise HTTPExceptions without wrapping them
raise
except Exception as e:
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
detail=f"Failed to normalize sound: {e!s}",
) from e