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

backend/api/routes/users.py

@@ -32,8 +32,11 @@ from backend.models.user import (
 from backend.services.user_service import get_user_service, UserService, USERS_COLLECTION
 from backend.services.email_service import get_email_service, EmailService
 from backend.services.stripe_service import get_stripe_service, StripeService, CREDIT_PACKAGES
+from backend.services.theme_service import get_theme_service
 from backend.api.dependencies import require_admin
+from backend.api.routes.file_upload import _prepare_theme_for_job
 from backend.services.auth_service import UserType
+from backend.utils.test_data import is_test_email
 
 
 logger = logging.getLogger(__name__)
@@ -57,6 +60,16 @@ class CreateCheckoutResponse(BaseModel):
     message: str
 
 
+class DoneForYouCheckoutRequest(BaseModel):
+    """Request to create a done-for-you karaoke video order."""
+    email: EmailStr
+    artist: str
+    title: str
+    source_type: str = "search"  # search, youtube, or upload
+    youtube_url: Optional[str] = None
+    notes: Optional[str] = None
+
+
 class CreditPackage(BaseModel):
     """Credit package information."""
     id: str
@@ -327,10 +340,459 @@ async def create_checkout(
     )
 
 
+@router.post("/done-for-you/checkout", response_model=CreateCheckoutResponse)
+async def create_done_for_you_checkout(
+    request: DoneForYouCheckoutRequest,
+    stripe_service: StripeService = Depends(get_stripe_service),
+):
+    """
+    Create a Stripe checkout session for a done-for-you karaoke video order.
+
+    This is the full-service option where Nomad Karaoke handles everything:
+    - Finding or processing the audio
+    - Reviewing and correcting lyrics
+    - Selecting the best instrumental
+    - Generating the final video
+
+    $15 with 24-hour delivery guarantee.
+    No authentication required - customer email is provided in the request.
+    """
+    if not stripe_service.is_configured():
+        raise HTTPException(status_code=503, detail="Payment processing is not available")
+
+    success, checkout_url, message = stripe_service.create_done_for_you_checkout_session(
+        customer_email=request.email,
+        artist=request.artist,
+        title=request.title,
+        source_type=request.source_type,
+        youtube_url=request.youtube_url,
+        notes=request.notes,
+    )
+
+    if not success or not checkout_url:
+        raise HTTPException(status_code=400, detail=message)
+
+    return CreateCheckoutResponse(
+        status="success",
+        checkout_url=checkout_url,
+        message=message,
+    )
+
+
 # =============================================================================
 # Stripe Webhooks
 # =============================================================================
 
+# Admin email for done-for-you order notifications
+ADMIN_EMAIL = "andrew@nomadkaraoke.com"
+
+
+async def _handle_done_for_you_order(
+    session_id: str,
+    metadata: dict,
+    user_service: UserService,
+    email_service: EmailService,
+) -> None:
+    """
+    Handle a completed done-for-you order by creating a job and notifying Andrew.
+
+    For orders with a YouTube URL, the job is created and workers are triggered immediately.
+    For orders without a URL (search mode), the audio search flow is used to find and
+    download the best matching audio source automatically.
+
+    Args:
+        session_id: Stripe checkout session ID
+        metadata: Order metadata from Stripe session
+        user_service: User service for marking session processed
+        email_service: Email service for notifications
+    """
+    from backend.models.job import JobCreate, JobStatus
+    from backend.services.job_manager import JobManager
+    from backend.services.worker_service import get_worker_service
+    from backend.services.audio_search_service import (
+        get_audio_search_service,
+        NoResultsError,
+        AudioSearchError,
+    )
+    from backend.services.storage_service import StorageService
+    import asyncio
+    import tempfile
+    import os
+
+    customer_email = metadata.get("customer_email", "")
+    artist = metadata.get("artist", "Unknown Artist")
+    title = metadata.get("title", "Unknown Title")
+    source_type = metadata.get("source_type", "search")
+    youtube_url = metadata.get("youtube_url")
+    notes = metadata.get("notes", "")
+
+    logger.info(
+        f"Processing done-for-you order: {artist} - {title} for {customer_email} "
+        f"(session: {session_id}, source_type: {source_type})"
+    )
+
+    try:
+        job_manager = JobManager()
+        worker_service = get_worker_service()
+        storage_service = StorageService()
+
+        # Apply default theme (Nomad) - same as audio_search endpoint
+        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}' for done-for-you order")
+
+        # Create job for the customer
+        # Note: done-for-you jobs should NOT be non_interactive - Andrew needs to review
+        job_create = JobCreate(
+            url=youtube_url if youtube_url else None,
+            artist=artist,
+            title=title,
+            user_email=customer_email,  # Customer owns the job
+            theme_id=effective_theme_id,  # Apply default theme
+            non_interactive=False,  # Andrew will review lyrics/instrumental
+            # Set audio search fields for search-based orders
+            audio_search_artist=artist if not youtube_url else None,
+            audio_search_title=title if not youtube_url else None,
+            auto_download=True,  # Auto-select best audio source
+        )
+        job = job_manager.create_job(job_create)
+        job_id = job.job_id
+
+        logger.info(f"Created done-for-you job {job_id} for {customer_email}")
+
+        # Prepare theme style assets for the job (same as audio_search endpoint)
+        if effective_theme_id:
+            try:
+                style_params_path, theme_style_assets, youtube_desc = _prepare_theme_for_job(
+                    job_id, effective_theme_id, None  # No color overrides for done-for-you
+                )
+                theme_update = {
+                    'style_params_gcs_path': style_params_path,
+                    'style_assets': theme_style_assets,
+                }
+                if youtube_desc:
+                    theme_update['youtube_description_template'] = youtube_desc
+                job_manager.update_job(job_id, theme_update)
+                logger.info(f"Applied theme '{effective_theme_id}' to done-for-you job {job_id}")
+            except Exception as e:
+                logger.warning(f"Failed to prepare theme for done-for-you job {job_id}: {e}")
+
+        # Mark session as processed for idempotency
+        # Note: Using internal method since this isn't a credit transaction
+        user_service._mark_stripe_session_processed(
+            stripe_session_id=session_id,
+            email=customer_email,
+            amount=0  # No credits, just tracking the session
+        )
+
+        # Handle based on whether we have a YouTube URL or need to search
+        if youtube_url:
+            # URL provided - trigger workers directly
+            logger.info(f"Job {job_id}: YouTube URL provided, triggering workers")
+            await asyncio.gather(
+                worker_service.trigger_audio_worker(job_id),
+                worker_service.trigger_lyrics_worker(job_id)
+            )
+        else:
+            # No URL - use audio search flow with auto_download
+            logger.info(f"Job {job_id}: No URL, using audio search for '{artist} - {title}'")
+
+            # Update job with audio search fields
+            job_manager.update_job(job_id, {
+                'audio_search_artist': artist,
+                'audio_search_title': title,
+                'auto_download': True,
+            })
+
+            # Transition to searching state
+            job_manager.transition_to_state(
+                job_id=job_id,
+                new_status=JobStatus.SEARCHING_AUDIO,
+                progress=5,
+                message=f"Searching for audio: {artist} - {title}"
+            )
+
+            # Perform audio search
+            audio_search_service = get_audio_search_service()
+
+            try:
+                search_results = audio_search_service.search(artist, title)
+            except NoResultsError as e:
+                # No results found - transition to AWAITING_AUDIO_SELECTION so Andrew can handle manually
+                logger.warning(f"Job {job_id}: No audio sources found for '{artist} - {title}'")
+                job_manager.transition_to_state(
+                    job_id=job_id,
+                    new_status=JobStatus.AWAITING_AUDIO_SELECTION,
+                    progress=10,
+                    message=f"No automatic audio sources found. Manual intervention required."
+                )
+                # Don't fail the job - Andrew can manually provide audio
+                search_results = None
+            except AudioSearchError as e:
+                logger.error(f"Job {job_id}: Audio search failed: {e}")
+                job_manager.transition_to_state(
+                    job_id=job_id,
+                    new_status=JobStatus.AWAITING_AUDIO_SELECTION,
+                    progress=10,
+                    message=f"Audio search error. Manual intervention required."
+                )
+                search_results = None
+
+            if search_results:
+                # Store search results in state_data
+                results_dicts = [r.to_dict() for r in search_results]
+                state_data_update = {
+                    'audio_search_results': results_dicts,
+                    'audio_search_count': len(results_dicts),
+                }
+                if audio_search_service.last_remote_search_id:
+                    state_data_update['remote_search_id'] = audio_search_service.last_remote_search_id
+                job_manager.update_job(job_id, {'state_data': state_data_update})
+
+                # Auto-select best result and download
+                best_index = audio_search_service.select_best(search_results)
+                selected = results_dicts[best_index]
+
+                logger.info(f"Job {job_id}: Auto-selected result {best_index}: {selected.get('provider')} - {selected.get('title')}")
+
+                # Transition to downloading state
+                job_manager.transition_to_state(
+                    job_id=job_id,
+                    new_status=JobStatus.DOWNLOADING_AUDIO,
+                    progress=10,
+                    message=f"Downloading from {selected.get('provider')}: {selected.get('artist')} - {selected.get('title')}",
+                    state_data_updates={
+                        'selected_audio_index': best_index,
+                        'selected_audio_provider': selected.get('provider'),
+                    }
+                )
+
+                # Download audio
+                try:
+                    is_torrent_source = selected.get('provider') in ['RED', 'OPS']
+                    is_remote_enabled = audio_search_service.is_remote_enabled()
+                    source_id = selected.get('source_id')
+                    source_name = selected.get('provider')
+                    target_file = selected.get('target_file')
+                    download_url = selected.get('url')
+                    remote_search_id = state_data_update.get('remote_search_id')
+
+                    if is_torrent_source and is_remote_enabled:
+                        # Remote torrent download - upload directly to GCS
+                        gcs_destination = f"uploads/{job_id}/audio/"
+
+                        if source_id and source_name:
+                            result = audio_search_service.download_by_id(
+                                source_name=source_name,
+                                source_id=source_id,
+                                output_dir="",
+                                target_file=target_file,
+                                download_url=download_url,
+                                gcs_path=gcs_destination,
+                            )
+                        else:
+                            result = audio_search_service.download(
+                                result_index=best_index,
+                                output_dir="",
+                                gcs_path=gcs_destination,
+                                remote_search_id=remote_search_id,
+                            )
+
+                        # Extract GCS path
+                        if result.filepath.startswith("gs://"):
+                            parts = result.filepath.replace("gs://", "").split("/", 1)
+                            audio_gcs_path = parts[1] if len(parts) == 2 else result.filepath
+                            filename = os.path.basename(result.filepath)
+                        else:
+                            filename = os.path.basename(result.filepath)
+                            audio_gcs_path = f"uploads/{job_id}/audio/{filename}"
+                    else:
+                        # Local download (YouTube or local torrent)
+                        temp_dir = tempfile.mkdtemp(prefix=f"audio_download_{job_id}_")
+                        import shutil
+
+                        try:
+                            if source_id and source_name and is_remote_enabled:
+                                result = audio_search_service.download_by_id(
+                                    source_name=source_name,
+                                    source_id=source_id,
+                                    output_dir=temp_dir,
+                                    target_file=target_file,
+                                    download_url=download_url,
+                                )
+                            elif source_name == 'YouTube' and download_url:
+                                # YouTube download
+                                from backend.workers.audio_worker import download_from_url
+                                local_path = await download_from_url(
+                                    download_url,
+                                    temp_dir,
+                                    selected.get('artist'),
+                                    selected.get('title')
+                                )
+                                if not local_path or not os.path.exists(local_path):
+                                    raise Exception(f"Failed to download from YouTube: {download_url}")
+
+                                class DownloadResult:
+                                    def __init__(self, filepath):
+                                        self.filepath = filepath
+                                result = DownloadResult(local_path)
+                            else:
+                                result = audio_search_service.download(
+                                    result_index=best_index,
+                                    output_dir=temp_dir,
+                                    remote_search_id=remote_search_id,
+                                )
+
+                            # Upload to GCS
+                            filename = os.path.basename(result.filepath)
+                            audio_gcs_path = f"uploads/{job_id}/audio/{filename}"
+
+                            with open(result.filepath, 'rb') as f:
+                                storage_service.upload_fileobj(f, audio_gcs_path, content_type='audio/flac')
+                        finally:
+                            # Always cleanup temp directory
+                            shutil.rmtree(temp_dir, ignore_errors=True)
+
+                    # Update job with GCS path
+                    job_manager.update_job(job_id, {
+                        'input_media_gcs_path': audio_gcs_path,
+                        'filename': filename,
+                    })
+
+                    # Transition to DOWNLOADING and trigger workers
+                    job_manager.transition_to_state(
+                        job_id=job_id,
+                        new_status=JobStatus.DOWNLOADING,
+                        progress=15,
+                        message="Audio downloaded, starting processing"
+                    )
+
+                    # Trigger workers
+                    await asyncio.gather(
+                        worker_service.trigger_audio_worker(job_id),
+                        worker_service.trigger_lyrics_worker(job_id)
+                    )
+
+                    logger.info(f"Job {job_id}: Audio downloaded and workers triggered")
+
+                except Exception as download_error:
+                    logger.error(f"Job {job_id}: Audio download failed: {download_error}")
+                    # Don't fail job - transition to awaiting selection so Andrew can handle
+                    job_manager.transition_to_state(
+                        job_id=job_id,
+                        new_status=JobStatus.AWAITING_AUDIO_SELECTION,
+                        progress=10,
+                        message=f"Auto-download failed: {download_error}. Manual intervention required."
+                    )
+
+        # Send confirmation email to customer
+        email_service.send_email(
+            to_email=customer_email,
+            subject=f"Your Karaoke Video Order: {artist} - {title}",
+            html_content=f"""
+            <h2>Thank you for your order!</h2>
+            <p>We've received your request for a karaoke video:</p>
+            <ul>
+                <li><strong>Artist:</strong> {artist}</li>
+                <li><strong>Title:</strong> {title}</li>
+                {f'<li><strong>Notes:</strong> {notes}</li>' if notes else ''}
+            </ul>
+            <p>Our team will review and create your video within <strong>24 hours</strong>.</p>
+            <p>You'll receive another email with download links when your video is ready.</p>
+            <p>If you have any questions, reply to this email or contact us at support@nomadkaraoke.com</p>
+            <p>Thanks for using Nomad Karaoke!</p>
+            """,
+            text_content=f"""
+Thank you for your order!
+
+We've received your request for a karaoke video:
+- Artist: {artist}
+- Title: {title}
+{f'- Notes: {notes}' if notes else ''}
+
+Our team will review and create your video within 24 hours.
+You'll receive another email with download links when your video is ready.
+
+If you have any questions, reply to this email or contact us at support@nomadkaraoke.com
+
+Thanks for using Nomad Karaoke!
+            """.strip(),
+        )
+
+        # Send notification email to Andrew
+        email_service.send_email(
+            to_email=ADMIN_EMAIL,
+            subject=f"[Done For You Order] {artist} - {title}",
+            html_content=f"""
+            <h2>New Done-For-You Order</h2>
+            <p>A customer has ordered a karaoke video:</p>
+            <ul>
+                <li><strong>Customer:</strong> {customer_email}</li>
+                <li><strong>Artist:</strong> {artist}</li>
+                <li><strong>Title:</strong> {title}</li>
+                <li><strong>Source:</strong> {source_type}</li>
+                {f'<li><strong>YouTube URL:</strong> <a href="{youtube_url}">{youtube_url}</a></li>' if youtube_url else ''}
+                {f'<li><strong>Notes:</strong> {notes}</li>' if notes else ''}
+            </ul>
+            <p><strong>Job ID:</strong> {job_id}</p>
+            <p>View job in admin: <a href="https://gen.nomadkaraoke.com/admin/jobs/{job_id}">Admin Link</a></p>
+            <p>View job as customer: <a href="https://gen.nomadkaraoke.com/jobs/{job_id}">Customer Link</a></p>
+            <p><strong>Deadline:</strong> 24 hours from now</p>
+            """,
+            text_content=f"""
+New Done-For-You Order
+
+Customer: {customer_email}
+Artist: {artist}
+Title: {title}
+Source: {source_type}
+{f'YouTube URL: {youtube_url}' if youtube_url else ''}
+{f'Notes: {notes}' if notes else ''}
+
+Job ID: {job_id}
+Admin: https://gen.nomadkaraoke.com/admin/jobs/{job_id}
+Customer: https://gen.nomadkaraoke.com/jobs/{job_id}
+
+Deadline: 24 hours from now
+            """.strip(),
+        )
+
+        logger.info(f"Sent done-for-you order notifications for job {job_id}")
+
+    except Exception as e:
+        logger.error(f"Error processing done-for-you order: {e}", exc_info=True)
+        # Still try to notify Andrew of the failure
+        try:
+            email_service.send_email(
+                to_email=ADMIN_EMAIL,
+                subject=f"[FAILED] Done For You Order: {artist} - {title}",
+                html_content=f"""
+                <h2>Done-For-You Order Failed</h2>
+                <p>An error occurred processing this order:</p>
+                <ul>
+                    <li><strong>Customer:</strong> {customer_email}</li>
+                    <li><strong>Artist:</strong> {artist}</li>
+                    <li><strong>Title:</strong> {title}</li>
+                    <li><strong>Error:</strong> {str(e)}</li>
+                </ul>
+                <p>Please manually create this job and notify the customer.</p>
+                """,
+                text_content=f"""
+Done-For-You Order Failed
+
+Customer: {customer_email}
+Artist: {artist}
+Title: {title}
+Error: {str(e)}
+
+Please manually create this job and notify the customer.
+                """.strip(),
+            )
+        except Exception as email_error:
+            logger.error(f"Failed to send error notification: {email_error}")
+
+
 @router.post("/webhooks/stripe")
 async def stripe_webhook(
     request: Request,
@@ -365,30 +827,41 @@ async def stripe_webhook(
     if event_type == "checkout.session.completed":
         session = event["data"]["object"]
         session_id = session.get("id")
+        metadata = session.get("metadata", {})
 
         # Idempotency check: Skip if this session was already processed
         if session_id and user_service.is_stripe_session_processed(session_id):
             logger.info(f"Skipping already processed session: {session_id}")
             return {"status": "received", "type": event_type, "note": "already_processed"}
 
-        # Process the completed checkout
-        success, user_email, credits, _ = stripe_service.handle_checkout_completed(session)
-
-        if success and user_email and credits > 0:
-            # Add credits to user account
-            ok, new_balance, credit_msg = user_service.add_credits(
-                email=user_email,
-                amount=credits,
-                reason="stripe_purchase",
-                stripe_session_id=session_id,
+        # Check if this is a done-for-you order
+        if metadata.get("order_type") == "done_for_you":
+            # Handle done-for-you order - create a job
+            await _handle_done_for_you_order(
+                session_id=session_id,
+                metadata=metadata,
+                user_service=user_service,
+                email_service=email_service,
             )
-
-            if ok:
-                # Send confirmation email
-                email_service.send_credits_added(user_email, credits, new_balance)
-                logger.info(f"Added {credits} credits to {user_email}, new balance: {new_balance}")
-            else:
-                logger.error(f"Failed to add credits: {credit_msg}")
+        else:
+            # Handle regular credit purchase
+            success, user_email, credits, _ = stripe_service.handle_checkout_completed(session)
+
+            if success and user_email and credits > 0:
+                # Add credits to user account
+                ok, new_balance, credit_msg = user_service.add_credits(
+                    email=user_email,
+                    amount=credits,
+                    reason="stripe_purchase",
+                    stripe_session_id=session_id,
+                )
+
+                if ok:
+                    # Send confirmation email
+                    email_service.send_credits_added(user_email, credits, new_balance)
+                    logger.info(f"Added {credits} credits to {user_email}, new balance: {new_balance}")
+                else:
+                    logger.error(f"Failed to add credits: {credit_msg}")
 
     elif event_type == "checkout.session.expired":
         logger.info(f"Checkout session expired: {event['data']['object'].get('id')}")
@@ -663,6 +1136,7 @@ async def list_users(
     sort_by: str = "created_at",
     sort_order: str = "desc",
     include_inactive: bool = False,
+    exclude_test: bool = True,
     auth_data: Tuple[str, UserType, int] = Depends(require_admin),
     user_service: UserService = Depends(get_user_service),
 ):
@@ -676,6 +1150,7 @@ async def list_users(
         sort_by: Field to sort by (created_at, last_login_at, credits, email)
         sort_order: Sort direction (asc, desc)
         include_inactive: Include disabled users
+        exclude_test: If True (default), exclude test users (e.g., @inbox.testmail.app)
     """
     from google.cloud import firestore
     from google.cloud.firestore_v1 import FieldFilter
@@ -704,9 +1179,14 @@ async def list_users(
     else:
         query = query.order_by("created_at", direction=direction)
 
-    # Get total count (without pagination) for has_more calculation
+    # Get all docs and filter in Python
     # Note: This is expensive for large datasets, consider caching
     all_docs = list(query.stream())
+
+    # Filter out test users if exclude_test is True
+    if exclude_test:
+        all_docs = [d for d in all_docs if not is_test_email(d.to_dict().get('email', ''))]
+
     total_count = len(all_docs)
 
     # Apply pagination manually (Firestore doesn't support offset well)
@@ -942,44 +1422,64 @@ async def list_beta_feedback(
 
 @router.get("/admin/beta/stats")
 async def get_beta_stats(
+    exclude_test: bool = True,
     auth_data: Tuple[str, UserType, int] = Depends(require_admin),
     user_service: UserService = Depends(get_user_service),
 ):
     """
     Get beta tester program statistics (admin only).
+
+    Args:
+        exclude_test: If True (default), exclude test users from beta stats
     """
     from google.cloud.firestore_v1 import FieldFilter
     from google.cloud.firestore_v1 import aggregation
 
-    # Count beta testers by status using efficient aggregation queries
     users_collection = user_service.db.collection(USERS_COLLECTION)
 
-    # Helper function to get count using aggregation
-    def get_count(query) -> int:
-        agg_query = aggregation.AggregationQuery(query)
-        agg_query.count(alias="count")
-        results = agg_query.get()
-        return results[0][0].value if results else 0
-
-    total_beta_testers = get_count(
-        users_collection.where(filter=FieldFilter("is_beta_tester", "==", True))
-    )
-
-    active_testers = get_count(
-        users_collection.where(filter=FieldFilter("beta_tester_status", "==", "active"))
-    )
+    if exclude_test:
+        # Stream and filter in Python since Firestore doesn't support "not ends with"
+        all_beta_users = []
+        for doc in users_collection.where(filter=FieldFilter("is_beta_tester", "==", True)).stream():
+            data = doc.to_dict()
+            if not is_test_email(data.get("email", "")):
+                all_beta_users.append(data)
 
-    pending_feedback = get_count(
-        users_collection.where(filter=FieldFilter("beta_tester_status", "==", "pending_feedback"))
-    )
+        total_beta_testers = len(all_beta_users)
+        active_testers = sum(1 for u in all_beta_users if u.get("beta_tester_status") == "active")
+        pending_feedback = sum(1 for u in all_beta_users if u.get("beta_tester_status") == "pending_feedback")
+        completed_feedback = sum(1 for u in all_beta_users if u.get("beta_tester_status") == "completed")
 
-    completed_feedback = get_count(
-        users_collection.where(filter=FieldFilter("beta_tester_status", "==", "completed"))
-    )
-
-    # Get average ratings from feedback
-    feedback_docs = list(user_service.db.collection("beta_feedback").stream())
+        # Filter feedback by non-test users
+        all_feedback = []
+        for doc in user_service.db.collection("beta_feedback").stream():
+            data = doc.to_dict()
+            if not is_test_email(data.get("user_email", "")):
+                all_feedback.append(data)
+        feedback_docs = all_feedback
+    else:
+        # Use efficient aggregation queries when including test data
+        def get_count(query) -> int:
+            agg_query = aggregation.AggregationQuery(query)
+            agg_query.count(alias="count")
+            results = agg_query.get()
+            return results[0][0].value if results else 0
+
+        total_beta_testers = get_count(
+            users_collection.where(filter=FieldFilter("is_beta_tester", "==", True))
+        )
+        active_testers = get_count(
+            users_collection.where(filter=FieldFilter("beta_tester_status", "==", "active"))
+        )
+        pending_feedback = get_count(
+            users_collection.where(filter=FieldFilter("beta_tester_status", "==", "pending_feedback"))
+        )
+        completed_feedback = get_count(
+            users_collection.where(filter=FieldFilter("beta_tester_status", "==", "completed"))
+        )
+        feedback_docs = [doc.to_dict() for doc in user_service.db.collection("beta_feedback").stream()]
 
+    # Calculate average ratings from feedback
     avg_overall = 0
     avg_ease = 0
     avg_accuracy = 0
@@ -987,8 +1487,7 @@ async def get_beta_stats(
 
     if feedback_docs:
         total = len(feedback_docs)
-        for doc in feedback_docs:
-            data = doc.to_dict()
+        for data in feedback_docs:
             avg_overall += data.get("overall_rating", 0)
             avg_ease += data.get("ease_of_use_rating", 0)
             avg_accuracy += data.get("lyrics_accuracy_rating", 0)