karaoke-gen 0.96.0__py3-none-any.whl → 0.99.3__py3-none-any.whl

backend/api/routes/admin.py

@@ -20,6 +20,7 @@ from backend.services.user_service import get_user_service, UserService, USERS_C
 from backend.services.job_manager import JobManager
 from backend.services.flacfetch_client import get_flacfetch_client, FlacfetchServiceError
 from backend.models.job import JobStatus
+from backend.utils.test_data import is_test_email
 from karaoke_gen.utils import sanitize_filename
 
 
@@ -61,12 +62,17 @@ class AdminStatsOverview(BaseModel):
 
 @router.get("/stats/overview", response_model=AdminStatsOverview)
 async def get_admin_stats_overview(
+    exclude_test: bool = True,
     auth_data: Tuple[str, UserType, int] = Depends(require_admin),
     user_service: UserService = Depends(get_user_service),
 ):
     """
     Get overview statistics for admin dashboard.
 
+    Args:
+        exclude_test: If True (default), exclude test data (users with @inbox.testmail.app emails
+                     and jobs created by test users) from all counts.
+
     Includes:
     - User counts (total, active in 7d, active in 30d)
     - Job counts (total, by status, recent)
@@ -81,48 +87,10 @@ async def get_admin_stats_overview(
     seven_days_ago = now - timedelta(days=7)
     thirty_days_ago = now - timedelta(days=30)
 
-    # Helper function to get count using aggregation
-    def get_count(query) -> int:
-        try:
-            agg_query = aggregation.AggregationQuery(query)
-            agg_query.count(alias="count")
-            results = agg_query.get()
-            return results[0][0].value if results else 0
-        except Exception as e:
-            logger.warning(f"Aggregation query failed: {e}")
-            return 0
-
-    # User statistics
     users_collection = db.collection(USERS_COLLECTION)
-
-    total_users = get_count(users_collection)
-
-    active_users_7d = get_count(
-        users_collection.where(filter=FieldFilter("last_login_at", ">=", seven_days_ago))
-    )
-
-    active_users_30d = get_count(
-        users_collection.where(filter=FieldFilter("last_login_at", ">=", thirty_days_ago))
-    )
-
-    total_beta_testers = get_count(
-        users_collection.where(filter=FieldFilter("is_beta_tester", "==", True))
-    )
-
-    # Job statistics
     jobs_collection = db.collection("jobs")
 
-    total_jobs = get_count(jobs_collection)
-
-    jobs_last_7d = get_count(
-        jobs_collection.where(filter=FieldFilter("created_at", ">=", seven_days_ago))
-    )
-
-    jobs_last_30d = get_count(
-        jobs_collection.where(filter=FieldFilter("created_at", ">=", thirty_days_ago))
-    )
-
-    # Jobs by status - map multiple statuses to simplified categories
+    # Jobs by status category mapping
     processing_statuses = [
         "downloading", "downloading_audio", "searching_audio", "awaiting_audio_selection",
         "separating_stage1", "separating_stage2", "transcribing", "correcting",
@@ -131,63 +99,166 @@ async def get_admin_stats_overview(
         "uploading", "notifying"
     ]
 
-    jobs_by_status = JobsByStatusResponse(
-        pending=get_count(
-            jobs_collection.where(filter=FieldFilter("status", "==", "pending"))
-        ),
-        processing=sum(
-            get_count(jobs_collection.where(filter=FieldFilter("status", "==", status)))
-            for status in processing_statuses
-        ),
-        awaiting_review=get_count(
-            jobs_collection.where(filter=FieldFilter("status", "==", "awaiting_review"))
-        ) + get_count(
-            jobs_collection.where(filter=FieldFilter("status", "==", "in_review"))
-        ),
-        awaiting_instrumental=get_count(
-            jobs_collection.where(filter=FieldFilter("status", "==", "awaiting_instrumental_selection"))
-        ),
-        complete=get_count(
-            jobs_collection.where(filter=FieldFilter("status", "==", "complete"))
-        ) + get_count(
-            jobs_collection.where(filter=FieldFilter("status", "==", "prep_complete"))
-        ),
-        failed=get_count(
-            jobs_collection.where(filter=FieldFilter("status", "==", "failed"))
-        ),
-        cancelled=get_count(
-            jobs_collection.where(filter=FieldFilter("status", "==", "cancelled"))
-        ),
-    )
+    # Limits for streaming queries - these are safety limits to prevent memory issues
+    # If hit, stats may be incomplete so we log a warning
+    USERS_STREAM_LIMIT = 2000
+    JOBS_STREAM_LIMIT = 10000
+
+    if exclude_test:
+        # When excluding test data, we must stream and filter in Python
+        # because Firestore doesn't support "not ends with" queries
+
+        # Stream all users and filter
+        all_users = []
+        users_fetched = 0
+        for doc in users_collection.limit(USERS_STREAM_LIMIT).stream():
+            users_fetched += 1
+            user_data = doc.to_dict()
+            email = user_data.get("email", "")
+            if not is_test_email(email):
+                all_users.append(user_data)
+
+        if users_fetched >= USERS_STREAM_LIMIT:
+            logger.warning(f"Users stream hit limit ({USERS_STREAM_LIMIT}), stats may be incomplete")
+
+        # Calculate user stats from filtered list
+        total_users = len(all_users)
+        active_users_7d = sum(
+            1 for u in all_users
+            if u.get("last_login_at") and _normalize_datetime(u["last_login_at"]) >= seven_days_ago
+        )
+        active_users_30d = sum(
+            1 for u in all_users
+            if u.get("last_login_at") and _normalize_datetime(u["last_login_at"]) >= thirty_days_ago
+        )
+        total_beta_testers = sum(1 for u in all_users if u.get("is_beta_tester"))
 
-    # Credit statistics - sum credits added in last 30 days
-    # This is more expensive, so we'll just estimate from users
-    total_credits_issued_30d = 0
-    try:
-        # Get all users and sum recent credit transactions
-        users_docs = users_collection.limit(500).stream()
-        for user_doc in users_docs:
-            user_data = user_doc.to_dict()
+        # Calculate credits from filtered users
+        total_credits_issued_30d = 0
+        for user_data in all_users:
             transactions = user_data.get("credit_transactions", [])
             for txn in transactions:
-                txn_date = txn.get("created_at")
-                if txn_date:
-                    # Handle both datetime and string formats
-                    if isinstance(txn_date, str):
-                        try:
-                            txn_date = datetime.fromisoformat(txn_date.replace("Z", "+00:00"))
-                        except Exception:
-                            continue
-                    if isinstance(txn_date, datetime):
-                        txn_date = txn_date.replace(tzinfo=None)
-                    else:
-                        continue
-                    if txn_date >= thirty_days_ago:
+                txn_date = _normalize_datetime(txn.get("created_at"))
+                if txn_date and txn_date >= thirty_days_ago:
+                    amount = txn.get("amount", 0)
+                    if amount > 0:
+                        total_credits_issued_30d += amount
+
+        # Stream all jobs and filter by user_email
+        all_jobs = []
+        jobs_fetched = 0
+        for doc in jobs_collection.limit(JOBS_STREAM_LIMIT).stream():
+            jobs_fetched += 1
+            job_data = doc.to_dict()
+            user_email = job_data.get("user_email", "")
+            if not is_test_email(user_email):
+                all_jobs.append(job_data)
+
+        if jobs_fetched >= JOBS_STREAM_LIMIT:
+            logger.warning(f"Jobs stream hit limit ({JOBS_STREAM_LIMIT}), stats may be incomplete")
+
+        # Calculate job stats from filtered list
+        total_jobs = len(all_jobs)
+        jobs_last_7d = sum(
+            1 for j in all_jobs
+            if j.get("created_at") and _normalize_datetime(j["created_at"]) >= seven_days_ago
+        )
+        jobs_last_30d = sum(
+            1 for j in all_jobs
+            if j.get("created_at") and _normalize_datetime(j["created_at"]) >= thirty_days_ago
+        )
+
+        # Jobs by status
+        jobs_by_status = JobsByStatusResponse(
+            pending=sum(1 for j in all_jobs if j.get("status") == "pending"),
+            processing=sum(1 for j in all_jobs if j.get("status") in processing_statuses),
+            awaiting_review=sum(1 for j in all_jobs if j.get("status") in ["awaiting_review", "in_review"]),
+            awaiting_instrumental=sum(1 for j in all_jobs if j.get("status") == "awaiting_instrumental_selection"),
+            complete=sum(1 for j in all_jobs if j.get("status") in ["complete", "prep_complete"]),
+            failed=sum(1 for j in all_jobs if j.get("status") == "failed"),
+            cancelled=sum(1 for j in all_jobs if j.get("status") == "cancelled"),
+        )
+    else:
+        # When including test data, use efficient aggregation queries
+        def get_count(query) -> int:
+            try:
+                agg_query = aggregation.AggregationQuery(query)
+                agg_query.count(alias="count")
+                results = agg_query.get()
+                return results[0][0].value if results else 0
+            except Exception as e:
+                logger.warning(f"Aggregation query failed: {e}")
+                return 0
+
+        # User statistics
+        total_users = get_count(users_collection)
+        active_users_7d = get_count(
+            users_collection.where(filter=FieldFilter("last_login_at", ">=", seven_days_ago))
+        )
+        active_users_30d = get_count(
+            users_collection.where(filter=FieldFilter("last_login_at", ">=", thirty_days_ago))
+        )
+        total_beta_testers = get_count(
+            users_collection.where(filter=FieldFilter("is_beta_tester", "==", True))
+        )
+
+        # Job statistics
+        total_jobs = get_count(jobs_collection)
+        jobs_last_7d = get_count(
+            jobs_collection.where(filter=FieldFilter("created_at", ">=", seven_days_ago))
+        )
+        jobs_last_30d = get_count(
+            jobs_collection.where(filter=FieldFilter("created_at", ">=", thirty_days_ago))
+        )
+
+        # Jobs by status
+        jobs_by_status = JobsByStatusResponse(
+            pending=get_count(
+                jobs_collection.where(filter=FieldFilter("status", "==", "pending"))
+            ),
+            processing=sum(
+                get_count(jobs_collection.where(filter=FieldFilter("status", "==", status)))
+                for status in processing_statuses
+            ),
+            awaiting_review=get_count(
+                jobs_collection.where(filter=FieldFilter("status", "==", "awaiting_review"))
+            ) + get_count(
+                jobs_collection.where(filter=FieldFilter("status", "==", "in_review"))
+            ),
+            awaiting_instrumental=get_count(
+                jobs_collection.where(filter=FieldFilter("status", "==", "awaiting_instrumental_selection"))
+            ),
+            complete=get_count(
+                jobs_collection.where(filter=FieldFilter("status", "==", "complete"))
+            ) + get_count(
+                jobs_collection.where(filter=FieldFilter("status", "==", "prep_complete"))
+            ),
+            failed=get_count(
+                jobs_collection.where(filter=FieldFilter("status", "==", "failed"))
+            ),
+            cancelled=get_count(
+                jobs_collection.where(filter=FieldFilter("status", "==", "cancelled"))
+            ),
+        )
+
+        # Credit statistics - sum credits added in last 30 days
+        total_credits_issued_30d = 0
+        try:
+            users_fetched = 0
+            for user_doc in users_collection.limit(USERS_STREAM_LIMIT).stream():
+                users_fetched += 1
+                user_data = user_doc.to_dict()
+                transactions = user_data.get("credit_transactions", [])
+                for txn in transactions:
+                    txn_date = _normalize_datetime(txn.get("created_at"))
+                    if txn_date and txn_date >= thirty_days_ago:
                         amount = txn.get("amount", 0)
-                        if amount > 0:  # Only count additions, not deductions
+                        if amount > 0:
                             total_credits_issued_30d += amount
-    except Exception as e:
-        logger.warning(f"Error calculating credits: {e}")
+            if users_fetched >= USERS_STREAM_LIMIT:
+                logger.warning(f"Credit calculation hit user limit ({USERS_STREAM_LIMIT}), total may be incomplete")
+        except Exception as e:
+            logger.warning(f"Error calculating credits: {e}")
 
     return AdminStatsOverview(
         total_users=total_users,
@@ -202,6 +273,21 @@ async def get_admin_stats_overview(
     )
 
 
+def _normalize_datetime(dt_value) -> Optional[datetime]:
+    """Normalize datetime values from Firestore (can be datetime or ISO string)."""
+    if dt_value is None:
+        return None
+    if isinstance(dt_value, datetime):
+        return dt_value.replace(tzinfo=None)
+    if isinstance(dt_value, str):
+        try:
+            parsed = datetime.fromisoformat(dt_value.replace("Z", "+00:00"))
+            return parsed.replace(tzinfo=None)
+        except Exception:
+            return None
+    return None
+
+
 # =============================================================================
 # Audio Search Management Models
 # =============================================================================
@@ -273,6 +359,7 @@ class CacheStatsResponse(BaseModel):
 async def list_audio_searches(
     limit: int = 50,
     status_filter: Optional[str] = None,
+    exclude_test: bool = True,
     auth_data: Tuple[str, UserType, int] = Depends(require_admin),
     user_service: UserService = Depends(get_user_service),
 ):
@@ -287,6 +374,7 @@ async def list_audio_searches(
     Args:
         limit: Maximum number of jobs to return (default 50)
         status_filter: Optional filter by job status (e.g., 'awaiting_audio_selection')
+        exclude_test: If True (default), exclude jobs from test users
     """
     from google.cloud.firestore_v1 import FieldFilter
 
