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

backend/api/routes/users.py

@@ -858,8 +858,19 @@ async def enroll_beta_tester(
             detail="Access denied from this location"
         )
 
-    # 3. Check IP-based enrollment rate limit (1 per 24h per IP)
-    if ip_address:
+    # 3. Check for E2E test bypass (allows automated testing to skip IP rate limit)
+    from backend.config import settings
+    e2e_bypass_key = http_request.headers.get("X-E2E-Bypass-Key")
+    skip_ip_rate_limit = False
+    if e2e_bypass_key and settings.e2e_bypass_key:
+        if e2e_bypass_key == settings.e2e_bypass_key:
+            logger.info(f"Beta enrollment: E2E bypass key validated for {_mask_email(email)}")
+            skip_ip_rate_limit = True
+        else:
+            logger.warning(f"Beta enrollment: Invalid E2E bypass key attempted for {_mask_email(email)}")
+
+    # 4. Check IP-based enrollment rate limit (1 per 24h per IP)
+    if ip_address and not skip_ip_rate_limit:
         allowed, remaining, message = rate_limit_service.check_beta_ip_limit(ip_address)
         if not allowed:
             logger.warning(f"Beta enrollment rejected - IP rate limit: {ip_address} - {message}")
@@ -868,7 +879,7 @@ async def enroll_beta_tester(
                 detail="Too many beta enrollments from your location. Please try again tomorrow."
             )
 
-    # 4. Check for duplicate enrollment via normalized email
+    # 5. Check for duplicate enrollment via normalized email
     normalized_email = email_validation.normalize_email(email)
     if normalized_email != email:
         # Check if normalized version is already enrolled

backend/config.py

@@ -111,6 +111,9 @@ class Settings(BaseSettings):
     rate_limit_youtube_uploads_per_day: int = int(os.getenv("RATE_LIMIT_YOUTUBE_UPLOADS_PER_DAY", "10"))
     # Maximum beta enrollments from same IP per day (0 = unlimited)
     rate_limit_beta_ip_per_day: int = int(os.getenv("RATE_LIMIT_BETA_IP_PER_DAY", "1"))
+
+    # E2E test bypass key for rate limiting (set via secret in production)
+    e2e_bypass_key: str = os.getenv("E2E_BYPASS_KEY", "")
     default_youtube_description: str = os.getenv(
         "DEFAULT_YOUTUBE_DESCRIPTION",
         "Karaoke video created with Nomad Karaoke (https://nomadkaraoke.com)\n\n"

backend/services/encoding_interface.py

@@ -40,6 +40,9 @@ class EncodingInput:
     # Output directory
     output_dir: str = ""
 
+    # Instrumental selection (clean, with_backing, or custom)
+    instrumental_selection: str = "clean"
+
     # Additional options
     options: Dict[str, Any] = field(default_factory=dict)
 
@@ -328,6 +331,7 @@ class GCEEncodingBackend(EncodingBackend):
                 "formats": ["mp4_4k_lossless", "mp4_4k_lossy", "mkv_4k", "mp4_720p"],
                 "artist": input_config.artist,
                 "title": input_config.title,
+                "instrumental_selection": input_config.instrumental_selection,
             }
 
             # Submit and wait for completion

backend/services/job_notification_service.py

@@ -53,30 +53,13 @@ class JobNotificationService:
 
     def _build_review_url(self, job_id: str, audio_hash: Optional[str] = None, review_token: Optional[str] = None) -> str:
         """Build the lyrics review URL for a job."""
-        import urllib.parse
-
-        review_ui_url = os.getenv("REVIEW_UI_URL", f"{self.frontend_url}/lyrics/")
-        base_api_url = f"{self.backend_url}/api/review/{job_id}"
-        encoded_api_url = urllib.parse.quote(base_api_url, safe='')
-
-        url = f"{review_ui_url}?baseApiUrl={encoded_api_url}"
-        if audio_hash:
-            url += f"&audioHash={urllib.parse.quote(audio_hash, safe='')}"
-        if review_token:
-            url += f"&reviewToken={urllib.parse.quote(review_token, safe='')}"
-        return url
+        # Use consolidated frontend route
+        return f"{self.frontend_url}/app/jobs/{job_id}/review"
 
     def _build_instrumental_url(self, job_id: str, instrumental_token: Optional[str] = None) -> str:
         """Build the instrumental selection URL for a job."""
