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

backend/services/langfuse_preloader.py

@@ -0,0 +1,98 @@
+"""Langfuse callback handler preloader for container startup.
+
+Initializes the Langfuse callback handler at container startup to avoid
+slow initialization during request processing. The CallbackHandler()
+constructor makes blocking network calls to the Langfuse API, which can
+take 3+ minutes on Cloud Run cold starts.
+
+See docs/archive/2026-01-08-performance-investigation.md for background.
+"""
+
+import logging
+import os
+import time
+from typing import Optional, Any
+
+logger = logging.getLogger(__name__)
+
+# Singleton storage for preloaded handler
+_preloaded_handler: Optional[Any] = None
+_initialization_attempted: bool = False
+
+
+def preload_langfuse_handler() -> Optional[Any]:
+    """Preload Langfuse callback handler at startup.
+
+    Only initializes if LANGFUSE_PUBLIC_KEY and LANGFUSE_SECRET_KEY
+    environment variables are set.
+
+    Returns:
+        The preloaded CallbackHandler, or None if not configured
+    """
+    global _preloaded_handler, _initialization_attempted
+
+    if _initialization_attempted:
+        logger.debug("Langfuse initialization already attempted")
+        return _preloaded_handler
+
+    _initialization_attempted = True
+
+    # Check if Langfuse is configured
+    public_key = os.getenv("LANGFUSE_PUBLIC_KEY")
+    secret_key = os.getenv("LANGFUSE_SECRET_KEY")
+
+    if not (public_key and secret_key):
+        logger.info("Langfuse not configured (missing keys), skipping preload")
+        return None
+
+    logger.info("Preloading Langfuse callback handler...")
+    start_time = time.time()
+
+    try:
+        from langfuse.langchain import CallbackHandler
+
+        # Initialize the handler - this is the slow part that makes network calls
+        _preloaded_handler = CallbackHandler()
+
+        elapsed = time.time() - start_time
+        host = os.getenv("LANGFUSE_HOST", "cloud.langfuse.com")
+        logger.info(f"Langfuse handler preloaded in {elapsed:.2f}s (host: {host})")
+
+        return _preloaded_handler
+
+    except ImportError:
+        logger.warning("langfuse package not installed, skipping preload")
+        return None
+    except Exception as e:
+        elapsed = time.time() - start_time
+        logger.error(f"Failed to preload Langfuse handler after {elapsed:.2f}s: {e}")
+        # Don't raise - Langfuse is optional
+        return None
+
+
+def get_preloaded_langfuse_handler() -> Optional[Any]:
+    """Get the preloaded Langfuse callback handler if available.
+
+    Returns:
+        The preloaded CallbackHandler, or None if not preloaded/configured
+    """
+    return _preloaded_handler
+
+
+def is_langfuse_preloaded() -> bool:
+    """Check if Langfuse handler has been preloaded."""
+    return _preloaded_handler is not None
+
+
+def is_langfuse_configured() -> bool:
+    """Check if Langfuse environment variables are configured."""
+    return bool(
+        os.getenv("LANGFUSE_PUBLIC_KEY") and os.getenv("LANGFUSE_SECRET_KEY")
+    )
+
+
+def clear_preloaded_handler() -> None:
+    """Clear preloaded handler. Useful for testing."""
+    global _preloaded_handler, _initialization_attempted
+    _preloaded_handler = None
+    _initialization_attempted = False

backend/services/nltk_preloader.py