@@ -306,6 +394,11 @@ async def list_audio_searches(
 
     for doc in query.stream():
         data = doc.to_dict()
+
+        # Filter out test users if exclude_test is True
+        if exclude_test and is_test_email(data.get("user_email", "")):
+            continue
+
         state_data = data.get("state_data", {})
         audio_results = state_data.get("audio_search_results", [])
 

backend/api/routes/audio_search.py

@@ -33,6 +33,7 @@ from backend.services.audio_search_service import (
     NoResultsError,
     DownloadError,
 )
+from backend.services.theme_service import get_theme_service
 from backend.config import get_settings
 from backend.version import VERSION
 from backend.api.dependencies import require_auth
@@ -534,9 +535,18 @@ async def search_audio(
         # Extract request metadata
         request_metadata = extract_request_metadata(request, created_from="audio_search")
 
+        # Apply default theme if none specified
+        # This ensures all karaoke videos use the Nomad theme by default
+        effective_theme_id = body.theme_id
+        if effective_theme_id is None:
+            theme_service = get_theme_service()
+            effective_theme_id = theme_service.get_default_theme_id()
+            if effective_theme_id:
+                logger.info(f"Applying default theme: {effective_theme_id}")
+
         # Resolve CDG/TXT defaults based on theme
         resolved_cdg, resolved_txt = _resolve_cdg_txt_defaults(
-            body.theme_id, body.enable_cdg, body.enable_txt
+            effective_theme_id, body.enable_cdg, body.enable_txt
         )
 
         # Use authenticated user's email
@@ -552,7 +562,7 @@ async def search_audio(
         job_create = JobCreate(
             artist=effective_display_artist,  # Display value for title screens, filenames
             title=effective_display_title,    # Display value for title screens, filenames
-            theme_id=body.theme_id,
+            theme_id=effective_theme_id,
             color_overrides=body.color_overrides or {},
             enable_cdg=resolved_cdg,
             enable_txt=resolved_txt,
@@ -591,11 +601,11 @@ async def search_audio(
         # If theme is set and no custom style files are being uploaded, prepare theme style now
         # This copies the theme's style_params.json to the job folder so LyricsTranscriber
         # can access the style configuration for preview videos
-        if body.theme_id and not body.style_files:
+        if effective_theme_id and not body.style_files:
             from backend.api.routes.file_upload import _prepare_theme_for_job
             try:
                 style_params_path, theme_style_assets, youtube_desc = _prepare_theme_for_job(
-                    job_id, body.theme_id, body.color_overrides
+                    job_id, effective_theme_id, body.color_overrides
                 )
                 theme_update = {
                     'style_params_gcs_path': style_params_path,
@@ -604,9 +614,9 @@ async def search_audio(
                 if youtube_desc and not effective_youtube_description:
                     theme_update['youtube_description_template'] = youtube_desc
                 job_manager.update_job(job_id, theme_update)
-                logger.info(f"Applied theme '{body.theme_id}' to job {job_id}")
+                logger.info(f"Applied theme '{effective_theme_id}' to job {job_id}")
             except Exception as e:
-                logger.warning(f"Failed to prepare theme '{body.theme_id}' for job {job_id}: {e}")
+                logger.warning(f"Failed to prepare theme '{effective_theme_id}' for job {job_id}: {e}")
                 # Continue without theme - job can still be processed with defaults
 
         # Handle style file uploads if provided

backend/api/routes/file_upload.py

@@ -562,9 +562,18 @@ async def upload_and_create_job(
                     detail=f"Invalid color_overrides JSON: {e}"
                 )
 
+        # Apply default theme if none specified
+        # This ensures all karaoke videos use the Nomad theme by default
+        effective_theme_id = theme_id
+        if effective_theme_id is None:
+            theme_service = get_theme_service()
+            effective_theme_id = theme_service.get_default_theme_id()
+            if effective_theme_id:
+                logger.info(f"Applying default theme: {effective_theme_id}")
+
         # Resolve CDG/TXT defaults based on theme
         resolved_cdg, resolved_txt = _resolve_cdg_txt_defaults(
-            theme_id, enable_cdg, enable_txt
+            effective_theme_id, enable_cdg, enable_txt
         )
 
         # Check if any custom style files are being uploaded (overrides theme)
@@ -596,7 +605,7 @@ async def upload_and_create_job(
             artist=artist,
             title=title,
             filename=file.filename,
-            theme_id=theme_id,
+            theme_id=effective_theme_id,
             color_overrides=parsed_color_overrides,
             enable_cdg=resolved_cdg,
             enable_txt=resolved_txt,
@@ -638,16 +647,16 @@ async def upload_and_create_job(
         theme_style_params_path = None
         theme_style_assets = {}
         theme_youtube_desc = None
-        if theme_id and not has_custom_style_files:
+        if effective_theme_id and not has_custom_style_files:
             try:
                 theme_style_params_path, theme_style_assets, theme_youtube_desc = _prepare_theme_for_job(
-                    job_id, theme_id, parsed_color_overrides or None
+                    job_id, effective_theme_id, parsed_color_overrides or None
                 )
-                logger.info(f"Applied theme '{theme_id}' to job {job_id}")
+                logger.info(f"Applied theme '{effective_theme_id}' to job {job_id}")
             except HTTPException:
                 raise  # Re-raise validation errors (e.g., theme not found)
             except Exception as e:
-                logger.warning(f"Failed to prepare theme '{theme_id}' for job {job_id}: {e}")
+                logger.warning(f"Failed to prepare theme '{effective_theme_id}' for job {job_id}: {e}")
                 # Continue without theme - job can still be processed with defaults
 
         # Upload main audio file to GCS
@@ -1097,9 +1106,18 @@ async def create_job_with_upload_urls(
         # Get original audio filename
         audio_file = audio_files[0]
 
+        # Apply default theme if none specified
+        # This ensures all karaoke videos use the Nomad theme by default
+        effective_theme_id = body.theme_id
+        if effective_theme_id is None:
+            theme_service = get_theme_service()
+            effective_theme_id = theme_service.get_default_theme_id()
+            if effective_theme_id:
+                logger.info(f"Applying default theme: {effective_theme_id}")
+
         # Resolve CDG/TXT defaults based on theme
         resolved_cdg, resolved_txt = _resolve_cdg_txt_defaults(
-            body.theme_id, body.enable_cdg, body.enable_txt
+            effective_theme_id, body.enable_cdg, body.enable_txt
         )
 
         # Check if style_params is being uploaded (overrides theme)
@@ -1113,7 +1131,7 @@ async def create_job_with_upload_urls(
             artist=body.artist,
             title=body.title,
             filename=audio_file.filename,
-            theme_id=body.theme_id,
+            theme_id=effective_theme_id,
             color_overrides=body.color_overrides or {},
             enable_cdg=resolved_cdg,
             enable_txt=resolved_txt,
@@ -1145,9 +1163,9 @@ async def create_job_with_upload_urls(
         logger.info(f"Created job {job_id} for {body.artist} - {body.title} (signed URL upload flow)")
 
         # If theme is set and no style_params uploaded, prepare theme style now
-        if body.theme_id and not has_style_params_upload:
+        if effective_theme_id and not has_style_params_upload:
             style_params_path, style_assets, youtube_desc = _prepare_theme_for_job(
-                job_id, body.theme_id, body.color_overrides
+                job_id, effective_theme_id, body.color_overrides
             )
             # Update job with theme style data
             update_data = {
@@ -1157,7 +1175,7 @@ async def create_job_with_upload_urls(
             if youtube_desc and not body.youtube_description:
                 update_data['youtube_description_template'] = youtube_desc
             job_manager.update_job(job_id, update_data)
-            logger.info(f"Applied theme '{body.theme_id}' to job {job_id}")
+            logger.info(f"Applied theme '{effective_theme_id}' to job {job_id}")
         
         # Generate signed upload URLs for each file
         upload_urls = []
@@ -1521,9 +1539,18 @@ async def create_job_from_url(
         artist = body.artist
         title = body.title
 
+        # Apply default theme if none specified
+        # This ensures all karaoke videos use the Nomad theme by default
+        effective_theme_id = body.theme_id
+        if effective_theme_id is None:
+            theme_service = get_theme_service()
+            effective_theme_id = theme_service.get_default_theme_id()
+            if effective_theme_id:
+                logger.info(f"Applying default theme: {effective_theme_id}")
+
         # Resolve CDG/TXT defaults based on theme
         resolved_cdg, resolved_txt = _resolve_cdg_txt_defaults(
-            body.theme_id, body.enable_cdg, body.enable_txt
+            effective_theme_id, body.enable_cdg, body.enable_txt
         )
 
         # Prefer authenticated user's email over request body
@@ -1535,7 +1562,7 @@ async def create_job_from_url(
             artist=artist,
             title=title,
             filename=None,  # No file uploaded
-            theme_id=body.theme_id,
+            theme_id=effective_theme_id,
             color_overrides=body.color_overrides or {},
             enable_cdg=resolved_cdg,
             enable_txt=resolved_txt,
@@ -1564,9 +1591,9 @@ async def create_job_from_url(
         metrics.record_job_created(job_id, source="url")
 
         # If theme is set, prepare theme style now
-        if body.theme_id:
+        if effective_theme_id:
             style_params_path, style_assets, youtube_desc = _prepare_theme_for_job(
-                job_id, body.theme_id, body.color_overrides
+                job_id, effective_theme_id, body.color_overrides
             )
             # Update job with theme style data
             update_data = {
@@ -1576,7 +1603,7 @@ async def create_job_from_url(
             if youtube_desc and not body.youtube_description:
                 update_data['youtube_description_template'] = youtube_desc
             job_manager.update_job(job_id, update_data)
-            logger.info(f"Applied theme '{body.theme_id}' to job {job_id}")
+            logger.info(f"Applied theme '{effective_theme_id}' to job {job_id}")
         
         logger.info(f"Created URL-based job {job_id} for URL: {body.url}")
         if artist:
@@ -1768,9 +1795,18 @@ async def create_finalise_only_job(
         # Extract request metadata
         request_metadata = extract_request_metadata(request, created_from="finalise_only_upload")
 
+        # Apply default theme if none specified
+        # This ensures all karaoke videos use the Nomad theme by default
+        effective_theme_id = body.theme_id
+        if effective_theme_id is None:
+            theme_service = get_theme_service()
+            effective_theme_id = theme_service.get_default_theme_id()
+            if effective_theme_id:
+                logger.info(f"Applying default theme: {effective_theme_id}")
+
         # Resolve CDG/TXT defaults based on theme
         resolved_cdg, resolved_txt = _resolve_cdg_txt_defaults(
-            body.theme_id, body.enable_cdg, body.enable_txt
+            effective_theme_id, body.enable_cdg, body.enable_txt
         )
 
         # Check if style_params is being uploaded (overrides theme)
@@ -1784,7 +1820,7 @@ async def create_finalise_only_job(
             artist=body.artist,
             title=body.title,
             filename="finalise_only",  # No single audio file - using prep outputs
-            theme_id=body.theme_id,
+            theme_id=effective_theme_id,
             color_overrides=body.color_overrides or {},
             enable_cdg=resolved_cdg,
             enable_txt=resolved_txt,
@@ -1808,9 +1844,9 @@ async def create_finalise_only_job(
         logger.info(f"Created finalise-only job {job_id} for {body.artist} - {body.title}")
 
         # If theme is set and no style_params uploaded, prepare theme style now
-        if body.theme_id and not has_style_params_upload:
+        if effective_theme_id and not has_style_params_upload:
             style_params_path, style_assets, youtube_desc = _prepare_theme_for_job(
-                job_id, body.theme_id, body.color_overrides
+                job_id, effective_theme_id, body.color_overrides
             )
             # Update job with theme style data
             update_data = {
@@ -1820,7 +1856,7 @@ async def create_finalise_only_job(
             if youtube_desc and not body.youtube_description:
                 update_data['youtube_description_template'] = youtube_desc
             job_manager.update_job(job_id, update_data)
-            logger.info(f"Applied theme '{body.theme_id}' to job {job_id}")
+            logger.info(f"Applied theme '{effective_theme_id}' to job {job_id}")
         
         # Generate signed upload URLs for each file
         upload_urls = []