karaoke-gen 0.101.0__py3-none-any.whl → 0.103.1__py3-none-any.whl

backend/services/job_defaults_service.py

@@ -0,0 +1,113 @@
+"""
+Centralized job defaults service.
+
+This module provides consistent handling of job creation defaults across all
+endpoints (file_upload, audio_search, made-for-you webhook, etc.).
+
+Centralizing these defaults prevents divergence between code paths and ensures
+all jobs receive the same default configuration.
+"""
+from dataclasses import dataclass
+from typing import Optional, Tuple
+
+from backend.config import get_settings
+
+
+@dataclass
+class EffectiveDistributionSettings:
+    """Distribution settings with defaults applied from environment variables."""
+    dropbox_path: Optional[str]
+    gdrive_folder_id: Optional[str]
+    discord_webhook_url: Optional[str]
+    brand_prefix: Optional[str]
+    enable_youtube_upload: bool
+    youtube_description: Optional[str]
+
+
+def get_effective_distribution_settings(
+    dropbox_path: Optional[str] = None,
+    gdrive_folder_id: Optional[str] = None,
+    discord_webhook_url: Optional[str] = None,
+    brand_prefix: Optional[str] = None,
+    enable_youtube_upload: Optional[bool] = None,
+    youtube_description: Optional[str] = None,
+) -> EffectiveDistributionSettings:
+    """
+    Get distribution settings with defaults applied from environment variables.
+
+    This ensures consistent handling of defaults across all job creation endpoints.
+    Each parameter, if not provided (None), falls back to the corresponding
+    environment variable configured in settings.
+
+    Args:
+        dropbox_path: Explicit Dropbox path or None for default
+        gdrive_folder_id: Explicit Google Drive folder ID or None for default
+        discord_webhook_url: Explicit Discord webhook URL or None for default
+        brand_prefix: Explicit brand prefix or None for default
+        enable_youtube_upload: Explicit flag or None for default
+        youtube_description: Explicit description or None for default
+
+    Returns:
+        EffectiveDistributionSettings with defaults applied
+    """
+    settings = get_settings()
+    return EffectiveDistributionSettings(
+        dropbox_path=dropbox_path or settings.default_dropbox_path,
+        gdrive_folder_id=gdrive_folder_id or settings.default_gdrive_folder_id,
+        discord_webhook_url=discord_webhook_url or settings.default_discord_webhook_url,
+        brand_prefix=brand_prefix or settings.default_brand_prefix,
+        enable_youtube_upload=enable_youtube_upload if enable_youtube_upload is not None else settings.default_enable_youtube_upload,
+        youtube_description=youtube_description or settings.default_youtube_description,
+    )
+
+
+def resolve_cdg_txt_defaults(
+    theme_id: Optional[str],
+    enable_cdg: Optional[bool] = None,
+    enable_txt: Optional[bool] = None,
+) -> Tuple[bool, bool]:
+    """
+    Resolve CDG/TXT settings based on theme and explicit settings.
+
+    The resolution logic is:
+    1. If explicit True/False is provided, use that value
+    2. Otherwise, if a theme is set, use the server defaults (settings.default_enable_cdg/txt)
+    3. If no theme is set, default to False (CDG/TXT require style configuration)
+
+    This ensures CDG/TXT are only enabled when:
+    - A theme is configured (provides necessary style params), AND
+    - The server defaults allow it (DEFAULT_ENABLE_CDG=true by default)
+
+    Args:
+        theme_id: Theme identifier (if any)
+        enable_cdg: Explicit CDG setting (None means use default)
+        enable_txt: Explicit TXT setting (None means use default)
+
+    Returns:
+        Tuple of (resolved_enable_cdg, resolved_enable_txt)
+    """
+    settings = get_settings()
+
+    # Default based on whether theme is set AND server defaults
+    # Theme is required because CDG/TXT need style configuration
+    theme_is_set = theme_id is not None
+    default_cdg = theme_is_set and settings.default_enable_cdg
+    default_txt = theme_is_set and settings.default_enable_txt
+
+    # Explicit values override defaults, None uses computed default
+    resolved_cdg = enable_cdg if enable_cdg is not None else default_cdg
+    resolved_txt = enable_txt if enable_txt is not None else default_txt
+
+    return resolved_cdg, resolved_txt
+
+
+# Singleton instance (optional, for convenience)
+_service_instance = None
+
+
+def get_job_defaults_service():
+    """Get the job defaults service (module-level functions work fine, this is for consistency)."""
+    return {
+        'get_effective_distribution_settings': get_effective_distribution_settings,
+        'resolve_cdg_txt_defaults': resolve_cdg_txt_defaults,
+    }

backend/services/job_manager.py

@@ -14,6 +14,7 @@ from datetime import datetime
 from typing import Optional, Dict, Any, List
 
 from backend.config import settings
+from backend.exceptions import RateLimitExceededError
 from backend.models.job import Job, JobStatus, JobCreate, STATE_TRANSITIONS
 from backend.models.worker_log import WorkerLogEntry
 from backend.services.firestore_service import FirestoreService
@@ -41,16 +42,44 @@ class JobManager:
         self.firestore = FirestoreService()
         self.storage = StorageService()
     
-    def create_job(self, job_create: JobCreate) -> Job:
+    def create_job(self, job_create: JobCreate, is_admin: bool = False) -> Job:
         """
         Create a new job with initial state PENDING.
 
         Jobs start in PENDING state and transition to DOWNLOADING
         when a worker picks them up.
 
+        Args:
+            job_create: Job creation parameters
+            is_admin: Whether the requesting user is an admin (bypasses rate limits)
+
         Raises:
             ValueError: If theme_id is not provided (all jobs require a theme)
+            RateLimitExceededError: If user has exceeded their daily job limit
         """
+        # Check rate limit FIRST (before any other validation)
+        # This prevents wasted work if user is rate limited
+        if job_create.user_email:
+            from backend.services.rate_limit_service import get_rate_limit_service
+
+            rate_limit_service = get_rate_limit_service()
+            allowed, remaining, message = rate_limit_service.check_user_job_limit(
+                user_email=job_create.user_email,
+                is_admin=is_admin
+            )
+            if not allowed:
+                from backend.services.rate_limit_service import _seconds_until_midnight_utc
+
+                # Get actual current count - remaining is clamped to 0 which loses info
+                current_count = rate_limit_service.get_user_job_count_today(job_create.user_email)
+                raise RateLimitExceededError(
+                    message=message,
+                    limit_type="jobs_per_day",
+                    remaining_seconds=_seconds_until_midnight_utc(),
+                    current_count=current_count,
+                    limit_value=settings.rate_limit_jobs_per_day
+                )
+
         # Enforce theme requirement - all jobs must have a theme
         # This prevents unstyled videos from ever being generated
         if not job_create.theme_id:
@@ -105,7 +134,17 @@ class JobManager:
         
         self.firestore.create_job(job)
         logger.info(f"Created new job {job_id} with status PENDING")
-        
+
+        # Record job creation for rate limiting (after successful persistence)
+        if job_create.user_email:
+            try:
+                from backend.services.rate_limit_service import get_rate_limit_service
+                rate_limit_service = get_rate_limit_service()
+                rate_limit_service.record_job_creation(job_create.user_email, job_id)
+            except Exception as e:
+                # Don't fail job creation if rate limit recording fails
+                logger.warning(f"Failed to record job creation for rate limiting: {e}")
+
         return job
     
     def get_job(self, job_id: str) -> Optional[Job]: