Download behavior_backend/app/api/routes/processing.py from urjob/test: direct link, hf CLI and curl.
- Browser
- Download file 8.68 kB
-
https://huggingface.co/spaces/urjob/test/resolve/main/behavior_backend/app/api/routes/processing.py
- Command line
-
hf download hf://spaces/urjob/test/behavior_backend/app/api/routes/processing.py
-
curl -L -o processing.py https://huggingface.co/spaces/urjob/test/resolve/main/behavior_backend/app/api/routes/processing.py
8.68 kB
| from fastapi import APIRouter, Depends, BackgroundTasks | |
| from sqlalchemy.orm import Session | |
| from app.db.base import get_db | |
| from app.models.processing import ProcessingRequest, ProcessingStatus | |
| from app.services.processing.processing_service import ProcessingService | |
| from app.utils.logging_utils import setup_logger, log_success | |
| from app.utils.auth import get_current_active_user, get_api_key_user | |
| from app.db.models import User | |
| """ | |
| Video Processing API Routes | |
| ========================== | |
| This module provides API endpoints for video processing operations, including: | |
| - Initiating video processing | |
| - Checking processing status | |
| - Retrieving processing results | |
| All endpoints are prefixed with '/processing' and include appropriate logging | |
| with endpoint identification in square brackets. | |
| """ | |
| # Setup logger for this module | |
| logger = setup_logger("processing_router") | |
| router = APIRouter( | |
| prefix="/processing", | |
| tags=["processing"], | |
| responses={404: {"description": "Not found"}}, | |
| ) | |
| async def process_video( | |
| request: ProcessingRequest, | |
| background_tasks: BackgroundTasks, | |
| db: Session = Depends(get_db), | |
| current_user: User = Depends(get_current_active_user) | |
| ): | |
| """ | |
| Initiate processing of a video. | |
| This endpoint accepts a video ID and initiates the processing pipeline | |
| as a background task. It returns a processing status object with the | |
| video ID that can be used to check the status later. | |
| Args: | |
| request (ProcessingRequest): Request object containing the video ID and processing options | |
| background_tasks (BackgroundTasks): FastAPI background tasks manager | |
| db (Session): Database session dependency | |
| current_user (User): Current active user dependency | |
| Returns: | |
| ProcessingStatus: Object containing the video ID and initial processing status | |
| Example: | |
| POST /processing | |
| { | |
| "video_id": "vid-12345", | |
| "frame_rate": 5, | |
| "language": "en", | |
| "generate_annotated_video": true | |
| } | |
| """ | |
| logger.info(f"[process_video] Received request to process video: {request.video_id}") | |
| processing_service = ProcessingService(db) | |
| result = await processing_service.process_video(request, background_tasks) | |
| logger.info(f" : {result.video_id}") | |
| return result | |
| async def get_processing_status( | |
| video_id: str, | |
| db: Session = Depends(get_db), | |
| current_user: User = Depends(get_current_active_user) | |
| ): | |
| """ | |
| Get the current processing status of a video. | |
| This endpoint retrieves the current status of a video processing job | |
| using the video ID returned from the process_video endpoint. | |
| Args: | |
| video_id (str): Unique identifier for the video processing job | |
| db (Session): Database session dependency | |
| current_user (User): Current active user dependency | |
| Returns: | |
| ProcessingStatus: Object containing the video ID and current processing status | |
| Example: | |
| GET /processing/status/vid-12345 | |
| """ | |
| logger.info(f"[get_processing_status] Checking status for video ID: {video_id}") | |
| processing_service = ProcessingService(db) | |
| status = processing_service.get_processing_status(video_id) | |
| logger.info(f"[get_processing_status] Status for video ID {video_id}: {status.status}") | |
| return status | |
| async def get_processing_results( | |
| video_id: str, | |
| db: Session = Depends(get_db), | |
| current_user: User = Depends(get_current_active_user) | |
| ): | |
| """ | |
| Get the results of a completed video processing job. | |
| This endpoint retrieves the full results of a video processing job | |
| after it has completed. It should only be called after the status | |
| endpoint indicates that processing is complete. | |
| Args: | |
| video_id (str): Unique identifier for the video processing job | |
| db (Session): Database session dependency | |
| current_user (User): Current active user dependency | |
| Returns: | |
| dict: Processing results including behavior analytics data | |
| Example: | |
| GET /processing/results/vid-12345 | |
| """ | |
| logger.info(f"[get_processing_results] Retrieving results for video ID: {video_id}") | |
| processing_service = ProcessingService(db) | |
| results = processing_service.get_processing_results(video_id) | |
| log_success(logger, f"[get_processing_results] Successfully retrieved results for video ID: {video_id}") | |
| return results | |
| async def process_video_direct( | |
| request: ProcessingRequest, | |
| background_tasks: BackgroundTasks, | |
| db: Session = Depends(get_db), | |
| api_key_valid: bool = Depends(get_api_key_user) | |
| ): | |
| """ | |
| Initiate processing of a video using API key authentication. | |
| This endpoint accepts a video ID and initiates the processing pipeline | |
| as a background task. It is secured with API key authentication. | |
| Args: | |
| request (ProcessingRequest): Request object containing the video ID and processing options | |
| background_tasks (BackgroundTasks): FastAPI background tasks manager | |
| db (Session): Database session dependency | |
| api_key_valid (bool): API key validation dependency | |
| Returns: | |
| ProcessingStatus: Object containing the video ID and initial processing status | |
| Example: | |
| POST /processing/direct | |
| X-API-Key: your-api-key | |
| { | |
| "video_id": "vid-12345", | |
| "frame_rate": 5, | |
| "language": "en", | |
| "generate_annotated_video": true | |
| } | |
| """ | |
| logger.info(f"[process_video_direct] Received request to process video: {request.video_id}") | |
| processing_service = ProcessingService(db) | |
| result = await processing_service.process_video(request, background_tasks) | |
| logger.info(f"[process_video_direct] Started processing for video ID: {result.video_id}") | |
| return result | |
| async def get_processing_status_direct( | |
| video_id: str, | |
| db: Session = Depends(get_db), | |
| api_key_valid: bool = Depends(get_api_key_user) | |
| ): | |
| """ | |
| Get the current processing status of a video using API key authentication. | |
| This endpoint retrieves the current status of a video processing job. | |
| It is secured with API key authentication. | |
| Args: | |
| video_id (str): Unique identifier for the video processing job | |
| db (Session): Database session dependency | |
| api_key_valid (bool): API key validation dependency | |
| Returns: | |
| ProcessingStatus: Object containing the video ID and current processing status | |
| Example: | |
| GET /processing/direct/status/vid-12345 | |
| X-API-Key: your-api-key | |
| """ | |
| logger.info(f"[get_processing_status_direct] Checking status for video ID: {video_id}") | |
| processing_service = ProcessingService(db) | |
| try: | |
| status = processing_service.get_processing_status(video_id) | |
| logger.info(f"[get_processing_status_direct] Status for video ID {video_id}: {status.status}, Progress: {status.progress}") | |
| return status | |
| except Exception as e: | |
| logger.error(f"[get_processing_status_direct] Error getting status: {str(e)}") | |
| raise | |
| async def get_processing_results_direct( | |
| video_id: str, | |
| db: Session = Depends(get_db), | |
| api_key_valid: bool = Depends(get_api_key_user) | |
| ): | |
| """ | |
| Get the results of a completed video processing job using API key authentication. | |
| This endpoint retrieves the full results of a video processing job | |
| after it has completed. It is secured with API key authentication. | |
| Args: | |
| video_id (str): Unique identifier for the video processing job | |
| db (Session): Database session dependency | |
| api_key_valid (bool): API key validation dependency | |
| Returns: | |
| dict: Processing results including behavior analytics data | |
| Example: | |
| GET /processing/direct/results/vid-12345 | |
| X-API-Key: your-api-key | |
| """ | |
| logger.info(f"[get_processing_results_direct] Retrieving results for video ID: {video_id}") | |
| processing_service = ProcessingService(db) | |
| results = processing_service.get_processing_results(video_id) | |
| log_success(logger, f"[get_processing_results_direct] Successfully retrieved results for video ID: {video_id}") | |
| return results |