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

backend/Dockerfile.base

@@ -54,6 +54,7 @@ WORKDIR /app
 COPY pyproject.toml README.md LICENSE /app/
 COPY karaoke_gen /app/karaoke_gen
 COPY lyrics_transcriber_temp /app/lyrics_transcriber_temp
+COPY backend /app/backend
 
 # Install all Python dependencies (the slow part - cached in base image)
 RUN pip install --no-cache-dir --upgrade pip && \

backend/api/routes/admin.py

@@ -8,7 +8,7 @@ Handles:
 - Audio search cache management
 """
 import logging
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from typing import Tuple, List, Optional, Any, Dict
 
 from fastapi import APIRouter, Depends, HTTPException
@@ -1139,6 +1139,229 @@ async def reset_job(
     )
 
 
+# =============================================================================
+# Delete Job Outputs Endpoint
+# =============================================================================
+
+class DeleteOutputsResponse(BaseModel):
+    """Response from delete job outputs endpoint."""
+    status: str
+    job_id: str
+    message: str
+    deleted_services: Dict[str, Any]  # youtube, dropbox, gdrive results
+    cleared_state_data: List[str]
+    outputs_deleted_at: str
+
+
+# State data keys to clear when deleting outputs
+OUTPUT_STATE_DATA_KEYS = [
+    "youtube_url",
+    "youtube_video_id",
+    "dropbox_link",
+    "brand_code",
+    "gdrive_files",
+]
+
+
+# Terminal states that allow output deletion
+TERMINAL_STATES = {"complete", "prep_complete", "failed", "cancelled"}
+
+
+@router.post("/jobs/{job_id}/delete-outputs", response_model=DeleteOutputsResponse)
+async def delete_job_outputs(
+    job_id: str,
+    auth_data: AuthResult = Depends(require_admin),
+):
+    """
+    Delete all distributed outputs for a job (admin only).
+
+    This endpoint deletes:
+    1. YouTube video (if uploaded)
+    2. Dropbox folder (if uploaded) - frees brand code for reuse
+    3. Google Drive files (if uploaded)
+
+    The job record is preserved with outputs_deleted_at timestamp set.
+    State data related to distribution is cleared.
+
+    Use case: Delete outputs for quality issues, then reset job to
+    awaiting_review or awaiting_instrumental_selection to re-process.
+
+    Args:
+        job_id: Job ID to delete outputs for
+
+    Returns:
+        Deletion results for each service
+    """
+    import re
+    from google.cloud.firestore_v1 import DELETE_FIELD, ArrayUnion
+
+    admin_email = auth_data.user_email or "unknown"
+    job_manager = JobManager()
+    job = job_manager.get_job(job_id)
+
+    if not job:
+        raise HTTPException(status_code=404, detail=f"Job {job_id} not found")
+
+    # Verify job is in a terminal state
+    if job.status not in TERMINAL_STATES:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Can only delete outputs from jobs in terminal states. "
+            f"Current status: {job.status}. Allowed: {', '.join(sorted(TERMINAL_STATES))}"
+        )
+
+    # Check if outputs already deleted
+    if job.outputs_deleted_at:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Outputs were already deleted at {job.outputs_deleted_at}"
+        )
+
+    state_data = job.state_data or {}
+    results = {
+        "youtube": {"status": "skipped", "reason": "no youtube_url in state_data"},
+        "dropbox": {"status": "skipped", "reason": "no brand_code or dropbox_path"},
+        "gdrive": {"status": "skipped", "reason": "no gdrive_files in state_data"},
+    }
+
+    # Clean up YouTube
+    youtube_url = state_data.get('youtube_url')
+    if youtube_url:
+        try:
+            video_id_match = re.search(r'(?:youtu\.be/|youtube\.com/watch\?v=)([^&\s]+)', youtube_url)
+            if video_id_match:
+                video_id = video_id_match.group(1)
+
+                from karaoke_gen.karaoke_finalise.karaoke_finalise import KaraokeFinalise
+                from backend.services.youtube_service import get_youtube_service
+
+                youtube_service = get_youtube_service()
+                if youtube_service.is_configured:
+                    finalise = KaraokeFinalise(
+                        dry_run=False,
+                        non_interactive=True,
+                        user_youtube_credentials=youtube_service.get_credentials_dict()
+                    )
+                    success = finalise.delete_youtube_video(video_id)
+                    results["youtube"] = {
+                        "status": "success" if success else "failed",
+                        "video_id": video_id
+                    }
+                else:
+                    results["youtube"] = {"status": "skipped", "reason": "YouTube credentials not configured"}
+            else:
+                results["youtube"] = {"status": "failed", "reason": f"Could not extract video ID from {youtube_url}"}
+        except Exception as e:
+            logger.error(f"Error deleting YouTube video for job {job_id}: {e}", exc_info=True)
+            results["youtube"] = {"status": "error", "error": str(e)}
+
+    # Clean up Dropbox
+    brand_code = state_data.get('brand_code')
+    dropbox_path = getattr(job, 'dropbox_path', None)
+    if brand_code and dropbox_path:
+        try:
+            from backend.services.dropbox_service import get_dropbox_service
+            dropbox = get_dropbox_service()
+            if dropbox.is_configured:
+                base_name = f"{job.artist} - {job.title}"
+                folder_name = f"{brand_code} - {base_name}"
+                full_path = f"{dropbox_path}/{folder_name}"
+                success = dropbox.delete_folder(full_path)
+                results["dropbox"] = {
+                    "status": "success" if success else "failed",
+                    "path": full_path
+                }
+            else:
+                results["dropbox"] = {"status": "skipped", "reason": "Dropbox credentials not configured"}
+        except Exception as e:
+            logger.error(f"Error deleting Dropbox folder for job {job_id}: {e}", exc_info=True)
+            results["dropbox"] = {"status": "error", "error": str(e)}
+
+    # Clean up Google Drive
+    gdrive_files = state_data.get('gdrive_files')
+    if gdrive_files:
+        try:
+            from backend.services.gdrive_service import get_gdrive_service
+            gdrive = get_gdrive_service()
+            if gdrive.is_configured:
+                file_ids = list(gdrive_files.values()) if isinstance(gdrive_files, dict) else []
+                delete_results = gdrive.delete_files(file_ids)
+                all_success = all(delete_results.values())
+                results["gdrive"] = {
+                    "status": "success" if all_success else "partial",
+                    "files": delete_results
+                }
+            else:
+                results["gdrive"] = {"status": "skipped", "reason": "Google Drive credentials not configured"}
+        except Exception as e:
+            logger.error(f"Error deleting Google Drive files for job {job_id}: {e}", exc_info=True)
+            results["gdrive"] = {"status": "error", "error": str(e)}
+
+    # Update job record
+    deletion_timestamp = datetime.now(timezone.utc)
+    user_service = get_user_service()
+    db = user_service.db
+    job_ref = db.collection("jobs").document(job_id)
+
+    update_payload = {
+        "outputs_deleted_at": deletion_timestamp,
+        "outputs_deleted_by": admin_email,
+        "updated_at": deletion_timestamp,
+    }
+
+    # Clear distribution-related state_data keys
+    cleared_keys = []
+    for key in OUTPUT_STATE_DATA_KEYS:
+        if key in state_data:
+            update_payload[f"state_data.{key}"] = DELETE_FIELD
+            cleared_keys.append(key)
+
+    # Add timeline event
+    timeline_event = {
+        "status": job.status,  # Keep current status
+        "timestamp": deletion_timestamp.isoformat(),
+        "message": f"Outputs deleted by admin ({admin_email})",
+    }
+    update_payload["timeline"] = ArrayUnion([timeline_event])
+
+    job_ref.update(update_payload)
+
+    # Determine overall status based on per-service results
+    error_services = [s for s, r in results.items() if r["status"] == "error"]
+    failed_services = [s for s, r in results.items() if r["status"] == "failed"]
+    success_services = [s for s, r in results.items() if r["status"] == "success"]
+
+    if error_services:
+        overall_status = "partial_success" if success_services else "error"
+        error_details = "; ".join(
+            f"{s}: {results[s].get('error', 'unknown error')}" for s in error_services
+        )
+        message = f"Some services failed: {error_details}"
+    elif failed_services:
+        overall_status = "partial_success" if success_services else "failed"
+        message = f"Some deletions failed: {', '.join(failed_services)}"
+    else:
+        overall_status = "success"
+        message = "Outputs deleted successfully"
+
+    logger.info(
+        f"Admin {admin_email} deleted outputs for job {job_id}. "
+        f"YouTube: {results['youtube']['status']}, "
+        f"Dropbox: {results['dropbox']['status']}, "
+        f"GDrive: {results['gdrive']['status']}. "
+        f"Cleared state_data keys: {cleared_keys}"
+    )
+
+    return DeleteOutputsResponse(
+        status=overall_status,
+        job_id=job_id,
+        message=message,
+        deleted_services=results,
+        cleared_state_data=cleared_keys,
+        outputs_deleted_at=deletion_timestamp.isoformat(),
+    )
+
+
 @router.get("/jobs/{job_id}/completion-message", response_model=CompletionMessageResponse)
 async def get_job_completion_message(
     job_id: str,
@@ -1286,7 +1509,7 @@ class ImpersonateUserResponse(BaseModel):
 @router.post("/users/{email}/impersonate", response_model=ImpersonateUserResponse)
 async def impersonate_user(
     email: str,
-    auth_data: Tuple[str, UserType, int] = Depends(require_admin),
+    auth_data: AuthResult = Depends(require_admin),
     user_service: UserService = Depends(get_user_service),
 ):
     """
