diff --git a/backend/services/fake_workers/pipeline.py b/backend/services/fake_workers/pipeline.py index 84b2f9a1..592b427a 100644 --- a/backend/services/fake_workers/pipeline.py +++ b/backend/services/fake_workers/pipeline.py @@ -23,6 +23,7 @@ from backend.services.fake_workers.config import FakeConfig, get_fake_config from backend.services.fake_workers.lyrics import build_corrections, build_lrc from backend.services.fake_workers.media import MediaSet, get_media from backend.services.job_manager import JobManager +from backend.services.quick_version import service as quick from backend.services.storage_service import StorageService logger = logging.getLogger(__name__) @@ -116,6 +117,27 @@ async def run_audio_download(job_id: str) -> bool: # ---------------------------------------------------------------- audio separation +async def _emit_quick_version(job, job_manager: JobManager, storage: StorageService, media: MediaSet) -> None: + """kjbox make-it jobs: write the same ``state_data.quick_version`` + + ``file_urls.quick.video_mp4`` the real audio worker's quick-version thread does + (``services/quick_version``), using the tiny fixture mp4. Same gate as prod + (``should_build_quick_version``), so non-kjbox jobs are untouched.""" + if not quick.should_build_quick_version(job): + return + job_id = job.job_id + quick.set_quick_state(job_manager, job_id, quick.STATUS_SEPARATING, started_at=quick._now_iso()) + quick.set_quick_state(job_manager, job_id, quick.STATUS_RENDERING) + gcs_path = f"jobs/{job_id}/quick/quick.mp4" + await asyncio.to_thread(storage.upload_file, media.final_mp4, gcs_path) + job_manager.update_file_url(job_id, quick.FILE_CATEGORY, quick.FILE_KEY, gcs_path) + quick.set_quick_state( + job_manager, job_id, quick.STATUS_READY, + lyrics_tier="fake_workers", line_count=0, + duration_seconds=float(media.duration), + size_bytes=os.path.getsize(media.final_mp4), ready_at=quick._now_iso(), + ) + + async def run_audio(job_id: str) -> bool: config = await _begin("audio", job_id) from backend.workers.audio_worker import _transcode_review_stems, upload_separation_results @@ -123,11 +145,18 @@ async def run_audio(job_id: str) -> bool: from backend.workers.worker_logging import create_job_logger job_manager, storage = JobManager(), StorageService() - if not _job_or_none(job_manager, job_id): + job = _job_or_none(job_manager, job_id) + if not job: return False job_log = create_job_logger(job_id, "audio") media = await asyncio.to_thread(_media_for, config) + try: + await _emit_quick_version(job, job_manager, storage, media) + except Exception as e: # non-fatal, same as the real worker + logger.warning(f"[job:{job_id}] fake audio: quick version failed: {e}") + quick.set_quick_state(job_manager, job_id, quick.STATUS_FAILED, error=str(e)[:500]) + job_manager.update_state_data(job_id, "audio_progress", { "stage": "separating", "progress": 30, "message": "Separating audio (fake)", }) diff --git a/backend/tests/test_fake_workers.py b/backend/tests/test_fake_workers.py index a39a7c1f..cc6eb44a 100644 --- a/backend/tests/test_fake_workers.py +++ b/backend/tests/test_fake_workers.py @@ -492,3 +492,43 @@ class TestFakeSearchConfidence: with open(FRONTEND_FIXTURE) as f: assert json.load(f) == frontend_fixture() + + +# --------------------------------------------------------------------------- kjbox quick version + +class TestKjboxQuickVersion: + def _run_audio(self, request_metadata): + from backend.services.fake_workers import pipeline + + jm = MagicMock() + jm.get_job.return_value = SimpleNamespace( + job_id="job1", user_email="u@example.com", artist="A", title="T", + request_metadata=request_metadata, state_data={}, + ) + jm.advance_to_screens_if_ready = AsyncMock() + jm.resume_video_if_waiting_for_stems = AsyncMock() + storage = MagicMock() + media = MagicMock(final_mp4=__file__, duration=30) + with patch.object(pipeline, "JobManager", return_value=jm), \ + patch.object(pipeline, "StorageService", return_value=storage), \ + patch.object(pipeline, "_media_for", return_value=media), \ + patch.object(pipeline, "get_fake_config", return_value=FakeConfig(step_delay_seconds=0)), \ + patch("backend.workers.audio_worker.upload_separation_results", AsyncMock()), \ + patch("backend.workers.audio_worker._transcode_review_stems", AsyncMock()), \ + patch("backend.workers.screens_worker._analyze_backing_vocals", AsyncMock()), \ + patch("backend.workers.worker_logging.create_job_logger"): + assert asyncio.run(pipeline.run("audio", "job1")) is True + return jm, storage + + def test_fake_workers_emit_quick_version_for_kjbox_jobs(self): + jm, storage = self._run_audio({"client_id": "kjbox"}) + jm.update_file_url.assert_called_once_with("job1", "quick", "video_mp4", "jobs/job1/quick/quick.mp4") + storage.upload_file.assert_called_once() + statuses = [c.args[2]["status"] for c in jm.update_state_data.call_args_list + if c.args[1] == "quick_version"] + assert statuses == ["separating", "rendering", "ready"] + + def test_non_kjbox_jobs_get_no_quick_version(self): + jm, storage = self._run_audio({"client_id": "web"}) + jm.update_file_url.assert_not_called() + assert not [c for c in jm.update_state_data.call_args_list if c.args[1] == "quick_version"] diff --git a/backend/tests/test_kjbox_partner_api.py b/backend/tests/test_kjbox_partner_api.py index 0c6585e9..02bbf112 100644 --- a/backend/tests/test_kjbox_partner_api.py +++ b/backend/tests/test_kjbox_partner_api.py @@ -774,3 +774,39 @@ class TestCatalogResolve: assert client.post("/api/kjbox/catalog/resolve", json={"query": "x"}).status_code == 403 assert self._post(client, "").status_code == 422 assert self._post(client, " ").status_code == 422 + + +def _local_stack_env(monkeypatch, **overrides): + import os + import subprocess + from pathlib import Path + + script = Path(__file__).resolve().parents[2] / "scripts" / "local-stack.sh" + env = {k: v for k, v in os.environ.items() + if k not in ("KJBOX_PARTNER_SECRET", "DECIDE_GEN_PARTNER_SECRET")} + env.update(overrides) + out = subprocess.run([str(script), "env"], capture_output=True, text=True, check=True, env=env).stdout + return dict(line.split("=", 1) for line in out.splitlines() if "=" in line) + + +def test_kjbox_routes_accept_local_secret(monkeypatch): + """With nothing set externally, local-stack.sh defaults KJBOX_PARTNER_SECRET to + local-stack-secret and the partner gate accepts exactly that value.""" + from fastapi import HTTPException + + env = _local_stack_env(monkeypatch) + local_secret = env["KJBOX_PARTNER_SECRET"] + assert local_secret == "local-stack-secret" + assert env["DECIDE_GEN_PARTNER_SECRET"] == "local-stack-secret" + + monkeypatch.setattr(kjbox, "get_settings", lambda: SimpleNamespace(kjbox_partner_secret=local_secret)) + assert kjbox.require_kjbox_partner(local_secret) == local_secret + with pytest.raises(HTTPException) as exc: + kjbox.require_kjbox_partner("wrong") + assert exc.value.status_code == 403 + + +def test_local_stack_honours_external_partner_secrets(monkeypatch): + env = _local_stack_env(monkeypatch, KJBOX_PARTNER_SECRET="ext-kjbox", DECIDE_GEN_PARTNER_SECRET="ext-decide") + assert env["KJBOX_PARTNER_SECRET"] == "ext-kjbox" + assert env["DECIDE_GEN_PARTNER_SECRET"] == "ext-decide" diff --git a/docs/TESTING.md b/docs/TESTING.md index 56a78d8a..c0efe3a3 100644 --- a/docs/TESTING.md +++ b/docs/TESTING.md @@ -334,6 +334,14 @@ settings object in a unit test never turns it on. | Postmark | console provider + captured outbox | `ConsoleEmailProvider` | | Secret Manager, DeBounce, encoding VM | skipped | `get_secret`, `is_disposable_domain`, warmup | +**kjbox partner calls.** The stack exports `KJBOX_PARTNER_SECRET=local-stack-secret` +(and `DECIDE_GEN_PARTNER_SECRET`, same value) so a local kjbox stack can call +`/api/kjbox/*` with `X-Kjbox-Secret: local-stack-secret`. For jobs created with +`X-Client-Id: kjbox…` the fake audio worker also writes the real "quick version" +outputs (`state_data.quick_version` separating -> rendering -> ready, and +`file_urls.quick.video_mp4` from the fixture mp4), so `/api/jobs/{id}/download-urls` +lists `quick/video_mp4` and `/download/quick/video_mp4` streams it, like prod. + The audio worker reuses the real stem upload, OGG transcode and backing-vocals analysis. The review preview video is the real local ffmpeg render. Startup **refuses** `FAKE_WORKERS` in production (`validate_production_config`). diff --git a/pyproject.toml b/pyproject.toml index fc25bb13..78c7cbf3 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "karaoke-gen" -version = "0.280.0" +version = "0.280.1" description = "Generate karaoke videos with synchronized lyrics. Handles the entire process from downloading audio and lyrics to creating the final video with title screens." authors = ["Andrew Beveridge "] license = "MIT" diff --git a/scripts/local-stack.sh b/scripts/local-stack.sh index 4358a394..2ed3c388 100755 --- a/scripts/local-stack.sh +++ b/scripts/local-stack.sh @@ -49,6 +49,8 @@ REVIEW_AUDIO_PROXY=1 MAX_SIGNUPS_PER_IP=100000 BOARD_MAX_SIGNUPS_PER_IP=100000 LOGIN_CODES_PER_IP_PER_HOUR=100000 +KJBOX_PARTNER_SECRET=${KJBOX_PARTNER_SECRET:-local-stack-secret} +DECIDE_GEN_PARTNER_SECRET=${DECIDE_GEN_PARTNER_SECRET:-local-stack-secret} POSTMARK_SERVER_TOKEN= STRIPE_SECRET_KEY= EOF