206 lines
7.2 KiB
Python
206 lines
7.2 KiB
Python
"""Audio extraction 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.extraction import ExtractionInfo, ExtractionService
|
|
from app.services.extraction_processor import extraction_processor
|
|
|
|
router = APIRouter(prefix="/extractions", tags=["extractions"])
|
|
|
|
|
|
async def get_extraction_service(
|
|
session: Annotated[AsyncSession, Depends(get_db)],
|
|
) -> ExtractionService:
|
|
"""Get the extraction service."""
|
|
return ExtractionService(session)
|
|
|
|
|
|
@router.post("/")
|
|
async def create_extraction(
|
|
url: str,
|
|
current_user: Annotated[User, Depends(get_current_active_user_flexible)],
|
|
extraction_service: Annotated[ExtractionService, Depends(get_extraction_service)],
|
|
) -> dict[str, ExtractionInfo | str]:
|
|
"""Create a new extraction job for a URL."""
|
|
try:
|
|
if current_user.id is None:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_401_UNAUTHORIZED,
|
|
detail="User ID not available",
|
|
)
|
|
|
|
extraction_info = await extraction_service.create_extraction(
|
|
url,
|
|
current_user.id,
|
|
)
|
|
|
|
# Queue the extraction for background processing
|
|
await extraction_processor.queue_extraction(extraction_info["id"])
|
|
|
|
except ValueError as e:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_400_BAD_REQUEST,
|
|
detail=str(e),
|
|
) from e
|
|
except Exception as e:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
detail=f"Failed to create extraction: {e!s}",
|
|
) from e
|
|
else:
|
|
return {
|
|
"message": "Extraction queued successfully",
|
|
"extraction": extraction_info,
|
|
}
|
|
|
|
|
|
@router.get("/user")
|
|
async def get_user_extractions( # noqa: PLR0913
|
|
current_user: Annotated[User, Depends(get_current_active_user_flexible)],
|
|
extraction_service: Annotated[ExtractionService, Depends(get_extraction_service)],
|
|
search: Annotated[
|
|
str | None,
|
|
Query(description="Search in title, URL, or service"),
|
|
] = None,
|
|
sort_by: Annotated[str, Query(description="Sort by field")] = "created_at",
|
|
sort_order: Annotated[str, Query(description="Sort order (asc/desc)")] = "desc",
|
|
status_filter: Annotated[str | None, Query(description="Filter by status")] = None,
|
|
page: Annotated[int, Query(description="Page number", ge=1)] = 1,
|
|
limit: Annotated[int, Query(description="Items per page", ge=1, le=100)] = 50,
|
|
) -> dict:
|
|
"""Get all extractions for the current user."""
|
|
try:
|
|
if current_user.id is None:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_401_UNAUTHORIZED,
|
|
detail="User ID not available",
|
|
)
|
|
|
|
result = await extraction_service.get_user_extractions(
|
|
user_id=current_user.id,
|
|
search=search,
|
|
sort_by=sort_by,
|
|
sort_order=sort_order,
|
|
status_filter=status_filter,
|
|
page=page,
|
|
limit=limit,
|
|
)
|
|
|
|
except Exception as e:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
detail=f"Failed to get extractions: {e!s}",
|
|
) from e
|
|
else:
|
|
return result
|
|
|
|
|
|
@router.get("/{extraction_id}")
|
|
async def get_extraction(
|
|
extraction_id: int,
|
|
current_user: Annotated[User, Depends(get_current_active_user_flexible)], # noqa: ARG001
|
|
extraction_service: Annotated[ExtractionService, Depends(get_extraction_service)],
|
|
) -> ExtractionInfo:
|
|
"""Get extraction information by ID."""
|
|
try:
|
|
extraction_info = await extraction_service.get_extraction_by_id(extraction_id)
|
|
|
|
if not extraction_info:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_404_NOT_FOUND,
|
|
detail=f"Extraction {extraction_id} not found",
|
|
)
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
detail=f"Failed to get extraction: {e!s}",
|
|
) from e
|
|
else:
|
|
return extraction_info
|
|
|
|
|
|
@router.get("/")
|
|
async def get_all_extractions( # noqa: PLR0913
|
|
extraction_service: Annotated[ExtractionService, Depends(get_extraction_service)],
|
|
search: Annotated[
|
|
str | None,
|
|
Query(description="Search in title, URL, or service"),
|
|
] = None,
|
|
sort_by: Annotated[str, Query(description="Sort by field")] = "created_at",
|
|
sort_order: Annotated[str, Query(description="Sort order (asc/desc)")] = "desc",
|
|
status_filter: Annotated[str | None, Query(description="Filter by status")] = None,
|
|
page: Annotated[int, Query(description="Page number", ge=1)] = 1,
|
|
limit: Annotated[int, Query(description="Items per page", ge=1, le=100)] = 50,
|
|
) -> dict:
|
|
"""Get all extractions with optional filtering, search, and sorting."""
|
|
try:
|
|
result = await extraction_service.get_all_extractions(
|
|
search=search,
|
|
sort_by=sort_by,
|
|
sort_order=sort_order,
|
|
status_filter=status_filter,
|
|
page=page,
|
|
limit=limit,
|
|
)
|
|
|
|
except Exception as e:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
detail=f"Failed to get extractions: {e!s}",
|
|
) from e
|
|
else:
|
|
return result
|
|
|
|
|
|
@router.get("/processing/current")
|
|
async def get_processing_extractions(
|
|
current_user: Annotated[User, Depends(get_current_active_user_flexible)], # noqa: ARG001
|
|
extraction_service: Annotated[ExtractionService, Depends(get_extraction_service)],
|
|
) -> list[ExtractionInfo]:
|
|
"""Get all currently processing extractions for showing ongoing toasts."""
|
|
try:
|
|
# Get all extractions with processing status
|
|
processing_extractions = await extraction_service.extraction_repo.get_by_status(
|
|
"processing"
|
|
)
|
|
|
|
# Convert to ExtractionInfo format
|
|
result = []
|
|
for extraction in processing_extractions:
|
|
# Get user information
|
|
user = await extraction_service.user_repo.get_by_id(extraction.user_id)
|
|
user_name = user.name if user else None
|
|
|
|
extraction_info: ExtractionInfo = {
|
|
"id": extraction.id or 0,
|
|
"url": extraction.url,
|
|
"service": extraction.service,
|
|
"service_id": extraction.service_id,
|
|
"title": extraction.title,
|
|
"status": extraction.status,
|
|
"error": extraction.error,
|
|
"sound_id": extraction.sound_id,
|
|
"user_id": extraction.user_id,
|
|
"user_name": user_name,
|
|
"created_at": extraction.created_at.isoformat(),
|
|
"updated_at": extraction.updated_at.isoformat(),
|
|
}
|
|
result.append(extraction_info)
|
|
|
|
return result
|
|
|
|
except Exception as e:
|
|
raise HTTPException(
|
|
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
|
detail=f"Failed to get processing extractions: {e!s}",
|
|
) from e
|