-        base_api_url = f"{self.backend_url}/api/jobs/{job_id}"
-
-        import urllib.parse
-        encoded_api_url = urllib.parse.quote(base_api_url, safe='')
-
-        url = f"{self.frontend_url}/instrumental/?baseApiUrl={encoded_api_url}"
-        if instrumental_token:
-            url += f"&instrumentalToken={urllib.parse.quote(instrumental_token, safe='')}"
-        return url
+        # Use consolidated frontend route
+        return f"{self.frontend_url}/app/jobs/{job_id}/instrumental"
 
     async def send_job_completion_email(
         self,

backend/tests/test_job_notification_service.py

@@ -3,7 +3,6 @@ Unit tests for job notification service.
 """
 import pytest
 from unittest.mock import Mock, patch, AsyncMock
-import urllib.parse
 
 from backend.services.job_notification_service import (
     JobNotificationService,
@@ -20,82 +19,55 @@ class TestURLBuilding:
         """Test basic review URL building."""
         service = JobNotificationService()
         service.frontend_url = "https://gen.nomadkaraoke.com"
-        service.backend_url = "https://api.nomadkaraoke.com"
 
         url = service._build_review_url("job-123")
 
-        assert "gen.nomadkaraoke.com/lyrics/" in url
-        assert "baseApiUrl=" in url
-        # The API URL should be URL-encoded
-        assert urllib.parse.quote("https://api.nomadkaraoke.com/api/review/job-123", safe='') in url
+        assert url == "https://gen.nomadkaraoke.com/app/jobs/job-123/review"
 
-    def test_build_review_url_with_audio_hash(self):
-        """Test review URL with audio hash parameter."""
+    def test_build_review_url_ignores_legacy_params(self):
+        """Test review URL ignores legacy audio_hash and review_token params."""
         service = JobNotificationService()
         service.frontend_url = "https://gen.nomadkaraoke.com"
-        service.backend_url = "https://api.nomadkaraoke.com"
 
-        url = service._build_review_url("job-123", audio_hash="abc123")
+        # Legacy params are still accepted but not used in the URL
+        url = service._build_review_url("job-123", audio_hash="abc123", review_token="token456")
 
-        assert "audioHash=abc123" in url
+        # URL should be the simple consolidated route
+        assert url == "https://gen.nomadkaraoke.com/app/jobs/job-123/review"
+        # No query params
+        assert "?" not in url
 
-    def test_build_review_url_with_review_token(self):
-        """Test review URL with review token parameter."""
+    def test_build_review_url_preserves_job_id_characters(self):
+        """Test that job ID is used directly in URL path."""
         service = JobNotificationService()
         service.frontend_url = "https://gen.nomadkaraoke.com"
-        service.backend_url = "https://api.nomadkaraoke.com"
 
-        url = service._build_review_url("job-123", review_token="token456")
+        # Note: job IDs with slashes would be unusual in real usage
+        url = service._build_review_url("abc-def-123")
 
-        assert "reviewToken=token456" in url
-
-    def test_build_review_url_with_all_params(self):
-        """Test review URL with all parameters."""
-        service = JobNotificationService()
-        service.frontend_url = "https://gen.nomadkaraoke.com"
-        service.backend_url = "https://api.nomadkaraoke.com"
-
-        url = service._build_review_url(
-            "job-123",
-            audio_hash="hash789",
-            review_token="token456"
-        )
-
-        assert "baseApiUrl=" in url
-        assert "audioHash=hash789" in url
-        assert "reviewToken=token456" in url
-
-    def test_build_review_url_encodes_special_chars(self):
-        """Test that special characters in job ID are encoded."""
-        service = JobNotificationService()
-        service.frontend_url = "https://gen.nomadkaraoke.com"
-        service.backend_url = "https://api.nomadkaraoke.com"
-
-        url = service._build_review_url("job/with/slashes")
-
-        # The baseApiUrl parameter should have encoded slashes
-        assert "%2F" in url
+        assert url == "https://gen.nomadkaraoke.com/app/jobs/abc-def-123/review"
 
     def test_build_instrumental_url_basic(self):
         """Test basic instrumental URL building."""
         service = JobNotificationService()
         service.frontend_url = "https://gen.nomadkaraoke.com"
-        service.backend_url = "https://api.nomadkaraoke.com"
 
         url = service._build_instrumental_url("job-123")
 
-        assert "gen.nomadkaraoke.com/instrumental/" in url
-        assert "baseApiUrl=" in url
+        assert url == "https://gen.nomadkaraoke.com/app/jobs/job-123/instrumental"
 
-    def test_build_instrumental_url_with_token(self):
-        """Test instrumental URL with token parameter."""
+    def test_build_instrumental_url_ignores_legacy_params(self):
+        """Test instrumental URL ignores legacy instrumental_token param."""
         service = JobNotificationService()
         service.frontend_url = "https://gen.nomadkaraoke.com"
-        service.backend_url = "https://api.nomadkaraoke.com"
 
+        # Legacy param is still accepted but not used in the URL
         url = service._build_instrumental_url("job-123", instrumental_token="inst-token")
 
-        assert "instrumentalToken=inst-token" in url
+        # URL should be the simple consolidated route
+        assert url == "https://gen.nomadkaraoke.com/app/jobs/job-123/instrumental"
+        # No query params
+        assert "?" not in url
 
 
 class TestCompletionEmail:
@@ -325,7 +297,6 @@ class TestActionReminderEmail:
         """Test that lyrics reminder includes correct review URL."""
         service = JobNotificationService()
         service.frontend_url = "https://gen.nomadkaraoke.com"
-        service.backend_url = "https://api.nomadkaraoke.com"
         service.email_service = Mock()
         service.email_service.send_action_reminder.return_value = True
         service.template_service = Mock()
@@ -336,22 +307,18 @@ class TestActionReminderEmail:
                 job_id="job-123",
                 user_email="user@example.com",
                 action_type="lyrics",
-                audio_hash="hash123",
-                review_token="token456",
             )
 
         # Verify the review URL was passed to template
         call_kwargs = service.template_service.render_action_needed_lyrics.call_args.kwargs
         review_url = call_kwargs.get('review_url')
-        assert "audioHash=hash123" in review_url
-        assert "reviewToken=token456" in review_url
+        assert review_url == "https://gen.nomadkaraoke.com/app/jobs/job-123/review"
 
     @pytest.mark.asyncio
     async def test_send_instrumental_reminder_includes_url(self):
         """Test that instrumental reminder includes correct URL."""
         service = JobNotificationService()
         service.frontend_url = "https://gen.nomadkaraoke.com"
-        service.backend_url = "https://api.nomadkaraoke.com"
         service.email_service = Mock()
         service.email_service.send_action_reminder.return_value = True
         service.template_service = Mock()
@@ -362,13 +329,12 @@ class TestActionReminderEmail:
                 job_id="job-123",
                 user_email="user@example.com",
                 action_type="instrumental",
-                instrumental_token="inst-token",
             )
 
         # Verify the instrumental URL was passed to template
         call_kwargs = service.template_service.render_action_needed_instrumental.call_args.kwargs
         instrumental_url = call_kwargs.get('instrumental_url')
-        assert "instrumentalToken=inst-token" in instrumental_url
+        assert instrumental_url == "https://gen.nomadkaraoke.com/app/jobs/job-123/instrumental"
 
 
 class TestGetCompletionMessage:

backend/tests/test_video_worker_orchestrator.py

@@ -845,3 +845,192 @@ class TestCreateOrchestratorConfigFromJob:
         )
 
         assert config.instrumental_audio_path == "/tmp/test/Test Artist - Test Title (Instrumental User).mp3"
+
+    def test_create_config_passes_instrumental_selection(self):
+        """Test that instrumental_selection is passed through to OrchestratorConfig.
+
+        This is a REGRESSION TEST for the bug where orchestrator -> GCE encoding
+        path did not pass instrumental_selection, causing GCE worker to default
+        to 'clean' even when user selected 'with_backing'.
+
+        The bug was:
+        - PR #271 fixed GCE worker to READ instrumental_selection from config
+        - But the orchestrator path (encoding_interface.py) was never updated to SEND it
+        - The legacy path (video_worker.py _encode_via_gce) was already correct
+        - So the bug only manifested when USE_NEW_ORCHESTRATOR=true (the default)
+
+        See: fix(gce): Respect user's instrumental selection in GCE encoding worker (#271)
+        """
+        job = MagicMock()
+        job.job_id = "test-123"
+        job.artist = "Test Artist"
+        job.title = "Test Title"
+        job.state_data = {"instrumental_selection": "with_backing"}  # User selected backing vocals
+        job.enable_cdg = False
+        job.enable_txt = False
+        job.enable_youtube_upload = False
+        job.brand_prefix = None
+        job.discord_webhook_url = None
+        job.youtube_description_template = None
+        job.dropbox_path = None
+        job.gdrive_folder_id = None
+        job.keep_brand_code = None
+        job.existing_instrumental_gcs_path = None
+
+        config = create_orchestrator_config_from_job(
+            job=job,
+            temp_dir="/tmp/test",
+        )
+
+        # CRITICAL: instrumental_selection must be passed to OrchestratorConfig
+        # If this fails, the GCE worker will default to 'clean' and ignore user's selection
+        assert config.instrumental_selection == "with_backing", \
+            "instrumental_selection must be passed from job.state_data to OrchestratorConfig"
+
+        # Also verify the instrumental path uses "Backing" not "Clean"
+        assert "Backing" in config.instrumental_audio_path, \
+            "When with_backing is selected, instrumental path should contain 'Backing'"
+
+
+class TestInstrumentalSelectionEndToEnd:
+    """End-to-end tests for instrumental selection flow.
+
+    These tests verify that instrumental_selection flows correctly from:
+    job.state_data -> OrchestratorConfig -> EncodingInput -> GCE encoding_config
+
+    This test class was added after discovering that PR #271 only fixed the
+    GCE worker (receiving side) but not the orchestrator (sending side),
+    causing the bug to persist in production where USE_NEW_ORCHESTRATOR=true.
+    """
+
+    def test_encoding_input_has_instrumental_selection_field(self):
+        """Test that EncodingInput dataclass includes instrumental_selection.
+
+        Without this field, the orchestrator cannot pass the selection to
+        the encoding backend.
+        """
+        from backend.services.encoding_interface import EncodingInput
+
+        # Test with explicit selection
+        input_with_backing = EncodingInput(
+            title_video_path="/path/title.mov",
+            karaoke_video_path="/path/karaoke.mov",
+            instrumental_audio_path="/path/audio.flac",
+            instrumental_selection="with_backing",
+        )
+        assert input_with_backing.instrumental_selection == "with_backing"
+
+        # Test default value
+        input_default = EncodingInput(
+            title_video_path="/path/title.mov",
+            karaoke_video_path="/path/karaoke.mov",
+            instrumental_audio_path="/path/audio.flac",
+        )
+        assert input_default.instrumental_selection == "clean", \
+            "Default instrumental_selection should be 'clean' for backward compatibility"
+
+    def test_orchestrator_config_has_instrumental_selection_field(self):
+        """Test that OrchestratorConfig includes instrumental_selection."""
+        config = OrchestratorConfig(
+            job_id="test-job",
+            artist="Test Artist",
+            title="Test Title",
+            title_video_path="/path/title.mov",
+            karaoke_video_path="/path/karaoke.mov",
+            instrumental_audio_path="/path/audio.flac",
+            instrumental_selection="with_backing",
+        )
+        assert config.instrumental_selection == "with_backing"
+
+        # Test default
+        config_default = OrchestratorConfig(
+            job_id="test-job",
+            artist="Test Artist",
+            title="Test Title",
+            title_video_path="/path/title.mov",
+            karaoke_video_path="/path/karaoke.mov",
+            instrumental_audio_path="/path/audio.flac",
+        )
+        assert config_default.instrumental_selection == "clean"
+
+    def test_gce_encoding_config_includes_instrumental_selection(self):
+        """Test that GCEEncodingBackend passes instrumental_selection to encoding_config.
+
+        This is the CRITICAL test that would have caught the bug in PR #271.
+        The GCE worker reads config.get("instrumental_selection", "clean"),
+        so if we don't send it, it defaults to 'clean' regardless of user selection.
+        """
+        from backend.services.encoding_interface import EncodingInput, GCEEncodingBackend
+
+        backend = GCEEncodingBackend(dry_run=True)
+
+        # Create input with 'with_backing' selection
+        encoding_input = EncodingInput(
+            title_video_path="/path/title.mov",
+            karaoke_video_path="/path/karaoke.mov",
+            instrumental_audio_path="/path/audio.flac",
+            artist="Test Artist",
+            title="Test Title",
+            instrumental_selection="with_backing",
+            options={
+                "job_id": "test-123",
+                "input_gcs_path": "gs://bucket/jobs/test-123/",
+                "output_gcs_path": "gs://bucket/jobs/test-123/finals/",
+            },
+        )
+
+        # We can't easily test the actual encoding_config dict without mocking
+        # the service, but we can verify the input has the right value
+        assert encoding_input.instrumental_selection == "with_backing"
+
+        # The fix ensures GCEEncodingBackend.encode() includes this in encoding_config:
+        # encoding_config = {
+        #     ...
+        #     "instrumental_selection": input_config.instrumental_selection,
+        # }
+
+    @pytest.mark.asyncio
+    async def test_orchestrator_passes_instrumental_selection_to_encoding(self):
+        """Test full flow: orchestrator creates EncodingInput with instrumental_selection.
+
+        This integration test verifies the complete path:
+        OrchestratorConfig.instrumental_selection -> EncodingInput.instrumental_selection
+        """
+        config = OrchestratorConfig(
+            job_id="test-job",
+            artist="Test Artist",
+            title="Test Title",
+            title_video_path="/path/title.mov",
+            karaoke_video_path="/path/karaoke.mov",
+            instrumental_audio_path="/path/audio.flac",
+            output_dir="/output",
+            instrumental_selection="with_backing",
+        )
+        orchestrator = VideoWorkerOrchestrator(config)
+
+        # Capture the EncodingInput that gets passed to the backend
+        captured_input = None
+
+        async def capture_encode(encoding_input):
+            nonlocal captured_input
+            captured_input = encoding_input
+            from backend.services.encoding_interface import EncodingOutput
+            return EncodingOutput(
+                success=True,
+                lossless_4k_mp4_path="/output/lossless.mp4",
+                encoding_time_seconds=1.0,
+                encoding_backend="mock",
+            )
+
+        with patch.object(orchestrator, "_get_encoding_backend") as mock_get:
+            mock_backend = MagicMock()
+            mock_backend.name = "mock"
+            mock_backend.encode = capture_encode
+            mock_get.return_value = mock_backend
+
+            await orchestrator._run_encoding()
+
+        # CRITICAL ASSERTION: instrumental_selection must be passed through
+        assert captured_input is not None, "encode() should have been called"
+        assert captured_input.instrumental_selection == "with_backing", \
+            "Orchestrator must pass instrumental_selection to EncodingInput"

backend/workers/video_worker_orchestrator.py

@@ -69,6 +69,9 @@ class OrchestratorConfig:
     # Keep existing brand code (for re-processing)
     keep_brand_code: Optional[str] = None
 
+    # Instrumental selection (clean, with_backing, or custom)
+    instrumental_selection: str = "clean"
+
     # Encoding backend preference
     encoding_backend: str = "auto"  # "auto", "local", "gce"
 
@@ -347,6 +350,7 @@ class VideoWorkerOrchestrator:
             title=self.config.title,
             brand_code=self.config.keep_brand_code,
             output_dir=self.config.output_dir,
+            instrumental_selection=self.config.instrumental_selection,
             options={
                 "job_id": self.config.job_id,
                 "input_gcs_path": input_gcs_path,
@@ -734,6 +738,9 @@ def create_orchestrator_config_from_job(
         # Keep existing brand code
         keep_brand_code=getattr(job, 'keep_brand_code', None),
 
+        # Instrumental selection (for GCE encoding)
+        instrumental_selection=instrumental_selection,
+
         # Encoding backend - auto selects GCE if available
         encoding_backend="auto",