@@ -0,0 +1,122 @@
+"""NLTK resource preloader for container startup.
+
+Loads NLTK data at container startup to avoid slow downloads during request processing.
+Cloud Run's ephemeral filesystem means NLTK data must be re-downloaded on each cold start,
+which can take 30-100+ seconds for cmudict.
+
+See docs/archive/2026-01-08-performance-investigation.md for background.
+"""
+
+import logging
+import time
+from typing import Optional, Dict, Any
+
+logger = logging.getLogger(__name__)
+
+# Singleton storage for preloaded resources
+_preloaded_resources: Dict[str, Any] = {}
+
+
+def preload_nltk_cmudict() -> None:
+    """Preload NLTK's CMU Pronouncing Dictionary at startup.
+
+    The cmudict is used by SyllablesMatchHandler for syllable counting.
+    Without preloading, each SyllablesMatchHandler init downloads ~30MB,
+    which took 50-100+ seconds in Cloud Run.
+    """
+    global _preloaded_resources
+
+    if "cmudict" in _preloaded_resources:
+        logger.info("NLTK cmudict already preloaded")
+        return
+
+    logger.info("Preloading NLTK cmudict...")
+    start_time = time.time()
+
+    try:
+        import nltk
+
+        # Ensure the data is downloaded
+        try:
+            from nltk.corpus import cmudict
+
+            # Try to access it - will raise LookupError if not downloaded
+            _ = cmudict.dict()
+        except LookupError:
+            logger.info("Downloading NLTK cmudict data...")
+            nltk.download("cmudict", quiet=True)
+            from nltk.corpus import cmudict
+
+        # Load into memory
+        cmu_dict = cmudict.dict()
+        _preloaded_resources["cmudict"] = cmu_dict
+
+        elapsed = time.time() - start_time
+        logger.info(f"NLTK cmudict preloaded in {elapsed:.2f}s ({len(cmu_dict)} entries)")
+
+    except Exception as e:
+        logger.error(f"Failed to preload NLTK cmudict: {e}")
+        raise
+
+
+def get_preloaded_cmudict() -> Optional[Dict]:
+    """Get the preloaded CMU dictionary if available.
+
+    Returns:
+        The preloaded cmudict dictionary, or None if not preloaded
+    """
+    return _preloaded_resources.get("cmudict")
+
+
+def is_cmudict_preloaded() -> bool:
+    """Check if cmudict has been preloaded."""
+    return "cmudict" in _preloaded_resources
+
+
+def preload_nltk_punkt() -> None:
+    """Preload NLTK's punkt tokenizer (optional, used for sentence tokenization)."""
+    global _preloaded_resources
+
+    if "punkt" in _preloaded_resources:
+        logger.info("NLTK punkt already preloaded")
+        return
+
+    logger.info("Preloading NLTK punkt tokenizer...")
+    start_time = time.time()
+
+    try:
+        import nltk
+
+        try:
+            from nltk.tokenize import word_tokenize
+
+            # Test it works
+            _ = word_tokenize("test")
+        except LookupError:
+            logger.info("Downloading NLTK punkt data...")
+            nltk.download("punkt", quiet=True)
+            nltk.download("punkt_tab", quiet=True)
+
+        _preloaded_resources["punkt"] = True
+
+        elapsed = time.time() - start_time
+        logger.info(f"NLTK punkt preloaded in {elapsed:.2f}s")
+
+    except Exception as e:
+        logger.warning(f"Failed to preload NLTK punkt (non-critical): {e}")
+
+
+def preload_all_nltk_resources() -> None:
+    """Preload all NLTK resources used by the application."""
+    preload_nltk_cmudict()
+    # punkt is optional and less critical
+    try:
+        preload_nltk_punkt()
+    except Exception:
+        pass  # Non-critical
+
+
+def clear_preloaded_resources() -> None:
+    """Clear all preloaded resources. Useful for testing."""
+    global _preloaded_resources
+    _preloaded_resources.clear()

backend/services/spacy_preloader.py

@@ -0,0 +1,65 @@
+"""SpaCy model preloader for container startup.
+
+Loads SpaCy models at container startup to avoid slow loading during request processing.
+Cloud Run filesystem I/O can cause 60+ second delays when loading SpaCy models lazily.
+"""
+
+import logging
+import time
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+# Singleton storage for preloaded models
+_preloaded_models: dict = {}
+
+
+def preload_spacy_model(model_name: str = "en_core_web_sm") -> None:
+    """Preload a SpaCy model at startup.
+
+    Args:
+        model_name: The SpaCy model to load (default: en_core_web_sm)
+    """
+    global _preloaded_models
+
+    if model_name in _preloaded_models:
+        logger.info(f"SpaCy model '{model_name}' already preloaded")
+        return
+
+    logger.info(f"Preloading SpaCy model '{model_name}'...")
+    start_time = time.time()
+
+    try:
+        import spacy
+
+        nlp = spacy.load(model_name)
+        _preloaded_models[model_name] = nlp
+
+        elapsed = time.time() - start_time
+        logger.info(f"SpaCy model '{model_name}' preloaded in {elapsed:.2f}s")
+    except Exception as e:
+        logger.error(f"Failed to preload SpaCy model '{model_name}': {e}")
+        raise
+
+
+def get_preloaded_model(model_name: str = "en_core_web_sm") -> Optional[object]:
+    """Get a preloaded SpaCy model if available.
+
+    Args:
+        model_name: The SpaCy model name
+
+    Returns:
+        The preloaded SpaCy Language object, or None if not preloaded
+    """
+    return _preloaded_models.get(model_name)
+
+
+def is_model_preloaded(model_name: str = "en_core_web_sm") -> bool:
+    """Check if a SpaCy model has been preloaded."""
+    return model_name in _preloaded_models
+
+
+def clear_preloaded_models() -> None:
+    """Clear all preloaded models. Useful for testing."""
+    global _preloaded_models
+    _preloaded_models.clear()

backend/services/stripe_service.py

@@ -46,6 +46,14 @@ CREDIT_PACKAGES = {
     },
 }
 
+# Made-for-you service package (not a credit package - creates a job directly)
+MADE_FOR_YOU_PACKAGE = {
+    "price_cents": 1500,  # $15.00
+    "name": "Made For You Karaoke Video",
+    "description": "Professional 4K karaoke video with perfectly synced lyrics, delivered to your email within 24 hours",
+    "images": ["https://gen.nomadkaraoke.com/nomad-logo.png"],
+}
+
 
 class StripeService:
     """Service for Stripe payment processing."""
@@ -58,6 +66,10 @@ class StripeService:
         self.frontend_url = os.getenv("FRONTEND_URL", "https://gen.nomadkaraoke.com")
         # After consolidation, buy URL is the same as frontend URL
         self.buy_url = os.getenv("BUY_URL", self.frontend_url)
+        # Payment method configuration ID from Stripe Dashboard
+        # Enables Google Pay, Apple Pay, Link, and other wallet methods
+        # Get this from: Dashboard > Settings > Payment methods > [Your Config] > Copy ID
+        self.payment_method_config = os.getenv("STRIPE_PAYMENT_METHOD_CONFIG")
 
         if self.secret_key:
             stripe.api_key = self.secret_key
@@ -65,6 +77,11 @@ class StripeService:
         else:
             logger.warning("STRIPE_SECRET_KEY not set - payments disabled")
 
+        if self.payment_method_config:
+            logger.info(f"Using payment method config: {self.payment_method_config}")
+        else:
+            logger.info("No STRIPE_PAYMENT_METHOD_CONFIG set - using Stripe defaults")
+
     def is_configured(self) -> bool:
         """Check if Stripe is properly configured."""
         return bool(self.secret_key)
@@ -106,32 +123,40 @@ class StripeService:
             if not cancel_url:
                 cancel_url = f"{self.buy_url}?cancelled=true"
 
-            # Create checkout session
-            session = stripe.checkout.Session.create(
-                payment_method_types=['card'],
-                line_items=[{
+            # Build checkout session params
+            session_params = {
+                # Omit payment_method_types to auto-enable Apple Pay, Google Pay, Link, etc.
+                'line_items': [{
                     'price_data': {
                         'currency': 'usd',
                         'product_data': {
                             'name': package['name'],
                             'description': package['description'],
+                            'images': ['https://gen.nomadkaraoke.com/nomad-logo.png'],
                         },
                         'unit_amount': package['price_cents'],
                     },
                     'quantity': 1,
                 }],
-                mode='payment',
-                success_url=success_url,
-                cancel_url=cancel_url,
-                customer_email=user_email,
-                metadata={
+                'mode': 'payment',
+                'success_url': success_url,
+                'cancel_url': cancel_url,
+                'customer_email': user_email,
+                'metadata': {
                     'package_id': package_id,
                     'credits': str(package['credits']),
                     'user_email': user_email,
                 },
                 # Allow promotion codes
-                allow_promotion_codes=True,
-            )
+                'allow_promotion_codes': True,
+            }
+
+            # Add payment method configuration if set (enables Google Pay, Link, etc.)
+            if self.payment_method_config:
+                session_params['payment_method_configuration'] = self.payment_method_config
+
+            # Create checkout session
+            session = stripe.checkout.Session.create(**session_params)
 
             logger.info(f"Created checkout session {session.id} for {user_email}, package {package_id}")
             return True, session.url, "Checkout session created"
@@ -143,6 +168,103 @@ class StripeService:
             logger.error(f"Error creating checkout session: {e}")
             return False, None, "Failed to create checkout session"
 
+    def create_made_for_you_checkout_session(
+        self,
+        customer_email: str,
+        artist: str,
+        title: str,
+        source_type: str = "search",
+        youtube_url: Optional[str] = None,
+        notes: Optional[str] = None,
+        success_url: Optional[str] = None,
+        cancel_url: Optional[str] = None,
+    ) -> Tuple[bool, Optional[str], str]:
+        """
+        Create a Stripe Checkout session for a made-for-you order.
+
+        This is for the full-service karaoke video creation where Nomad Karaoke
+        handles all the work (lyrics review, instrumental selection, etc.).
+
+        Args:
+            customer_email: Customer's email for delivery
+            artist: Song artist
+            title: Song title
+            source_type: Audio source type (search, youtube, upload)
+            youtube_url: YouTube URL if source_type is youtube
+            notes: Any special requests from customer
+            success_url: URL to redirect to on success (optional)
+            cancel_url: URL to redirect to on cancel (optional)
+
+        Returns:
+            (success, checkout_url, message)
+        """
+        if not self.is_configured():
+            return False, None, "Payment processing is not configured"
+
+        try:
+            # Default URLs - redirect to homepage success page
+            if not success_url:
+                success_url = "https://nomadkaraoke.com/order/success/?session_id={CHECKOUT_SESSION_ID}"
+            if not cancel_url:
+                cancel_url = "https://nomadkaraoke.com/#do-it-for-me"
+
+            # Build metadata for job creation after payment
+            metadata = {
+                'order_type': 'made_for_you',
+                'customer_email': customer_email,
+                'artist': artist,
+                'title': title,
+                'source_type': source_type,
+            }
+            if youtube_url:
+                metadata['youtube_url'] = youtube_url
+            if notes:
+                # Truncate notes to fit Stripe's 500 char limit per metadata value
+                metadata['notes'] = notes[:500] if len(notes) > 500 else notes
+
+            # Build checkout session params
+            session_params = {
+                # Omit payment_method_types to auto-enable Apple Pay, Google Pay, Link, etc.
+                'line_items': [{
+                    'price_data': {
+                        'currency': 'usd',
+                        'product_data': {
+                            'name': f"Karaoke Video: {artist} - {title}",
+                            'description': MADE_FOR_YOU_PACKAGE['description'],
+                            'images': MADE_FOR_YOU_PACKAGE['images'],
+                        },
+                        'unit_amount': MADE_FOR_YOU_PACKAGE['price_cents'],
+                    },
+                    'quantity': 1,
+                }],
+                'mode': 'payment',
+                'success_url': success_url,
+                'cancel_url': cancel_url,
+                'customer_email': customer_email,
+                'metadata': metadata,
+                'allow_promotion_codes': True,
+            }
+
+            # Add payment method configuration if set (enables Google Pay, Link, etc.)
+            if self.payment_method_config:
+                session_params['payment_method_configuration'] = self.payment_method_config
+
+            # Create checkout session
+            session = stripe.checkout.Session.create(**session_params)
+
+            logger.info(
+                f"Created made-for-you checkout session {session.id} for {customer_email}, "
+                f"song: {artist} - {title}"
+            )
+            return True, session.url, "Checkout session created"
+
+        except stripe.error.StripeError as e:
+            logger.error(f"Stripe error creating made-for-you checkout session: {e}")
+            return False, None, f"Payment error: {str(e)}"
+        except Exception as e:
+            logger.error(f"Error creating made-for-you checkout session: {e}")
+            return False, None, "Failed to create checkout session"
+
     def verify_webhook_signature(self, payload: bytes, signature: str) -> Tuple[bool, Optional[Dict], str]:
         """
         Verify a Stripe webhook signature.