@@ -1308,7 +1531,7 @@ async def impersonate_user(
         user_email: The impersonated user's email
         message: Success message
     """
-    admin_email = auth_data[0]
+    admin_email = auth_data.user_email or "unknown"
     target_email = email.lower()
 
     # Cannot impersonate yourself

backend/api/routes/push.py

@@ -0,0 +1,238 @@
+"""
+Push Notification API routes.
+
+Provides endpoints for managing Web Push notification subscriptions:
+- GET /api/push/vapid-public-key: Get VAPID public key for client-side subscription
+- POST /api/push/subscribe: Register a push subscription
+- POST /api/push/unsubscribe: Remove a push subscription
+- GET /api/push/subscriptions: List user's subscriptions
+- POST /api/push/test: Send a test notification (admin only)
+"""
+import logging
+from typing import Optional, Dict, List
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+
+from backend.config import get_settings
+from backend.api.dependencies import require_auth, require_admin
+from backend.services.auth_service import AuthResult
+from backend.services.push_notification_service import get_push_notification_service
+
+
+logger = logging.getLogger(__name__)
+router = APIRouter(prefix="/push", tags=["push"])
+
+
+# Request/Response Models
+
+class VapidPublicKeyResponse(BaseModel):
+    """Response containing VAPID public key."""
+    enabled: bool
+    vapid_public_key: Optional[str] = None
+
+
+class SubscribeRequest(BaseModel):
+    """Request to subscribe to push notifications."""
+    endpoint: str
+    keys: Dict[str, str]  # p256dh and auth
+    device_name: Optional[str] = None
+
+
+class SubscribeResponse(BaseModel):
+    """Response after subscribing."""
+    status: str
+    message: str
+
+
+class UnsubscribeRequest(BaseModel):
+    """Request to unsubscribe from push notifications."""
+    endpoint: str
+
+
+class UnsubscribeResponse(BaseModel):
+    """Response after unsubscribing."""
+    status: str
+    message: str
+
+
+class SubscriptionInfo(BaseModel):
+    """Information about a push subscription."""
+    endpoint: str
+    device_name: Optional[str] = None
+    created_at: Optional[str] = None
+    last_used_at: Optional[str] = None
+
+
+class SubscriptionsListResponse(BaseModel):
+    """Response containing user's subscriptions."""
+    subscriptions: List[SubscriptionInfo]
+    count: int
+
+
+class TestNotificationRequest(BaseModel):
+    """Request to send a test notification."""
+    title: Optional[str] = "Test Notification"
+    body: Optional[str] = "This is a test push notification from Karaoke Generator"
+
+
+class TestNotificationResponse(BaseModel):
+    """Response after sending test notification."""
+    status: str
+    sent_count: int
+    message: str
+
+
+# Routes
+
+@router.get("/vapid-public-key", response_model=VapidPublicKeyResponse)
+async def get_vapid_public_key():
+    """
+    Get the VAPID public key for push subscription.
+
+    This endpoint is public - no authentication required.
+    Returns the public key needed for client-side PushManager.subscribe().
+    """
+    settings = get_settings()
+    push_service = get_push_notification_service()
+
+    if not settings.enable_push_notifications:
+        return VapidPublicKeyResponse(enabled=False)
+
+    public_key = push_service.get_public_key()
+    if not public_key:
+        return VapidPublicKeyResponse(enabled=False)
+
+    return VapidPublicKeyResponse(
+        enabled=True,
+        vapid_public_key=public_key
+    )
+
+
+@router.post("/subscribe", response_model=SubscribeResponse)
+async def subscribe_push(
+    request: SubscribeRequest,
+    auth_result: AuthResult = Depends(require_auth)
+):
+    """
+    Register a push notification subscription for the current user.
+
+    Requires authentication. Users can have up to 5 subscriptions
+    (configurable via MAX_PUSH_SUBSCRIPTIONS_PER_USER).
+    """
+    settings = get_settings()
+    if not settings.enable_push_notifications:
+        raise HTTPException(status_code=503, detail="Push notifications are not enabled")
+
+    if not auth_result.user_email:
+        raise HTTPException(status_code=401, detail="User email not available")
+
+    push_service = get_push_notification_service()
+
+    # Validate keys
+    if "p256dh" not in request.keys or "auth" not in request.keys:
+        raise HTTPException(status_code=400, detail="Missing required keys (p256dh, auth)")
+
+    success = await push_service.add_subscription(
+        user_email=auth_result.user_email,
+        endpoint=request.endpoint,
+        keys=request.keys,
+        device_name=request.device_name
+    )
+
+    if not success:
+        raise HTTPException(status_code=500, detail="Failed to save subscription")
+
+    return SubscribeResponse(
+        status="success",
+        message="Push subscription registered successfully"
+    )
+
+
+@router.post("/unsubscribe", response_model=UnsubscribeResponse)
+async def unsubscribe_push(
+    request: UnsubscribeRequest,
+    auth_result: AuthResult = Depends(require_auth)
+):
+    """
+    Remove a push notification subscription.
+
+    Requires authentication. Users can only remove their own subscriptions.
+    """
+    if not auth_result.user_email:
+        raise HTTPException(status_code=401, detail="User email not available")
+
+    push_service = get_push_notification_service()
+
+    success = await push_service.remove_subscription(
+        user_email=auth_result.user_email,
+        endpoint=request.endpoint
+    )
+
+    if not success:
+        # Don't error if subscription wasn't found - might already be removed
+        return UnsubscribeResponse(
+            status="success",
+            message="Subscription removed (or was not found)"
+        )
+
+    return UnsubscribeResponse(
+        status="success",
+        message="Push subscription removed successfully"
+    )
+
+
+@router.get("/subscriptions", response_model=SubscriptionsListResponse)
+async def list_subscriptions(
+    auth_result: AuthResult = Depends(require_auth)
+):
+    """
+    List all push notification subscriptions for the current user.
+
+    Requires authentication.
+    """
+    if not auth_result.user_email:
+        raise HTTPException(status_code=401, detail="User email not available")
+
+    push_service = get_push_notification_service()
+
+    subscriptions = await push_service.list_subscriptions(auth_result.user_email)
+
+    return SubscriptionsListResponse(
+        subscriptions=[SubscriptionInfo(**s) for s in subscriptions],
+        count=len(subscriptions)
+    )
+
+
+@router.post("/test", response_model=TestNotificationResponse)
+async def send_test_notification(
+    request: TestNotificationRequest,
+    auth_result: AuthResult = Depends(require_admin)
+):
+    """
+    Send a test push notification to the current user's devices.
+
+    Admin only. Useful for testing push notification setup.
+    """
+    settings = get_settings()
+    if not settings.enable_push_notifications:
+        raise HTTPException(status_code=503, detail="Push notifications are not enabled")
+
+    if not auth_result.user_email:
+        raise HTTPException(status_code=401, detail="User email not available")
+
+    push_service = get_push_notification_service()
+
+    sent_count = await push_service.send_push(
+        user_email=auth_result.user_email,
+        title=request.title or "Test Notification",
+        body=request.body or "This is a test push notification",
+        url="/app/",
+        tag="test"
+    )
+
+    return TestNotificationResponse(
+        status="success",
+        sent_count=sent_count,
+        message=f"Test notification sent to {sent_count} device(s)"
+    )

backend/config.py

@@ -123,7 +123,15 @@ class Settings(BaseSettings):
     # These can be overridden per-request via explicit enable_cdg/enable_txt parameters
     default_enable_cdg: bool = os.getenv("DEFAULT_ENABLE_CDG", "true").lower() in ("true", "1", "yes")
     default_enable_txt: bool = os.getenv("DEFAULT_ENABLE_TXT", "true").lower() in ("true", "1", "yes")
-    
+
+    # Push Notifications Configuration
+    # When enabled, users can subscribe to push notifications for job status updates
+    enable_push_notifications: bool = os.getenv("ENABLE_PUSH_NOTIFICATIONS", "false").lower() in ("true", "1", "yes")
+    # Maximum number of push subscriptions per user (oldest removed when exceeded)
+    max_push_subscriptions_per_user: int = int(os.getenv("MAX_PUSH_SUBSCRIPTIONS_PER_USER", "5"))
+    # VAPID subject (email or URL for push service to contact)
+    vapid_subject: str = os.getenv("VAPID_SUBJECT", "mailto:gen@nomadkaraoke.com")
+
     # Secret Manager cache
     _secret_cache: Dict[str, str] = {}
     

backend/main.py

@@ -7,7 +7,7 @@ from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 
 from backend.config import settings
-from backend.api.routes import health, jobs, internal, file_upload, review, auth, audio_search, themes, users, admin, tenant, rate_limits
+from backend.api.routes import health, jobs, internal, file_upload, review, auth, audio_search, themes, users, admin, tenant, rate_limits, push
 from backend.services.tracing import setup_tracing, instrument_app, get_current_trace_id
 from backend.services.structured_logging import setup_structured_logging
 from backend.services.spacy_preloader import preload_spacy_model
@@ -144,6 +144,7 @@ app.include_router(themes.router, prefix="/api")  # Theme selection for styles
 app.include_router(users.router, prefix="/api")  # User auth, credits, and Stripe webhooks
 app.include_router(admin.router, prefix="/api")  # Admin dashboard and management
 app.include_router(rate_limits.router, prefix="/api")  # Rate limits admin management
+app.include_router(push.router, prefix="/api")  # Push notification subscription management
 app.include_router(tenant.router)  # Tenant/white-label configuration (no /api prefix, router has it)
 
 

backend/models/job.py

@@ -285,6 +285,10 @@ class Job(BaseModel):
     customer_email: Optional[str] = None         # Customer email for final delivery (job owned by admin during processing)
     customer_notes: Optional[str] = None         # Notes provided by customer with their order
 
+    # Output deletion tracking (for admin cleanup without deleting job)
+    outputs_deleted_at: Optional[datetime] = None  # Timestamp when outputs were deleted by admin
+    outputs_deleted_by: Optional[str] = None       # Admin email who deleted outputs
+
     # Processing state
     track_output_dir: Optional[str] = None       # Local output directory (temp)
     audio_hash: Optional[str] = None             # Hash for deduplication

backend/models/user.py

@@ -8,9 +8,9 @@ Supports:
 - Stripe integration for payments
 - Beta tester program with feedback collection
 """
-from datetime import datetime
+from datetime import datetime, timezone
 from enum import Enum
-from typing import Optional, List
+from typing import Optional, List, Dict
 from pydantic import BaseModel, Field
 
 
@@ -39,6 +39,20 @@ class CreditTransaction(BaseModel):
     created_by: Optional[str] = None  # Admin email if granted by admin
 
 
+class PushSubscription(BaseModel):
+    """
+    Web Push subscription for a user's device.
+
+    Stores the push subscription endpoint and encryption keys needed
+    to send push notifications to the user's browser/device.
+    """
+    endpoint: str  # Push service endpoint URL
+    keys: Dict[str, str]  # p256dh and auth keys for encryption
+    device_name: Optional[str] = None  # e.g., "iPhone", "Chrome on Windows"
+    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+    last_used_at: Optional[datetime] = None  # Last time a notification was sent
+
+
 class User(BaseModel):
     """
     User model stored in Firestore.
@@ -86,6 +100,10 @@ class User(BaseModel):
     beta_feedback_due_at: Optional[datetime] = None  # 24hr after job completion
     beta_feedback_email_sent: bool = False
 
+    # Push notification subscriptions (Web Push API)
+    # Users can subscribe from multiple devices/browsers
+    push_subscriptions: List[PushSubscription] = Field(default_factory=list)
+
 
 class MagicLinkToken(BaseModel):
     """

backend/services/gce_encoding/main.py

@@ -338,19 +338,33 @@ def run_encoding(job_id: str, work_dir: Path, config: dict):
                 # Search more specifically for karaoke video
                 karaoke_video = find_file(work_dir, "*Karaoke*.mkv", "*Karaoke*.mov", "*vocals*.mkv")
 
-        # Instrumental audio
-        instrumental = find_file(
-            work_dir,
-            "*instrumental_clean*.flac", "*Instrumental Clean*.flac",
-            "*instrumental*.flac", "*Instrumental*.flac",
-            "*instrumental*.wav"
-        )
+        # Instrumental audio - respect user's selection from encoding config
+        instrumental_selection = config.get("instrumental_selection", "clean")
+        logger.info(f"Instrumental selection from config: {instrumental_selection}")
+
+        if instrumental_selection == "with_backing":
+            # User selected instrumental with backing vocals
+            instrumental = find_file(
+                work_dir,
+                "*instrumental_with_backing*.flac", "*Instrumental Backing*.flac",
+                "*with_backing*.flac", "*Backing*.flac",
+                "*instrumental*.flac", "*Instrumental*.flac",
+                "*instrumental*.wav"
+            )
+        else:
+            # Default to clean instrumental
+            instrumental = find_file(
+                work_dir,
+                "*instrumental_clean*.flac", "*Instrumental Clean*.flac",
+                "*instrumental*.flac", "*Instrumental*.flac",
+                "*instrumental*.wav"
+            )
 
         logger.info(f"Found files:")
         logger.info(f"  Title video: {title_video}")
         logger.info(f"  Karaoke video: {karaoke_video}")
         logger.info(f"  End video: {end_video}")
-        logger.info(f"  Instrumental: {instrumental}")
+        logger.info(f"  Instrumental ({instrumental_selection}): {instrumental}")
 
         # Validate required files
         if not title_video: