Compare commits

..
Author SHA1 Message Date
Andrew BeveridgeandClaude Opus 4.5 2614a2c14c Address CodeRabbit review feedback
- Add thread-safe singleton initialization for ThemeService using double-checked locking
- Make BRANDING_DIR configurable via environment variable in upload-theme.sh
- Fix trap command quoting (use single quotes for deferred expansion)
- Add validation for required branding files before upload

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
2025-12-27 17:51:43 -05:00
Andrew BeveridgeandClaude Opus 4.5 80115b7e34 Add theme system for pre-made video styles
- Backend: Add theme models, service, and API routes for theme selection
- Backend: Update job creation to accept theme_id and color_overrides
- Backend: Enable CDG/TXT by default when theme is selected
- Frontend: Add ThemeSelector and ColorOverridesPanel components
- Frontend: Integrate theme selection into JobSubmission form
- CLI: Add --theme argument for remote CLI
- Upload Nomad theme to GCS at themes/nomad/

Themes are stored in GCS and include style params, assets, YouTube
description templates, and preview images. Users can select a theme
and optionally override colors (artist, title, sung/unsung lyrics).

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
2025-12-27 15:17:48 -05:00
317 changed files with 6701 additions and 43519 deletions

No files matched your search

@@ -1,106 +0,0 @@
# Plan: Migrate from MailSlurp to testmail.app
**Created:** 2026-01-02
**Branch:** feat/sess-20260102-2109-migrate-mailslurp-testmail
**Status:** Complete
## Overview
Replace MailSlurp email testing service with testmail.app for E2E testing of magic link authentication. testmail.app uses a simpler API with namespace-based email addresses that require no inbox creation/deletion - emails just arrive at `{namespace}.{tag}@inbox.testmail.app`.
## Requirements
- [x] Remove all code referencing MailSlurp
- [x] Remove `mailslurp-client` npm dependency
- [x] Implement testmail.app API integration
- [x] Update environment variable names (`TESTMAIL_API_KEY`, `TESTMAIL_NAMESPACE`)
- [x] Maintain same `EmailHelper` interface for minimal test changes
- [x] Update archive docs to note migration (optional - historical accuracy)
## Technical Approach
### API Differences
| Feature | MailSlurp | testmail.app |
|---------|-----------|--------------|
| Email format | Random `xxx@mailslurp.com` | `{namespace}.{tag}@inbox.testmail.app` |
| Inbox creation | Required (`createInbox()`) | Not needed - use any tag |
| Inbox deletion | Required (`deleteInbox()`) | Not needed |
| Get emails | `waitForLatestEmail(inboxId)` | GET `/api/json?apikey=X&namespace=Y&tag=Z&livequery=true` |
| Auth | API key in constructor | API key as query param |
| Email body | `email.body` | `email.html` or `email.text` |
### Implementation Strategy
1. **Keep same `EmailHelper` interface** - `createInbox()`, `waitForEmail()`, `extractMagicLink()`, `deleteInbox()`
2. **Use testmail.app's live query feature** - `livequery=true` waits for email to arrive (up to timeout)
3. **Generate unique tags** - Use timestamp + random suffix for each test run to avoid collisions
4. **Inbox becomes a simple object** - `{ id: tag, emailAddress: '{namespace}.{tag}@inbox.testmail.app' }`
5. **Delete becomes no-op** - testmail.app emails auto-expire, no cleanup needed
### Environment Variables
| Old | New |
|-----|-----|
| `MAILSLURP_API_KEY` | `TESTMAIL_API_KEY` |
| (none) | `TESTMAIL_NAMESPACE` |
Values: Set via environment variables (see `frontend/.env.local.example`)
## Implementation Steps
1. [x] **Update `email-testing.ts`** - Replace MailSlurp implementation with testmail.app
- Remove `mailslurp-client` import
- Add testmail.app API fetch implementation
- Use native `fetch` (no new dependencies)
- Generate unique tag for each "inbox"
- Implement `livequery=true` for waiting
- Adapt email body extraction (`html`/`text` instead of `body`)
2. [x] **Update `full-user-journey.spec.ts`** - Change references
- Update doc comments (env var name)
- Update error messages
- Update console logs
3. [x] **Update `playwright.record.config.ts`** - Change env var comment
4. [x] **Update `package.json`** - Remove `mailslurp-client` dependency
5. [x] **Run `npm install`** - Update package-lock.json
6. [x] **Create `.env.local.example`** - Document required env vars for local testing
7. [x] **Update archive docs** - Skipped intentionally; historical docs preserved for accuracy
## Files to Create/Modify
| File | Action | Description |
|------|--------|-------------|
| `frontend/e2e/helpers/email-testing.ts` | Modify | Replace MailSlurp with testmail.app |
| `frontend/e2e/production/full-user-journey.spec.ts` | Modify | Update env var refs and messages |
| `frontend/playwright.record.config.ts` | Modify | Update env var comment |
| `frontend/package.json` | Modify | Remove `mailslurp-client` |
| `frontend/package-lock.json` | Modify | Auto-updated by npm install |
| `frontend/.env.local.example` | Create | Document env vars for local testing |
## Testing Strategy
- **Manual testing**: Run production E2E test with testmail.app credentials
```bash
cd frontend
TESTMAIL_API_KEY=your-api-key \
TESTMAIL_NAMESPACE=your-namespace \
npm run test:e2e:prod:headed
```
- **Verify**: Email received, magic link extracted, auth flow completes
- **CI testing**: Env vars already configured in GitHub Actions org secrets
## Open Questions
None - requirements are clear.
## Rollback Plan
1. Revert the commit
2. Run `npm install` to restore mailslurp-client
3. Re-add MAILSLURP_API_KEY to secrets if removed
@@ -1,401 +0,0 @@
# Plan: Video Worker Stage Refactor
**Created:** 2026-01-03
**Branch:** feat/sess-20260103-2250-investigate-youtube-upload
**Status:** COMPLETE - Ready for PR
**Last Updated:** 2026-01-04
## Overview
Refactor `video_worker.py` and `KaraokeFinalise` into separate, composable stages following SOLID principles. This eliminates the GCE vs KaraokeFinalise code path divergence that causes features like YouTube upload to be missing from the GCE encoding path.
## Three Execution Modes
Understanding the three ways this system runs is critical to the refactor:
### 1. Local CLI (`karaoke-gen`)
- Runs entirely on user's machine
- KaraokeFinalise.process() orchestrates everything
- Writes directly to local Dropbox sync folder (e.g., `~/Dropbox/Karaoke/Tracks-Organized/`)
- **Produces full output structure** with stems/, lyrics/, visualizations/, etc.
- **This is the source of truth for output format**
### 2. Remote CLI (`karaoke-gen-remote`)
- User's CLI talks to cloud backend (api.nomadkaraoke.com)
- Cloud does ALL processing (audio, lyrics, video encoding)
- CLI just monitors job status and downloads final outputs
- With Dropbox configured: cloud uploads full structure to user's Dropbox
- Without Dropbox: user downloads individual files
### 3. Web Frontend (`gen.nomadkaraoke.com`)
- Same cloud backend as remote CLI
- User sees:
- YouTube video link
- Dropbox folder link
- Direct download: final karaoke video (720p)
- Direct download: 4K video
- Direct download: "with vocals" video
- Direct download: CDG zip (if enabled)
## Problem Statement
Currently, `video_worker.py` has two completely divergent code paths:
```python
if use_gce_encoding:
# GCE PATH: Only encoding, missing YouTube/Discord/CDG/TXT
result = await _encode_via_gce(...)
# result DOES NOT include youtube_url!
else:
# STANDARD PATH: KaraokeFinalise does everything
finalise = KaraokeFinalise(...)
result = finalise.process()
# result includes youtube_url from upload
```
### What GCE Encoding Broke
| Feature | KaraokeFinalise Path | GCE Path |
|---------|---------------------|----------|
| Video encoding | ✅ 4 formats | ✅ 4 formats |
| YouTube upload | ✅ | ❌ **BROKEN** |
| Discord notification | ✅ | ❌ **BROKEN** |
| CDG/TXT packaging | ✅ | ❌ **BROKEN** |
| Brand code generation | ✅ | ✅ (via Dropbox service) |
| Dropbox upload | ✅ (rclone) | ✅ (native SDK) |
| Google Drive upload | ❌ | ✅ (native SDK) |
### Root Cause
`KaraokeFinalise.process()` is a monolith that handles:
1. CDG/TXT packaging
2. Video encoding (the CPU-intensive part)
3. YouTube upload
4. Discord notifications
5. Folder organization
The GCE encoding was added as a bypass around the entire class, rather than replacing just the encoding step.
## Requirements
### Functional Requirements
- [ ] YouTube upload works regardless of encoding backend (GCE or local)
- [ ] Discord notifications work regardless of encoding backend
- [ ] CDG/TXT packaging works regardless of encoding backend
- [ ] Brand code generation works consistently
- [ ] Dropbox/Google Drive upload works (already works in both paths)
- [ ] All existing CLI functionality continues to work
- [ ] Output structure matches local CLI exactly
### Output Structure Parity
Cloud backend must produce identical output to local CLI:
```
NOMAD-XXXX - Artist - Title/
├── Artist - Title (Title).mov
├── Artist - Title (Title).jpg
├── Artist - Title (End).mov
├── Artist - Title (End).jpg
├── Artist - Title (Final Karaoke Lossless 4k).mp4
├── Artist - Title (Final Karaoke Lossless 4k).mkv
├── Artist - Title (Final Karaoke Lossy 4k).mp4
├── Artist - Title (Final Karaoke Lossy 720p).mp4
├── Artist - Title (Final Karaoke CDG).zip
├── Artist - Title (Final Karaoke TXT).zip
├── Artist - Title (Instrumental {model}).flac
├── Artist - Title (Instrumental +BV {model}).flac
├── Artist - Title (Karaoke).mp4
├── Artist - Title (Karaoke).cdg
├── Artist - Title (Karaoke).mp3
├── Artist - Title (Karaoke).lrc
├── Artist - Title (With Vocals).mp4
├── stems/
│ ├── Artist - Title (Instrumental {model}).flac
│ ├── Artist - Title (Vocals {model}).flac
│ ├── Artist - Title (Lead Vocals {model}).flac
│ ├── Artist - Title (Backing Vocals {model}).flac
│ └── ... (other stems)
├── lyrics/
│ ├── Artist - Title (Karaoke).lrc
│ ├── Artist - Title (Karaoke).ass
│ ├── Artist - Title (Karaoke).srt
│ └── ... (corrections JSONs)
├── previews/
├── visualizations/
└── styles_assets/
```
### Non-Functional Requirements
- [ ] Single Responsibility: Each stage has one job
- [ ] Open/Closed: Easy to add new encoding backends without modifying stages
- [ ] Testable: Each stage can be unit tested in isolation
- [ ] No duplicate code between paths
- [ ] Backwards compatible with existing KaraokeFinalise CLI usage
## Technical Approach
### Architecture: Stage-Based Pipeline
```
video_worker.py (VideoWorkerOrchestrator)
│
├── 1. EncodingStage (interface)
│ ├── LocalEncodingService (wraps KaraokeFinalise encoding methods)
│ └── GCEEncodingService (existing encoding_service.py)
│
├── 2. PackagingStage
│ ├── CDGPackager (extracts from KaraokeFinalise)
│ └── TXTPackager (extracts from KaraokeFinalise)
│
├── 3. DistributionStage
│ ├── YouTubeUploadService (extracts from KaraokeFinalise)
│ ├── DropboxService (existing)
│ ├── GoogleDriveService (existing)
│ └── DiscordService (extracts from KaraokeFinalise)
│
└── 4. OrganizationStage
└── BrandCodeService (extracts from KaraokeFinalise + DropboxService)
```
### Key Design Decisions
1. **Extract, Don't Rewrite**: Pull methods out of KaraokeFinalise into services, don't rewrite from scratch
2. **Keep KaraokeFinalise for CLI**: Local CLI still uses KaraokeFinalise.process() - we extract services that it can also use
3. **Interface-Based Encoding**: EncodingStage interface allows swapping GCE/local without changing orchestration
4. **Existing Service Pattern**: Follow singleton + factory pattern already used in codebase
5. **Local CLI stays sync**: Local karaoke-gen CLI remains synchronous as it is today
### Data Flow
```
JobConfig (from Firestore)
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ VideoWorkerOrchestrator │
│ ┌─────────────────────────────────────────────────────────────┐│
│ │ 1. Setup: Download files, prepare directories ││
│ │ - Download title.mov, end.mov, with_vocals.mkv ││
│ │ - Download instrumental audio ││
│ │ - Prepare temp directory ││
│ └─────────────────────────────────────────────────────────────┘│
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────┐│
│ │ 2. Packaging: CDG/TXT (if enabled) - runs BEFORE encoding ││
│ │ Reason: CDG depends on LRC file which is available ││
│ │ Input: LRC file, instrumental audio ││
│ │ Output: CDG.zip, TXT.zip, .cdg, .mp3 ││
│ └─────────────────────────────────────────────────────────────┘│
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────┐│
│ │ 3. Encoding: GCE or Local (via interface) ││
│ │ Input: title.mov, karaoke.mov, end.mov ││
│ │ Output: 4K lossless, 4K lossy, 720p, MKV ││
│ └─────────────────────────────────────────────────────────────┘│
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────┐│
│ │ 4. Organization: Brand code, folder structure ││
│ │ - Generate brand code (NOMAD-XXXX) ││
│ │ - Prepare full output directory structure ││
│ └─────────────────────────────────────────────────────────────┘│
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────┐│
│ │ 5. Distribution: Upload to destinations ││
│ │ - YouTube upload (if enabled) ││
│ │ - Dropbox upload (if configured) ││
│ │ - Google Drive upload (if configured) ││
│ └─────────────────────────────────────────────────────────────┘│
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────┐│
│ │ 6. Notification: Discord, Email ││
│ │ Input: YouTube URL, brand code, Dropbox link ││
│ └─────────────────────────────────────────────────────────────┘│
└─────────────────────────────────────────────────────────────────┘
│
▼
Result (youtube_url, brand_code, dropbox_link, file_paths, etc.)
```
## Implementation Steps
### Phase 1: Extract Services from KaraokeFinalise (Non-Breaking) ✅ COMPLETE
These services can be used by both the cloud orchestrator AND KaraokeFinalise.
1. [x] **Create `backend/services/youtube_upload_service.py`** ✅
- Extract YouTube upload logic from KaraokeFinalise
- Methods: `upload_video()`, `check_duplicate()`, `delete_video()`, `truncate_title()`
- Supports pre-loaded credentials (server-side) or client secrets file (CLI)
- 23 unit tests with mocked YouTube API
2. [x] **Create `backend/services/discord_service.py`** ✅
- Extract Discord notification from KaraokeFinalise
- Methods: `post_message()`, `post_video_notification()`, `is_enabled()`
- Simple HTTP POST to webhook with validation
- 20 unit tests with mocked requests
3. [x] **Create `backend/services/packaging_service.py`** ✅
- Extract CDG/TXT generation from KaraokeFinalise
- Methods: `create_cdg_package()`, `create_txt_package()`
- Uses lyrics_converter and CDGGenerator (existing dependencies)
- 18 unit tests with temp files
4. [x] **Create `backend/services/local_encoding_service.py`** ✅
- Extract encoding methods from KaraokeFinalise
- Methods: `encode_all_formats()`, individual encoding methods
- Hardware acceleration detection with software fallback
- 28 unit tests with mocked subprocess
### Phase 2: Create Encoding Interface ✅ COMPLETE
5. [x] **Create `backend/services/encoding_interface.py`** ✅
- Define ABC `EncodingBackend` with methods: `encode()`, `is_available()`, `get_status()`
- `EncodingInput` and `EncodingOutput` dataclasses for config/results
- Factory function `get_encoding_backend()` with "local", "gce", "auto" options
6. [x] **`LocalEncodingBackend`** ✅
- Implements `EncodingBackend` interface
- Wraps `LocalEncodingService` with `asyncio.to_thread()`
- 17 unit tests
7. [x] **`GCEEncodingBackend`** ✅
- Implements `EncodingBackend` interface
- Wraps existing `EncodingService` (encoding_service.py)
- Requires GCS paths in options for cloud execution
- 6 additional unit tests
### Phase 3: Create Orchestrator ✅ COMPLETE
8. [x] **Create `backend/workers/video_worker_orchestrator.py`** ✅
- New class that coordinates all stages
- Replaces the branching logic in `generate_video()`
- Methods:
- `__init__(config, job_manager, storage, job_logger)`
- `async run() -> OrchestratorResult`
- `_run_packaging()` - CDG/TXT
- `_run_encoding()` - GCE or local via EncodingBackend interface
- `_run_organization()` - Brand code, folder structure
- `_run_distribution()` - YouTube, Dropbox, GDrive
- `_run_notifications()` - Discord
- 27 unit tests (test_video_worker_orchestrator.py)
9. [x] **Update `backend/workers/video_worker.py`** ✅
- Added `USE_NEW_ORCHESTRATOR` feature flag (default: true)
- `generate_video()` routes to orchestrator or legacy path
- `generate_video_orchestrated()` - new unified pipeline
- `generate_video_legacy()` - original code for rollback
- Legacy GCE and KaraokeFinalise paths preserved for safety
### Phase 4: Update KaraokeFinalise to Use Services (OPTIONAL)
10. [ ] **Update `karaoke_gen/karaoke_finalise/karaoke_finalise.py`**
- Import and use the new services
- Replace inline YouTube/Discord/CDG code with service calls
- Keep process() working for CLI backwards compatibility
- Services become the single source of truth
- **NOTE**: This is optional for MVP - the orchestrator already uses the extracted services directly
### Phase 5: Testing & Validation ✅ COMPLETE
11. [x] **Add unit tests for each service** ✅
- test_youtube_upload_service.py (23 tests)
- test_discord_service.py (20 tests)
- test_packaging_service.py (18 tests)
- test_local_encoding_service.py (28 tests)
- test_encoding_interface.py (23 tests)
- test_video_worker_orchestrator.py (27 tests)
- **Total: 139 new tests**
12. [x] **Full test suite passes** ✅
- 976 tests passed (86 skipped - emulator/integration tests)
- No regressions from changes
13. [ ] **Manual E2E testing** (After deployment)
- [ ] GCE encoding job with YouTube upload enabled
- [ ] Local encoding job with YouTube upload enabled
- [ ] CLI karaoke-gen with all features
- [ ] Job with CDG/TXT enabled
- [ ] Verify output structure matches local CLI
## Files Created/Modified
| File | Action | Description | Status |
|------|--------|-------------|--------|
| `backend/services/youtube_upload_service.py` | Create | YouTube upload logic (~446 lines) | ✅ |
| `backend/services/discord_service.py` | Create | Discord notification service (~167 lines) | ✅ |
| `backend/services/packaging_service.py` | Create | CDG/TXT package generation (~266 lines) | ✅ |
| `backend/services/local_encoding_service.py` | Create | Local FFmpeg encoding service (~512 lines) | ✅ |
| `backend/services/encoding_interface.py` | Create | Abstract interface + backends (~418 lines) | ✅ |
| `backend/workers/video_worker_orchestrator.py` | Create | Stage orchestration logic (~550 lines) | ✅ |
| `backend/workers/video_worker.py` | Modify | Added orchestrator path + feature flag | ✅ |
| `backend/tests/test_youtube_upload_service.py` | Create | 23 unit tests | ✅ |
| `backend/tests/test_discord_service.py` | Create | 20 unit tests | ✅ |
| `backend/tests/test_packaging_service.py` | Create | 18 unit tests | ✅ |
| `backend/tests/test_local_encoding_service.py` | Create | 28 unit tests | ✅ |
| `backend/tests/test_encoding_interface.py` | Create | 23 unit tests | ✅ |
| `backend/tests/test_video_worker_orchestrator.py` | Create | 27 unit tests | ✅ |
| `karaoke_gen/karaoke_finalise/karaoke_finalise.py` | Modify | Use extracted services (optional) | Deferred |
## Testing Strategy
### Unit Tests
- **youtube_upload_service**: Mock YouTube API, test upload/delete/duplicate check
- **discord_service**: Mock requests, test webhook POST
- **packaging_service**: Use temp files, test CDG/TXT generation
- **local_encoding_service**: Mock subprocess, test FFmpeg command construction
### Integration Tests
- **video_worker_orchestrator**: Mock all services, test stage sequencing
- **video_worker**: Test with mocked orchestrator
### E2E Verification
- [ ] GCE encoding job with YouTube upload enabled → YouTube link appears
- [ ] Local encoding job with YouTube upload enabled → Same behavior
- [ ] CLI `karaoke-gen` with all features → No regression
- [ ] Job with CDG/TXT enabled → Packages generated
- [ ] Dropbox output structure → Matches local CLI exactly
## Open Questions
- [x] Should we keep KaraokeFinalise.process() or deprecate it?
- **Decision**: Keep it for CLI backwards compatibility. It will use the new services internally.
- [x] Should local_encoding_service run FFmpeg sync or async?
- **Decision**: Sync implementation, async wrapper via `asyncio.to_thread()` for interface compatibility.
- [x] Order of packaging vs encoding?
- **Decision**: CDG/TXT runs BEFORE encoding (depends on LRC file, not videos). KaraokeFinalise does it this way too.
## Rollback Plan
1. The refactor is additive - new services don't replace old code until orchestrator is wired up
2. Feature flag: `USE_NEW_ORCHESTRATOR=true` to enable new code path
3. If issues found in production:
- Set `USE_NEW_ORCHESTRATOR=false` to revert to old behavior
- Old `generate_video()` code preserved behind feature flag
4. After 1 week stable, remove feature flag and old code
## Success Criteria
1. Job `5b78ad46` scenario (GCE + YouTube) would upload to YouTube
2. All 803+ existing tests pass
3. E2E happy path test passes
4. No regression in local CLI functionality
5. Output structure matches local CLI exactly
6. Code coverage maintained or improved
## Estimated Scope
- **Phase 1** (Extract Services): 4 new service files + tests (~400-600 lines each)
- **Phase 2** (Interface): 1 new file, 2 modifications (~100 lines)
- **Phase 3** (Orchestrator): 2 files (~300-400 lines)
- **Phase 4** (KaraokeFinalise): 1 modification (~100 lines of changes)
- **Phase 5** (Testing): Integration tests + manual verification
This is a medium-sized refactor that can be done incrementally. Each phase produces working, tested code.
-83
View File
@@ -1,83 +0,0 @@
# .dockerignore - Reduce Docker build context size
# This is critical for fast builds as it reduces upload time and cache invalidation
# Git
.git/
.gitignore
.gitmodules
# Node.js / Frontend (not needed for backend image)
node_modules/
frontend/
frontend-react/
*.log
npm-debug.log*
yarn-debug.log*
yarn-error.log*
# Python virtual environments (use Docker's Python instead)
__pycache__/
*.py[cod]
*$py.class
*.so
.Python
.venv/
venv/
backend/venv/
ENV/
env/
*.egg-info/
.eggs/
dist/
build/
*.egg
# IDE
.idea/
.vscode/
*.swp
*.swo
*~
.DS_Store
# Testing (not needed in production image)
.pytest_cache/
.coverage
htmlcov/
.tox/
.nox/
coverage.xml
*.cover
tests/
backend/tests/
# Documentation (not needed in Docker image)
docs/
*.md
!README.md
# Infrastructure (not needed for Docker build)
infrastructure/
# CI/CD configs
.github/
# Cloud Build configs (keep for reference but not in image)
cloudbuild*.yaml
# Local development files
lyrics_transcriber_local/
*.local
.env
.env.*
*.bak
*.tmp
Thumbs.db
# Large test/sample files
tests/data/
*.mp3
*.wav
*.mp4
*.mkv
*.flac
+169 -656
View File
File diff suppressed because it is too large. Load diff
-173
View File
@@ -1,173 +0,0 @@
name: E2E Happy Path Test
# Comprehensive end-to-end test that validates the full karaoke generation journey
# using ONLY browser interactions (no API shortcuts)
#
# See docs/E2E-HAPPY-PATH-TEST-SPEC.md for full requirements
on:
# Daily run at 6 AM UTC
schedule:
- cron: '0 6 * * *'
# Manual trigger with optional parameters
workflow_dispatch:
inputs:
debug_mode:
description: 'Enable debug mode (slower, more screenshots)'
required: false
default: 'false'
type: boolean
browser:
description: 'Browser to test with'
required: false
default: 'chromium'
type: choice
options:
- chromium
- firefox
- webkit
use_test_token:
description: 'Skip signup and use E2E_TEST_TOKEN (for iterations)'
required: false
default: 'false'
type: boolean
permissions:
contents: read
jobs:
e2e-happy-path:
name: "Full Happy Path (Real User)"
runs-on: ubuntu-latest
timeout-minutes: 90 # 1.5 hours max (test itself is 60 min)
steps:
- name: Checkout code
uses: actions/checkout@v4
- name: Setup Node.js
uses: actions/setup-node@v4
with:
node-version: '20'
cache: 'npm'
cache-dependency-path: frontend/package-lock.json
- name: Install dependencies
working-directory: frontend
run: npm ci --legacy-peer-deps
- name: Install Playwright browsers
working-directory: frontend
run: |
BROWSER=${{ inputs.browser || 'chromium' }}
npx playwright install --with-deps $BROWSER
- name: Create test-results directory
working-directory: frontend
run: mkdir -p test-results
- name: Run E2E Happy Path Test
working-directory: frontend
env:
TESTMAIL_API_KEY: ${{ secrets.TESTMAIL_API_KEY }}
TESTMAIL_NAMESPACE: ${{ secrets.TESTMAIL_NAMESPACE }}
E2E_TEST_TOKEN: ${{ inputs.use_test_token && secrets.E2E_TEST_TOKEN || '' }}
E2E_ADMIN_TOKEN: ${{ secrets.E2E_ADMIN_TOKEN }}
DEBUG_MODE: ${{ inputs.debug_mode || 'false' }}
run: |
echo "Starting E2E Happy Path Test"
echo "Browser: ${{ inputs.browser || 'chromium' }}"
echo "Debug mode: ${{ inputs.debug_mode || 'false' }}"
echo "Use test token: ${{ inputs.use_test_token || 'false' }}"
echo "Time: $(date)"
echo ""
# Run the real user happy path test
npx playwright test happy-path-real-user.spec.ts \
--config=playwright.production.config.ts \
--project=${{ inputs.browser || 'chromium' }} \
--reporter=list \
--timeout=3600000 \
2>&1 | tee test-output.log
continue-on-error: true
- name: Check test result
id: test_result
working-directory: frontend
run: |
if grep -q "passed" test-output.log && ! grep -q "failed" test-output.log; then
echo "result=success" >> $GITHUB_OUTPUT
echo "Test PASSED"
else
echo "result=failure" >> $GITHUB_OUTPUT
echo "Test FAILED - see artifacts for details"
fi
- name: Upload test artifacts
if: always()
uses: actions/upload-artifact@v4
with:
name: e2e-happy-path-results-${{ github.run_number }}
path: |
frontend/test-results/
frontend/playwright-report/
frontend/test-output.log
retention-days: 30
- name: Upload video recordings
if: always()
uses: actions/upload-artifact@v4
with:
name: e2e-happy-path-videos-${{ github.run_number }}
path: frontend/test-results/**/*.webm
retention-days: 30
if-no-files-found: ignore
- name: Create summary
if: always()
run: |
echo "## E2E Happy Path Test Results" >> $GITHUB_STEP_SUMMARY
echo "" >> $GITHUB_STEP_SUMMARY
echo "| Property | Value |" >> $GITHUB_STEP_SUMMARY
echo "|----------|-------|" >> $GITHUB_STEP_SUMMARY
echo "| Run | #${{ github.run_number }} |" >> $GITHUB_STEP_SUMMARY
echo "| Trigger | ${{ github.event_name }} |" >> $GITHUB_STEP_SUMMARY
echo "| Browser | ${{ inputs.browser || 'chromium' }} |" >> $GITHUB_STEP_SUMMARY
echo "| Result | ${{ steps.test_result.outputs.result || 'unknown' }} |" >> $GITHUB_STEP_SUMMARY
echo "" >> $GITHUB_STEP_SUMMARY
if [ -f frontend/test-output.log ]; then
echo "### Test Output (last 100 lines)" >> $GITHUB_STEP_SUMMARY
echo "\`\`\`" >> $GITHUB_STEP_SUMMARY
tail -100 frontend/test-output.log >> $GITHUB_STEP_SUMMARY
echo "\`\`\`" >> $GITHUB_STEP_SUMMARY
fi
- name: Send email notification
if: always() && github.event_name == 'schedule'
uses: dawidd6/action-send-mail@v3
with:
server_address: smtp.sendgrid.net
server_port: 587
username: apikey
password: ${{ secrets.SENDGRID_API_KEY }}
subject: "E2E Happy Path Test ${{ steps.test_result.outputs.result == 'success' && 'PASSED' || 'FAILED' }} - Run #${{ github.run_number }}"
to: andrew@nomadkaraoke.com
from: "Karaoke Gen CI <noreply@nomadkaraoke.com>"
body: |
E2E Happy Path Test Results
===========================
Status: ${{ steps.test_result.outputs.result == 'success' && 'PASSED ✅' || 'FAILED ❌' }}
Run: #${{ github.run_number }}
Trigger: ${{ github.event_name }}
Time: ${{ github.event.repository.updated_at }}
View details: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
This is an automated notification from the daily E2E happy path test.
- name: Fail if test failed
if: steps.test_result.outputs.result == 'failure'
run: exit 1
+1 -9
View File
@@ -12,9 +12,6 @@ tests/outputs
/input
/output/
# Cloud Infra
.emulator-logs
# Next.js / React Frontend (./frontend)
node_modules/
frontend/node_modules/
@@ -47,7 +44,6 @@ frontend/coverage/
frontend/test-results/
frontend/playwright-report/
frontend/playwright/.cache/
frontend/e2e/screenshots/
# TypeScript
frontend/*.tsbuildinfo
@@ -83,9 +79,8 @@ eggs/
# Python lib directories (not frontend)
lib/
lib64/
# But allow frontend lib directories
# But allow frontend lib
!frontend/lib/
!buy-site/lib/
parts/
sdist/
var/
@@ -229,6 +224,3 @@ cython_debug/
# option (not recommended) you can uncomment the following to ignore the entire idea folder.
#.idea/
flacfetch
# Test output directories
Rick Astley*/
File renamed without changes.
+110 -77
View File
@@ -1,98 +1,131 @@
# Karaoke-Gen AI Assistant Guidelines
# Project Guidelines for AI Assistants
## Project Overview
This document contains guidelines and rules for AI assistants working on this codebase.
**Karaoke video generation platform** - CLI tool and web service that creates professional karaoke videos with synchronized lyrics.
## Core Principles
- **Production**: <https://gen.nomadkaraoke.com> (frontend), <https://api.nomadkaraoke.com> (backend)
- **CLI**: `karaoke-gen` (local), `karaoke-gen-remote` (cloud)
- **Repo**: <https://github.com/nomadkaraoke/karaoke-gen>
**Always be testing.** Proactively evaluate, read, run, fix, and improve tests whenever you touch any part of the system—frontend, backend, infrastructure. Every code change should be thoroughly tested. Leave everything better tested than you found it.
## Quick Reference
**Always be documenting.** Continuously read, write, improve, update, and organize markdown documentation. Reference existing docs and keep them accurate as the codebase evolves.
| What | Where |
|------|-------|
| Product vision & goals | `docs/PRODUCT-VISION.md` |
| Current status | `docs/README.md` |
| Architecture | `docs/ARCHITECTURE.md` |
| Dev setup & testing | `docs/DEVELOPMENT.md` |
| API reference | `docs/API.md` |
| Past learnings | `docs/LESSONS-LEARNED.md` |
**Build for maintainability.** Keep code SOLID, modular, and clean. Favor simplicity and clarity. Future developers (and AI agents) will thank you.
## Tech Stack
## Branching Workflow
- **Backend**: FastAPI on Cloud Run, Firestore, GCS, Secret Manager
- **Frontend**: Next.js on Cloudflare Pages
- **Processing**: Modal (GPU audio separation), AudioShake/Whisper (transcription)
- **Infra**: Pulumi IaC, GitHub Actions CI/CD
**Never commit directly to `main`.** Always work on a feature branch.
## Essential Rules
Create descriptive branch names like `feature/add-discord-notifications`, `fix/audio-sync-issue`, or `refactor/cleanup-api-routes`.
### Git Workflow
- **Never commit directly to `main`** - use `/new-worktree <description>` to start
- **Follow global workflow** - see `~/.claude/CLAUDE.md` for command sequence
- Create PR with summary, changes, testing info
- Merge only after CI passes
### Using Git Worktrees
### Testing (Required Before Commit)
**For non-trivial changes** (new features, multi-file edits, refactors):
- Create a git worktree in the parent folder before making any file changes:
```bash
git worktree add ../karaoke-gen-feat-xyz feature/xyz
```
- This keeps the main directory clean on `main` and enables parallel work on multiple features
- Name the worktree folder descriptively, e.g., `../karaoke-gen-fix-audio-sync`
**For trivial changes** (typos, single-line fixes):
- Creating a branch in the current directory is acceptable
- Use `git checkout -b fix/typo-xyz` before making changes
**Cleanup:** When done with a worktree, remove it with:
```bash
# Backend (10 min timeout, limit output)
make test 2>&1 | tail -n 500
git worktree remove ../karaoke-gen-feat-xyz
```
# Frontend
### Creating a Pull Request
Once all changes are complete, tests pass, and commits are pushed, create a PR with:
1. **Summary** - Brief overview of the changes
2. **Changes Made** - List of specific modifications
3. **Testing** - How changes were tested (unit tests, manual testing)
4. **Related Issues** - Reference any GitHub issues (e.g., "Fixes #123")
Only merge after review and CI checks pass.
## Infrastructure Changes
All Google Cloud infrastructure (IAM, Cloud Storage, Cloud Run, Secret Manager, Artifact Registry, etc.) must be managed via **Pulumi IaC** in the `infrastructure/` folder.
### Rules
- **Reading/querying** with `gcloud` CLI is fine for investigation and debugging
- **Temporary changes** via `gcloud` CLI or Console are acceptable for urgent fixes or experimentation, but **must be cleaned up** and properly codified in the IaC afterward
- **Permanent changes** must go through Pulumi — never leave `gcloud` or Console changes as the final state
### Workflow
1. Make changes in `infrastructure/`
2. Run `pulumi preview` and verify the output
3. Run `pulumi up` to apply
### Authentication Issues
If you encounter any authentication issues with `gcloud` or `pulumi` (e.g., expired tokens, permission errors), **stop and notify the user** so they can run the appropriate auth commands in their external terminal:
```bash
gcloud auth login
gcloud auth application-default login
```
Do not attempt to work around auth issues or make assumptions about credentials.
## Version Management
When committing and pushing changes, always bump the patch version in `pyproject.toml`.
The version is located at `tool.poetry.version` in `pyproject.toml`. For example, if the current version is `0.70.3`, bump it to `0.70.4`.
This ensures every commit pushed to the repository has a unique version number for tracking and deployment purposes.
## Testing Requirements
**Before committing and pushing ANY changes, you MUST run the full test suite.**
### Backend Test Command
```bash
make test 2>&1 | tail -n 500
```
**Important for AI agents:**
- Set a **10 minute timeout** when running tests (they can take a while with emulators)
- Always pipe output through `tail -n 500` to limit output and preserve context window
- The tail output will show test results and any failures at the end
This runs all backend tests in order and fails fast if any test fails:
1. Unit tests (karaoke_gen package) with coverage check
2. Backend unit tests
3. E2E integration tests with emulators (auto-starts/stops emulators)
### Frontend Test Command
When working in the `frontend/` directory, run:
```bash
cd frontend && npm run test:all 2>&1 | tail -n 200
```
### Version Bumping
- Bump `tool.poetry.version` in `pyproject.toml` for code changes
- Skip for docs-only changes
This runs:
1. **Unit tests** (Jest) - Component and utility tests
2. **E2E tests** (Playwright) - Browser-based integration tests
### Infrastructure
- All GCP changes via Pulumi in `infrastructure/`
- `gcloud` CLI for reading/debugging only
- Stop and notify user on auth issues
**Note:** E2E tests require `KARAOKE_ACCESS_TOKEN` environment variable to be set in `frontend/.env.local`.
## Documentation Maintenance
Individual test commands:
- `npm run test:unit` - Run unit tests only
- `npm run test:e2e` - Run E2E tests only
- `npm run test:ci` - Run unit tests with coverage
### Structure
```text
docs/
├── README.md # Current status + navigation (UPDATE THIS)
├── ARCHITECTURE.md # System design
├── DEVELOPMENT.md # Dev setup, testing, deployment
├── API.md # Backend API reference
├── LESSONS-LEARNED.md # Key insights for future agents
└── archive/ # Historical docs (YYYY-MM-DD-topic.md)
```
### Pre-commit Checklist
### Rules
1. **Before merging PRs**: Run `/docs-review` to check if docs need updating
2. **Periodically**: Run `/docs-maintain` to verify docs are organized
3. **For significant work**: Create `docs/archive/YYYY-MM-DD-topic.md`
4. **Add learnings**: Update `docs/LESSONS-LEARNED.md` with insights
5. **Keep status current**: Update `docs/README.md` when project state changes
- [ ] `make test` passes (for backend changes)
- [ ] `cd frontend && npm run test:all` passes (for frontend changes)
- [ ] Version in `pyproject.toml` has been bumped
- [ ] `coderabbit review --plain` has been run to get comprehensive analysis and suggestions for cleaner, more maintainable code. Apply the feedback to improve accessibility, structure, and best practices.
### What Goes Where
- **README.md**: Current status, known issues, quick links
- **ARCHITECTURE.md**: System design, data flow, tech decisions
- **DEVELOPMENT.md**: Setup, testing, deployment, CI/CD
- **API.md**: Endpoints, request/response formats
- **LESSONS-LEARNED.md**: What worked, what didn't, gotchas
- **archive/**: Completed work, session summaries, old plans
**Do not commit or push code that fails tests. Fix any test failures before proceeding.**
## Related Projects
### flacfetch
Location: `/Users/andrew/Projects/flacfetch`
Workflow: Make changes on `main`, bump version, push, wait for CI, then `poetry update flacfetch` in karaoke-gen.
## Pre-PR Checklist
Follow global workflow (`~/.claude/CLAUDE.md`):
- [ ] Tests pass: `/test` (or `make test` / `npm run test:all`)
- [ ] Version bumped (if code changed)
- [ ] Docs checked: `/docs-review`
- [ ] Code reviewed: `/review` (CodeRabbit CLI)
- [ ] PR created: `/pr` (adds @coderabbitai ignore)
+2 -72
View File
@@ -71,40 +71,8 @@ export AUDIOSHAKE_API_TOKEN="your_audioshake_token"
Get an API key at [https://www.audioshake.ai/](https://www.audioshake.ai/) - business only, at time of writing this.
#### Option 2: Local Whisper (No Cloud Required)
Run Whisper directly on your local machine using whisper-timestamped. Works on CPU, NVIDIA GPU (CUDA), or Apple Silicon.
```bash
# Install with local Whisper support
pip install "karaoke-gen[local-whisper]"
# Optional: Configure model size (tiny, base, small, medium, large)
export WHISPER_MODEL_SIZE="medium"
# Optional: Force specific device (cpu, cuda, mps)
export WHISPER_DEVICE="cpu"
```
**Model Size Guide:**
| Model | VRAM | Speed | Quality |
|-------|------|-------|---------|
| tiny | ~1GB | Fast | Lower |
| base | ~1GB | Fast | Basic |
| small | ~2GB | Medium | Good |
| medium | ~5GB | Slower | Better |
| large | ~10GB | Slowest | Best |
**CPU-Only Installation** (no GPU required):
```bash
# Pre-install CPU-only PyTorch first
pip install torch torchaudio --index-url https://download.pytorch.org/whl/cpu
pip install "karaoke-gen[local-whisper]"
```
Local Whisper runs automatically as a fallback when no cloud transcription services are configured.
#### Option 3: Whisper via RunPod
Cloud-based alternative using OpenAI's Whisper model on RunPod infrastructure.
#### Option 2: Whisper via RunPod
Open-source alternative using OpenAI's Whisper model on RunPod infrastructure.
```bash
export RUNPOD_API_KEY="your_runpod_key"
@@ -606,44 +574,6 @@ If the output video has quality problems:
- Check available codecs: `ffmpeg -codecs`
- For 4K output, ensure sufficient disk space (10GB+ per track)
### Local Whisper Issues
#### GPU Out of Memory
If you get CUDA out of memory errors:
```bash
# Use a smaller model
export WHISPER_MODEL_SIZE="small" # or "tiny"
# Or force CPU mode
export WHISPER_DEVICE="cpu"
```
#### Slow Transcription on CPU
CPU transcription is significantly slower than GPU. For faster processing:
- Use a smaller model (`tiny` or `base`)
- Consider using cloud transcription (AudioShake or RunPod)
- On Apple Silicon, the `small` model offers good speed/quality balance
#### Model Download Issues
Whisper models are downloaded on first use (~1-3GB depending on size). If downloads fail:
- Check your internet connection
- Set a custom cache directory: `export WHISPER_CACHE_DIR="/path/with/space"`
- Models are cached in `~/.cache/whisper/` by default
#### whisper-timestamped Not Found
If you get "whisper-timestamped is not installed":
```bash
pip install "karaoke-gen[local-whisper]"
# Or install directly:
pip install whisper-timestamped
```
#### Disabling Local Whisper
If you want to disable local Whisper (e.g., to force cloud transcription):
```bash
export ENABLE_LOCAL_WHISPER="false"
```
---
## 🧪 Development
-75
View File
@@ -1,75 +0,0 @@
[
{
"test_name": "Sound-alike error (wurld -> world)",
"success": true,
"proposals": [
{
"action": "ReplaceWord",
"word_id": null,
"word_ids": [
"w1"
],
"replacement_text": "world",
"confidence": 0.75,
"reason": "Sound-alike error. Reference suggests: 'world'. The transcription 'wurld' is a phonetic misspelling or sound-alike of the word 'world' which appears in both reference sources (Genius and LRCLIB).",
"gap_category": "GapCategory.SOUND_ALIKE",
"requires_human_review": false
}
]
},
{
"test_name": "Punctuation difference",
"success": true,
"proposals": [
{
"action": "NoAction",
"word_id": null,
"word_ids": [
"w2"
],
"replacement_text": null,
"confidence": 0.99,
"reason": "Transcription matches at least one reference source. The gap text 'Hello' followed by the context 'is it me you're looking for' matches the Genius reference lyrics exactly, excluding punctuation. According to the guidelines, if any reference source matches the transcription text (ignoring punctuation), it should be classified as NO_ERROR.",
"gap_category": "GapCategory.NO_ERROR",
"requires_human_review": false
}
]
},
{
"test_name": "Extra filler word",
"success": true,
"proposals": [
{
"action": "DeleteWord",
"word_id": "w3",
"word_ids": null,
"replacement_text": null,
"confidence": 0.8,
"reason": "Extra filler word 'And' at sentence start not in reference. The transcription includes the filler word 'And' at the beginning of the phrase, which is not present in the reference lyrics. This matches the definition of EXTRA_WORDS.",
"gap_category": "GapCategory.EXTRA_WORDS",
"requires_human_review": false
}
]
},
{
"test_name": "Complex multi-word error",
"success": true,
"proposals": [
{
"action": "NoAction",
"word_id": null,
"word_ids": [
"w7",
"w8",
"w9",
"w10"
],
"replacement_text": null,
"confidence": 0.99,
"reason": "Transcription matches at least one reference source. The transcription text 'gonna give you up' matches the Genius reference lyrics exactly when ignoring punctuation and capitalization. In context, the full phrase 'never gonna give you up' is correctly transcribed and aligns perfectly with the known lyrics and title of the song.",
"gap_category": "GapCategory.NO_ERROR",
"requires_human_review": false
}
]
}
]
+1 -30
View File
@@ -10,43 +10,14 @@ FROM python:3.11-slim
# Note: Transmission daemon removed - torrent downloads now handled by
# dedicated flacfetch VM service (see docs/00-current-plan/TORRENT-SERVICE-PLAN.md)
RUN apt-get update && apt-get install -y \
ffmpeg \
libsndfile1 \
libsox-dev \
sox \
build-essential \
curl \
xz-utils \
&& rm -rf /var/lib/apt/lists/*
# Install comprehensive font support for international lyrics and symbols
# Noto fonts provide full Unicode coverage including:
# - Latin, Greek, Cyrillic (core)
# - CJK: Chinese, Japanese, Korean (~150MB)
# - Arabic, Hebrew, Thai, Hindi, and other scripts (extra)
# - Color emoji (limited support in libass, but available)
# - Musical symbols (♪ ♫ etc.)
# Note: This adds ~200-300MB to the image but ensures all languages render correctly
RUN apt-get update && apt-get install -y \
fonts-noto-core \
fonts-noto-cjk \
fonts-noto-extra \
fonts-noto-color-emoji \
fontconfig \
&& fc-cache -f \
&& rm -rf /var/lib/apt/lists/*
# Install optimized static FFmpeg build (7.0.2) instead of Debian package (5.1.8)
# John Van Sickle's builds are compiled with better optimizations for x86_64
# This provides ~20-40% performance improvement for encoding tasks
# Source: https://johnvansickle.com/ffmpeg/
RUN curl -L https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-amd64-static.tar.xz -o /tmp/ffmpeg.tar.xz && \
tar -xf /tmp/ffmpeg.tar.xz -C /tmp && \
cp /tmp/ffmpeg-*-amd64-static/ffmpeg /usr/local/bin/ && \
cp /tmp/ffmpeg-*-amd64-static/ffprobe /usr/local/bin/ && \
chmod +x /usr/local/bin/ffmpeg /usr/local/bin/ffprobe && \
rm -rf /tmp/ffmpeg* && \
ffmpeg -version
# Set working directory
WORKDIR /app
+70 -182
View File
@@ -4,11 +4,11 @@ FastAPI dependencies for authentication and authorization.
import logging
import secrets
from datetime import datetime, timedelta, UTC
from typing import Optional, Tuple, Callable, Union
from typing import Optional, Tuple, Callable
from fastapi import Depends, HTTPException, Header, Query, Request, Path
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
from backend.services.auth_service import get_auth_service, UserType, AuthService, AuthResult
from backend.services.auth_service import get_auth_service, UserType, AuthService
logger = logging.getLogger(__name__)
@@ -66,130 +66,70 @@ async def require_auth(
auth_service: AuthService = Depends(get_auth_service),
credentials: Optional[HTTPAuthorizationCredentials] = Depends(security),
token: Optional[str] = Query(None)
) -> AuthResult:
) -> Tuple[str, UserType, int]:
"""
Require authentication for an endpoint.
Returns:
AuthResult with full authentication context including:
- is_valid, user_type, remaining_uses, message (backward compatible via tuple unpacking)
- user_email: Email of authenticated user (if session/API key auth)
- is_admin: Whether user has admin privileges
(token, user_type, remaining_uses)
Raises:
HTTPException: 401 if authentication fails
"""
# Get token from request
token_str = await get_token_from_request(request, credentials, token)
if not token_str:
raise HTTPException(
status_code=401,
detail="Authentication required. Provide token via Authorization header or ?token= parameter"
)
# Validate token using the full method
auth_result = auth_service.validate_token_full(token_str)
# Get request_id from middleware for correlation
request_id = getattr(request.state, "request_id", None)
if not auth_result.is_valid:
# Log auth failure with request_id for correlation
# Validate token
is_valid, user_type, remaining_uses, message = auth_service.validate_token(token_str)
if not is_valid:
# Log more details for debugging token issues
auth_header = request.headers.get("Authorization", "")
logger.warning(
"auth_failed",
extra={
"request_id": request_id,
"audit_type": "auth_event",
"auth_message": auth_result.message,
"token_provided": bool(token_str),
"token_length": len(token_str) if token_str else 0,
"auth_header_present": bool(auth_header),
}
f"Authentication failed: {message}. "
f"Token provided: {bool(token_str)}, "
f"Token length: {len(token_str) if token_str else 0}, "
f"Auth header present: {bool(auth_header)}, "
f"Header prefix: {auth_header[:20] if auth_header else 'none'}..."
)
raise HTTPException(
status_code=401,
detail=f"Authentication failed: {auth_result.message}"
)
# Log successful auth with request_id for correlation with request audit
logger.info(
"auth_success",
extra={
"request_id": request_id,
"user_email": auth_result.user_email,
"user_type": auth_result.user_type.value if auth_result.user_type else None,
"is_admin": auth_result.is_admin,
"remaining_uses": auth_result.remaining_uses,
"audit_type": "auth_event",
}
)
return auth_result
async def require_auth_legacy(
request: Request,
auth_service: AuthService = Depends(get_auth_service),
credentials: Optional[HTTPAuthorizationCredentials] = Depends(security),
token: Optional[str] = Query(None)
) -> Tuple[str, UserType, int]:
"""
Legacy authentication dependency that returns tuple.
DEPRECATED: Use require_auth which returns AuthResult instead.
Returns:
(token, user_type, remaining_uses)
"""
token_str = await get_token_from_request(request, credentials, token)
if not token_str:
raise HTTPException(
status_code=401,
detail="Authentication required. Provide token via Authorization header or ?token= parameter"
)
is_valid, user_type, remaining_uses, message = auth_service.validate_token(token_str)
if not is_valid:
raise HTTPException(
status_code=401,
detail=f"Authentication failed: {message}"
)
logger.info(f"Authenticated as {user_type} (remaining: {remaining_uses})")
return token_str, user_type, remaining_uses
async def require_admin(
auth_result: AuthResult = Depends(require_auth)
) -> AuthResult:
auth_data: Tuple[str, UserType, int] = Depends(require_auth)
) -> Tuple[str, UserType, int]:
"""
Require admin access for an endpoint.
Admin access is granted if:
- Using an admin token from ADMIN_TOKENS env var
- User email is from admin domain (e.g., @nomadkaraoke.com)
- User role is set to ADMIN in database
Returns:
AuthResult with admin privileges
(token, user_type, remaining_uses)
Raises:
HTTPException: 403 if user is not admin
"""
if not auth_result.is_admin:
logger.warning(
f"Admin access denied for {auth_result.user_type} user "
f"(email: {auth_result.user_email or 'unknown'})"
)
token, user_type, remaining_uses = auth_data
if user_type != UserType.ADMIN:
logger.warning(f"Admin access denied for {user_type} user")
raise HTTPException(
status_code=403,
detail="Admin access required"
)
return auth_result
return token, user_type, remaining_uses
def optional_auth(
@@ -228,14 +168,14 @@ def optional_auth(
def require_review_auth_factory(job_id_param: str = "job_id"):
"""
Factory to create a review authentication dependency.
Accepts either:
1. Full user authentication (admin/user token) - also validates job ownership
1. Full user authentication (admin/user token)
2. Job-specific review token (only valid for the specific job)
Args:
job_id_param: Name of the path parameter containing the job ID
Returns:
Dependency function that validates review access
"""
@@ -249,63 +189,37 @@ def require_review_auth_factory(job_id_param: str = "job_id"):
) -> Tuple[str, str]:
"""
Validate review access for a job.
Returns:
(job_id, auth_type) where auth_type is "full" or "review_token"
Raises:
HTTPException: 401 if authentication fails
HTTPException: 403 if user doesn't own the job (for full auth)
"""
# Import here to avoid circular dependency
from backend.services.job_manager import JobManager
job_manager = JobManager()
# Try full authentication first
full_token = None
if credentials:
full_token = credentials.credentials
elif token:
full_token = token
if full_token:
auth_result = auth_service.validate_token_full(full_token)
if auth_result.is_valid:
# For full auth, also verify job ownership
job = job_manager.get_job(job_id)
if not job:
raise HTTPException(status_code=404, detail=f"Job {job_id} not found")
# Check ownership: admin can access all, users only their own jobs
if not auth_result.is_admin:
if auth_result.user_email and job.user_email:
if auth_result.user_email.lower() != job.user_email.lower():
logger.warning(
f"Review access denied: user {auth_result.user_email} "
f"tried to access job {job_id} owned by {job.user_email}"
)
raise HTTPException(
status_code=403,
detail="You don't have permission to access this job's review"
)
elif job.user_email:
# Token auth without email trying to access a job with owner
raise HTTPException(
status_code=403,
detail="You don't have permission to access this job's review"
)
logger.info(f"Review access granted via full auth ({auth_result.user_type}) for job {job_id}")
is_valid, user_type, remaining_uses, message = auth_service.validate_token(full_token)
if is_valid:
logger.info(f"Review access granted via full auth ({user_type}) for job {job_id}")
return job_id, "full"
# Try review token
if review_token:
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")
# Validate review token matches
if job.review_token and secrets.compare_digest(job.review_token, review_token):
# Check expiry if set
@@ -315,25 +229,25 @@ def require_review_auth_factory(job_id_param: str = "job_id"):
expiry = job.review_token_expires_at
if expiry.tzinfo is None:
expiry = expiry.replace(tzinfo=UTC)
if now > expiry:
logger.warning(f"Review token expired for job {job_id}")
raise HTTPException(
status_code=401,
detail="Review token has expired. Please request a new review link."
)
logger.info(f"Review access granted via review_token for job {job_id}")
return job_id, "review_token"
else:
logger.warning(f"Invalid review token for job {job_id}")
# No valid authentication
raise HTTPException(
status_code=401,
detail="Authentication required. Provide either a full access token or a valid review_token for this job."
)
return require_review_auth
@@ -344,14 +258,14 @@ require_review_auth = require_review_auth_factory()
def require_instrumental_auth_factory(job_id_param: str = "job_id"):
"""
Factory to create an instrumental review authentication dependency.
Accepts either:
1. Full user authentication (admin/user token) - also validates job ownership
1. Full user authentication (admin/user token)
2. Job-specific instrumental token (only valid for the specific job)
Args:
job_id_param: Name of the path parameter containing the job ID
Returns:
Dependency function that validates instrumental review access
"""
@@ -365,63 +279,37 @@ def require_instrumental_auth_factory(job_id_param: str = "job_id"):
) -> Tuple[str, str]:
"""
Validate instrumental review access for a job.
Returns:
(job_id, auth_type) where auth_type is "full" or "instrumental_token"
Raises:
HTTPException: 401 if authentication fails
HTTPException: 403 if user doesn't own the job (for full auth)
"""
# Import here to avoid circular dependency
from backend.services.job_manager import JobManager
job_manager = JobManager()
# Try full authentication first
full_token = None
if credentials:
full_token = credentials.credentials
elif token:
full_token = token
if full_token:
auth_result = auth_service.validate_token_full(full_token)
if auth_result.is_valid:
# For full auth, also verify job ownership
job = job_manager.get_job(job_id)
if not job:
raise HTTPException(status_code=404, detail=f"Job {job_id} not found")
# Check ownership: admin can access all, users only their own jobs
if not auth_result.is_admin:
if auth_result.user_email and job.user_email:
if auth_result.user_email.lower() != job.user_email.lower():
logger.warning(
f"Instrumental access denied: user {auth_result.user_email} "
f"tried to access job {job_id} owned by {job.user_email}"
)
raise HTTPException(
status_code=403,
detail="You don't have permission to access this job's instrumental review"
)
elif job.user_email:
# Token auth without email trying to access a job with owner
raise HTTPException(
status_code=403,
detail="You don't have permission to access this job's instrumental review"
)
logger.info(f"Instrumental access granted via full auth ({auth_result.user_type}) for job {job_id}")
is_valid, user_type, remaining_uses, message = auth_service.validate_token(full_token)
if is_valid:
logger.info(f"Instrumental access granted via full auth ({user_type}) for job {job_id}")
return job_id, "full"
# Try instrumental token
if instrumental_token:
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")
# Validate instrumental token matches
if job.instrumental_token and secrets.compare_digest(job.instrumental_token, instrumental_token):
# Check expiry if set
@@ -431,25 +319,25 @@ def require_instrumental_auth_factory(job_id_param: str = "job_id"):
expiry = job.instrumental_token_expires_at
if expiry.tzinfo is None:
expiry = expiry.replace(tzinfo=UTC)
if now > expiry:
logger.warning(f"Instrumental token expired for job {job_id}")
raise HTTPException(
status_code=401,
detail="Instrumental review token has expired. Please request a new review link."
)
logger.info(f"Instrumental access granted via instrumental_token for job {job_id}")
return job_id, "instrumental_token"
else:
logger.warning(f"Invalid instrumental token for job {job_id}")
# No valid authentication
raise HTTPException(
status_code=401,
detail="Authentication required. Provide either a full access token or a valid instrumental_token for this job."
)
return require_instrumental_auth
-582
View File
@@ -1,582 +0,0 @@
"""
Admin API routes for dashboard statistics and management.
Handles:
- Dashboard overview statistics
- System-wide metrics
- Admin-only operations
- Audio search cache management
"""
import logging
from datetime import datetime, timedelta
from typing import Tuple, List, Optional, Any, Dict
from fastapi import APIRouter, Depends, HTTPException
from pydantic import BaseModel
from backend.api.dependencies import require_admin
from backend.services.auth_service import UserType
from backend.services.user_service import get_user_service, UserService, USERS_COLLECTION
from backend.services.job_manager import JobManager
from backend.services.flacfetch_client import get_flacfetch_client, FlacfetchServiceError
from backend.models.job import JobStatus
logger = logging.getLogger(__name__)
router = APIRouter(prefix="/admin", tags=["admin"])
# =============================================================================
# Response Models
# =============================================================================
class JobsByStatusResponse(BaseModel):
"""Breakdown of jobs by status."""
pending: int = 0
processing: int = 0
awaiting_review: int = 0
awaiting_instrumental: int = 0
complete: int = 0
failed: int = 0
cancelled: int = 0
class AdminStatsOverview(BaseModel):
"""Overview statistics for admin dashboard."""
total_users: int
active_users_7d: int
active_users_30d: int
total_jobs: int
jobs_last_7d: int
jobs_last_30d: int
jobs_by_status: JobsByStatusResponse
total_credits_issued_30d: int
total_beta_testers: int
# =============================================================================
# Admin Stats Endpoints
# =============================================================================
@router.get("/stats/overview", response_model=AdminStatsOverview)
async def get_admin_stats_overview(
auth_data: Tuple[str, UserType, int] = Depends(require_admin),
user_service: UserService = Depends(get_user_service),
):
"""
Get overview statistics for admin dashboard.
Includes:
- User counts (total, active in 7d, active in 30d)
- Job counts (total, by status, recent)
- Credit statistics
- Beta program stats
"""
from google.cloud.firestore_v1 import FieldFilter
from google.cloud.firestore_v1 import aggregation
db = user_service.db
now = datetime.utcnow()
seven_days_ago = now - timedelta(days=7)
thirty_days_ago = now - timedelta(days=30)
# Helper function to get count using aggregation
def get_count(query) -> int:
try:
agg_query = aggregation.AggregationQuery(query)
agg_query.count(alias="count")
results = agg_query.get()
return results[0][0].value if results else 0
except Exception as e:
logger.warning(f"Aggregation query failed: {e}")
return 0
# User statistics
users_collection = db.collection(USERS_COLLECTION)
total_users = get_count(users_collection)
active_users_7d = get_count(
users_collection.where(filter=FieldFilter("last_login_at", ">=", seven_days_ago))
)
active_users_30d = get_count(
users_collection.where(filter=FieldFilter("last_login_at", ">=", thirty_days_ago))
)
total_beta_testers = get_count(
users_collection.where(filter=FieldFilter("is_beta_tester", "==", True))
)
# Job statistics
jobs_collection = db.collection("jobs")
total_jobs = get_count(jobs_collection)
jobs_last_7d = get_count(
jobs_collection.where(filter=FieldFilter("created_at", ">=", seven_days_ago))
)
jobs_last_30d = get_count(
jobs_collection.where(filter=FieldFilter("created_at", ">=", thirty_days_ago))
)
# Jobs by status - map multiple statuses to simplified categories
processing_statuses = [
"downloading", "downloading_audio", "searching_audio", "awaiting_audio_selection",
"separating_stage1", "separating_stage2", "transcribing", "correcting",
"generating_screens", "applying_padding", "rendering_video",
"instrumental_selected", "generating_video", "encoding", "packaging",
"uploading", "notifying"
]
jobs_by_status = JobsByStatusResponse(
pending=get_count(
jobs_collection.where(filter=FieldFilter("status", "==", "pending"))
),
processing=sum(
get_count(jobs_collection.where(filter=FieldFilter("status", "==", status)))
for status in processing_statuses
),
awaiting_review=get_count(
jobs_collection.where(filter=FieldFilter("status", "==", "awaiting_review"))
) + get_count(
jobs_collection.where(filter=FieldFilter("status", "==", "in_review"))
),
awaiting_instrumental=get_count(
jobs_collection.where(filter=FieldFilter("status", "==", "awaiting_instrumental_selection"))
),
complete=get_count(
jobs_collection.where(filter=FieldFilter("status", "==", "complete"))
) + get_count(
jobs_collection.where(filter=FieldFilter("status", "==", "prep_complete"))
),
failed=get_count(
jobs_collection.where(filter=FieldFilter("status", "==", "failed"))
),
cancelled=get_count(
jobs_collection.where(filter=FieldFilter("status", "==", "cancelled"))
),
)
# Credit statistics - sum credits added in last 30 days
# This is more expensive, so we'll just estimate from users
total_credits_issued_30d = 0
try:
# Get all users and sum recent credit transactions
users_docs = users_collection.limit(500).stream()
for user_doc in users_docs:
user_data = user_doc.to_dict()
transactions = user_data.get("credit_transactions", [])
for txn in transactions:
txn_date = txn.get("created_at")
if txn_date:
# Handle both datetime and string formats
if isinstance(txn_date, str):
try:
txn_date = datetime.fromisoformat(txn_date.replace("Z", "+00:00"))
except Exception:
continue
if isinstance(txn_date, datetime):
txn_date = txn_date.replace(tzinfo=None)
else:
continue
if txn_date >= thirty_days_ago:
amount = txn.get("amount", 0)
if amount > 0: # Only count additions, not deductions
total_credits_issued_30d += amount
except Exception as e:
logger.warning(f"Error calculating credits: {e}")
return AdminStatsOverview(
total_users=total_users,
active_users_7d=active_users_7d,
active_users_30d=active_users_30d,
total_jobs=total_jobs,
jobs_last_7d=jobs_last_7d,
jobs_last_30d=jobs_last_30d,
jobs_by_status=jobs_by_status,
total_credits_issued_30d=total_credits_issued_30d,
total_beta_testers=total_beta_testers,
)
# =============================================================================
# Audio Search Management Models
# =============================================================================
class AudioSearchResultSummary(BaseModel):
"""Summary of a single audio search result."""
index: int
provider: str
artist: str
title: str
is_lossless: bool
quality: Optional[str] = None
seeders: Optional[int] = None
class AudioSearchJobSummary(BaseModel):
"""Summary of a job with audio search results."""
job_id: str
status: str
user_email: Optional[str] = None
audio_search_artist: Optional[str] = None
audio_search_title: Optional[str] = None
created_at: Optional[datetime] = None
results_count: int
results_summary: List[AudioSearchResultSummary]
has_lossless: bool
providers: List[str]
class AudioSearchListResponse(BaseModel):
"""Response for listing audio search jobs."""
jobs: List[AudioSearchJobSummary]
total: int
class ClearSearchCacheResponse(BaseModel):
"""Response for clearing search cache."""
status: str
job_id: str
message: str
previous_status: str
new_status: str
results_cleared: int
flacfetch_cache_cleared: bool = False
flacfetch_error: Optional[str] = None
class ClearAllCacheResponse(BaseModel):
"""Response for clearing all flacfetch cache."""
status: str
message: str
deleted_count: int
class CacheStatsResponse(BaseModel):
"""Response for cache statistics."""
count: int
total_size_bytes: int
oldest_entry: Optional[str] = None
newest_entry: Optional[str] = None
configured: bool
# =============================================================================
# Audio Search Management Endpoints
# =============================================================================
@router.get("/audio-searches", response_model=AudioSearchListResponse)
async def list_audio_searches(
limit: int = 50,
status_filter: Optional[str] = None,
auth_data: Tuple[str, UserType, int] = Depends(require_admin),
user_service: UserService = Depends(get_user_service),
):
"""
List jobs with audio search results.
Returns jobs that have cached audio search results, useful for:
- Monitoring search activity
- Identifying stale cached results
- Clearing cache for specific jobs
Args:
limit: Maximum number of jobs to return (default 50)
status_filter: Optional filter by job status (e.g., 'awaiting_audio_selection')
"""
from google.cloud.firestore_v1 import FieldFilter
db = user_service.db
jobs_collection = db.collection("jobs")
# Query jobs - we'll filter for those with audio_search_results in Python
# since Firestore can't query for existence of nested fields efficiently
query = jobs_collection.order_by("created_at", direction="DESCENDING").limit(500)
if status_filter:
query = jobs_collection.where(
filter=FieldFilter("status", "==", status_filter)
).order_by("created_at", direction="DESCENDING").limit(500)
jobs_with_searches = []
for doc in query.stream():
data = doc.to_dict()
state_data = data.get("state_data", {})
audio_results = state_data.get("audio_search_results", [])
if not audio_results:
continue
# Compute has_lossless and providers from ALL results (not just first 10)
has_lossless = any(r.get("is_lossless", False) for r in audio_results)
providers = {r.get("provider", "Unknown") for r in audio_results}
# Build summary from first 10 results only
results_summary = []
for r in audio_results[:10]:
results_summary.append(AudioSearchResultSummary(
index=r.get("index", 0),
provider=r.get("provider", "Unknown"),
artist=r.get("artist", ""),
title=r.get("title", ""),
is_lossless=r.get("is_lossless", False),
quality=r.get("quality"),
seeders=r.get("seeders"),
))
jobs_with_searches.append(AudioSearchJobSummary(
job_id=doc.id,
status=data.get("status", "unknown"),
user_email=data.get("user_email"),
audio_search_artist=data.get("audio_search_artist"),
audio_search_title=data.get("audio_search_title"),
created_at=data.get("created_at"),
results_count=len(audio_results),
results_summary=results_summary,
has_lossless=has_lossless,
providers=sorted(providers),
))
if len(jobs_with_searches) >= limit:
break
return AudioSearchListResponse(
jobs=jobs_with_searches,
total=len(jobs_with_searches),
)
@router.post("/audio-searches/{job_id}/clear-cache", response_model=ClearSearchCacheResponse)
async def clear_audio_search_cache(
job_id: str,
auth_data: Tuple[str, UserType, int] = Depends(require_admin),
user_service: UserService = Depends(get_user_service),
):
"""
Clear the cached audio search results for a job.
This will:
1. Remove the cached search results from job.state_data
2. Reset the job status to 'pending' so a new search can be performed
3. Clear the flacfetch GCS cache for this artist/title (if available)
Use this when:
- Cached results are stale (e.g., flacfetch was updated)
- User wants to search again with different terms
- Results appear incomplete or incorrect
"""
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")
# Get current state
state_data = job.state_data or {}
audio_results = state_data.get("audio_search_results", [])
results_count = len(audio_results)
previous_status = job.status
if not audio_results:
raise HTTPException(
status_code=400,
detail=f"Job {job_id} has no cached audio search results"
)
# Validate job status - only allow cache clear for appropriate states
# Don't allow clearing cache for jobs that are actively processing or complete
forbidden_statuses = {
"downloading", "downloading_audio", "searching_audio",
"separating_stage1", "separating_stage2", "transcribing", "correcting",
"generating_screens", "applying_padding", "rendering_video",
"generating_video", "encoding", "packaging", "uploading",
"complete", "prep_complete",
}
if previous_status in forbidden_statuses:
raise HTTPException(
status_code=400,
detail=f"Cannot clear cache for job in '{previous_status}' state. "
f"Only jobs in pending, awaiting_audio_selection, failed, or cancelled states can have cache cleared."
)
# Clear the cache by removing the keys
db = user_service.db
job_ref = db.collection("jobs").document(job_id)
from google.cloud.firestore_v1 import DELETE_FIELD
# Update job: clear cache and reset status
job_ref.update({
"state_data.audio_search_results": DELETE_FIELD,
"state_data.audio_search_count": DELETE_FIELD,
"state_data.remote_search_id": DELETE_FIELD,
"status": "pending",
"progress": 0,
"message": "Audio search cache cleared by admin. Ready for new search.",
"updated_at": datetime.utcnow(),
})
# Also clear flacfetch's GCS cache if we have artist/title
flacfetch_cache_cleared = False
flacfetch_error = None
artist = job.audio_search_artist
title = job.audio_search_title
if artist and title:
flacfetch_client = get_flacfetch_client()
if flacfetch_client:
try:
flacfetch_cache_cleared = await flacfetch_client.clear_search_cache(artist, title)
logger.info(
f"Cleared flacfetch cache for '{artist}' - '{title}': "
f"{'deleted' if flacfetch_cache_cleared else 'no entry found'}"
)
except FlacfetchServiceError as e:
flacfetch_error = str(e)
logger.warning(f"Failed to clear flacfetch cache: {e}")
else:
flacfetch_error = "flacfetch client not configured"
logger.debug("Skipping flacfetch cache clear - client not configured")
else:
flacfetch_error = "missing artist or title"
logger.debug(f"Skipping flacfetch cache clear - missing artist ({artist}) or title ({title})")
logger.info(
f"Admin {auth_data[0]} cleared audio search cache for job {job_id}. "
f"Cleared {results_count} results. Status changed from {previous_status} to pending. "
f"Flacfetch cache cleared: {flacfetch_cache_cleared}"
)
message = f"Cleared {results_count} cached search results. Job reset to pending."
if flacfetch_cache_cleared:
message += " Flacfetch cache also cleared."
elif flacfetch_error:
message += f" Note: flacfetch cache not cleared ({flacfetch_error})."
return ClearSearchCacheResponse(
status="success",
job_id=job_id,
message=message,
previous_status=previous_status,
new_status="pending",
results_cleared=results_count,
flacfetch_cache_cleared=flacfetch_cache_cleared,
flacfetch_error=flacfetch_error,
)
@router.post("/jobs/{job_id}/reset-worker-state")
async def reset_worker_state(
job_id: str,
auth_data: Tuple[str, UserType, int] = Depends(require_admin),
):
"""
Reset stale worker progress state for a job.
This clears the video_progress, render_progress, and screens_progress
from state_data, allowing workers to be re-triggered.
Use this when a job is stuck because worker progress shows 'running'
from a previous failed attempt.
"""
from backend.services.job_manager import JobManager
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")
# Reset worker progress states
job_manager.update_state_data(job_id, 'video_progress', {'stage': 'pending'})
job_manager.update_state_data(job_id, 'render_progress', {'stage': 'pending'})
job_manager.update_state_data(job_id, 'screens_progress', {'stage': 'pending'})
logger.info(f"Admin {auth_data[0]} reset worker state for job {job_id}")
return {
"status": "success",
"job_id": job_id,
"message": "Worker progress states reset to pending"
}
@router.delete("/cache", response_model=ClearAllCacheResponse)
async def clear_all_flacfetch_cache(
auth_data: Tuple[str, UserType, int] = Depends(require_admin),
):
"""
Clear the entire flacfetch search cache.
This will delete all cached search results from flacfetch's GCS cache.
Use with caution - this will cause all subsequent searches to hit
the trackers fresh.
Note: This does NOT clear Firestore job.state_data caches, only the
flacfetch-side GCS cache.
"""
flacfetch_client = get_flacfetch_client()
if not flacfetch_client:
raise HTTPException(
status_code=503,
detail="flacfetch client not configured"
)
try:
deleted_count = await flacfetch_client.clear_all_cache()
logger.info(
f"Admin {auth_data[0]} cleared all flacfetch cache. "
f"Deleted {deleted_count} entries."
)
return ClearAllCacheResponse(
status="success",
message=f"Cleared {deleted_count} cache entries from flacfetch.",
deleted_count=deleted_count,
)
except FlacfetchServiceError as e:
logger.error(f"Failed to clear all flacfetch cache: {e}")
raise HTTPException(
status_code=502,
detail=f"Failed to clear flacfetch cache: {e}"
)
@router.get("/cache/stats", response_model=CacheStatsResponse)
async def get_flacfetch_cache_stats(
auth_data: Tuple[str, UserType, int] = Depends(require_admin),
):
"""
Get statistics about the flacfetch search cache.
Returns information about:
- Number of cached entries
- Total size in bytes
- Oldest and newest cache entries
- Whether cache is configured
"""
flacfetch_client = get_flacfetch_client()
if not flacfetch_client:
raise HTTPException(
status_code=503,
detail="flacfetch client not configured"
)
try:
stats = await flacfetch_client.get_cache_stats()
return CacheStatsResponse(
count=stats.get("count", 0),
total_size_bytes=stats.get("total_size_bytes", 0),
oldest_entry=stats.get("oldest_entry"),
newest_entry=stats.get("newest_entry"),
configured=stats.get("configured", True),
)
except FlacfetchServiceError as e:
logger.error(f"Failed to get flacfetch cache stats: {e}")
raise HTTPException(
status_code=502,
detail=f"Failed to get cache stats: {e}"
)
# Trigger deployment
+13 -105
View File
@@ -35,7 +35,7 @@ from backend.services.audio_search_service import (
from backend.config import get_settings
from backend.version import VERSION
from backend.api.dependencies import require_auth
from backend.services.auth_service import UserType, AuthResult
from backend.services.auth_service import UserType
from pathlib import Path
logger = logging.getLogger(__name__)
@@ -85,13 +85,9 @@ class AudioSearchRequest(BaseModel):
# Auto-download mode
auto_download: bool = Field(False, description="Automatically select best result and download")
# Theme configuration
theme_id: Optional[str] = Field(None, description="Theme ID to use (e.g., 'nomad', 'default'). If set, CDG/TXT are enabled by default.")
color_overrides: Optional[Dict[str, str]] = Field(None, description="Color overrides: artist_color, title_color, sung_lyrics_color, unsung_lyrics_color (hex #RRGGBB)")
# Processing options (CDG/TXT require style config or theme, disabled by default unless theme is set)
enable_cdg: Optional[bool] = Field(None, description="Generate CDG+MP3 package. Default: True if theme_id set, False otherwise")
enable_txt: Optional[bool] = Field(None, description="Generate TXT+MP3 package. Default: True if theme_id set, False otherwise")
# Processing options (CDG/TXT require style config, disabled by default)
enable_cdg: bool = Field(False, description="Generate CDG+MP3 package (requires style config)")
enable_txt: bool = Field(False, description="Generate TXT+MP3 package (requires style config)")
# Finalisation options
brand_prefix: Optional[str] = Field(None, description="Brand code prefix (e.g., NOMAD)")
@@ -117,9 +113,6 @@ class AudioSearchRequest(BaseModel):
# Style params JSON and related assets (background images, fonts)
style_files: Optional[List[StyleFileRequest]] = Field(None, description="Style files to upload (style_params JSON, backgrounds, fonts)")
# Non-interactive mode
non_interactive: bool = Field(False, description="Skip interactive steps (lyrics review, instrumental selection)")
class AudioSearchResultResponse(BaseModel):
"""A single audio search result.
@@ -187,35 +180,6 @@ class AudioSelectResponse(BaseModel):
selected_provider: str
def _resolve_cdg_txt_defaults(
theme_id: Optional[str],
enable_cdg: Optional[bool],
enable_txt: Optional[bool]
) -> Tuple[bool, bool]:
"""
Resolve CDG/TXT settings based on theme and explicit settings.
When a theme is selected, CDG and TXT are enabled by default.
Explicit True/False values always override the default.
Args:
theme_id: Theme identifier (if any)
enable_cdg: Explicit CDG setting (None means use default)
enable_txt: Explicit TXT setting (None means use default)
Returns:
Tuple of (resolved_enable_cdg, resolved_enable_txt)
"""
# Default based on whether theme is set
default_enabled = theme_id is not None
# Explicit values override defaults, None uses default
resolved_cdg = enable_cdg if enable_cdg is not None else default_enabled
resolved_txt = enable_txt if enable_txt is not None else default_enabled
return resolved_cdg, resolved_txt
def extract_request_metadata(request: Request, created_from: str = "audio_search") -> Dict[str, Any]:
"""Extract metadata from request for job tracking."""
headers = dict(request.headers)
@@ -375,31 +339,8 @@ async def _download_and_start_processing(
target_file=target_file,
download_url=download_url,
)
elif source_name == 'YouTube' and download_url:
# For YouTube without remote, download directly using URL from state_data
# This avoids relying on in-memory cache which doesn't persist across instances
logger.info(f"Downloading YouTube audio directly from URL: {download_url}")
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 DownloadError(f"Failed to download from YouTube: {download_url}")
# Create a result-like object
class DownloadResult:
def __init__(self, filepath):
self.filepath = filepath
result = DownloadResult(local_path)
else:
# Fallback to search-based download (may fail if cache is empty)
logger.warning(f"Falling back to cache-based download for {source_name} - this may fail on multi-instance deployments")
# Fallback to search-based download
result = audio_search_service.download(
result_index=selection_index,
output_dir=temp_dir,
@@ -462,7 +403,7 @@ async def search_audio(
request: Request,
background_tasks: BackgroundTasks,
body: AudioSearchRequest,
auth_result: AuthResult = Depends(require_auth)
auth_data: Tuple[str, UserType, int] = Depends(require_auth)
):
"""
Search for audio by artist and title, creating a new job.
@@ -520,23 +461,13 @@ async def search_audio(
# Extract request metadata
request_metadata = extract_request_metadata(request, created_from="audio_search")
# Resolve CDG/TXT defaults based on theme
resolved_cdg, resolved_txt = _resolve_cdg_txt_defaults(
body.theme_id, body.enable_cdg, body.enable_txt
)
# Use authenticated user's email
effective_user_email = auth_result.user_email
# Create job
job_create = JobCreate(
artist=body.artist,
title=body.title,
theme_id=body.theme_id,
color_overrides=body.color_overrides or {},
enable_cdg=resolved_cdg,
enable_txt=resolved_txt,
enable_cdg=body.enable_cdg,
enable_txt=body.enable_txt,
brand_prefix=effective_brand_prefix,
enable_youtube_upload=effective_enable_youtube_upload,
youtube_description=effective_youtube_description,
@@ -544,7 +475,6 @@ async def search_audio(
discord_webhook_url=effective_discord_webhook_url,
dropbox_path=effective_dropbox_path,
gdrive_folder_id=effective_gdrive_folder_id,
user_email=effective_user_email,
lyrics_artist=body.lyrics_artist,
lyrics_title=body.lyrics_title,
subtitle_offset_ms=body.subtitle_offset_ms,
@@ -555,11 +485,10 @@ async def search_audio(
audio_search_title=body.title,
auto_download=body.auto_download,
request_metadata=request_metadata,
non_interactive=body.non_interactive,
)
job = job_manager.create_job(job_create)
job_id = job.job_id
logger.info(f"Created job {job_id} for audio search: {body.artist} - {body.title}")
# Update job with audio search fields
@@ -568,28 +497,7 @@ async def search_audio(
'audio_search_title': body.title,
'auto_download': body.auto_download,
})
# If theme is set and no custom style files are being uploaded, prepare theme style now
# This copies the theme's style_params.json to the job folder so LyricsTranscriber
# can access the style configuration for preview videos
if body.theme_id and not body.style_files:
from backend.api.routes.file_upload import _prepare_theme_for_job
try:
style_params_path, theme_style_assets, youtube_desc = _prepare_theme_for_job(
job_id, body.theme_id, body.color_overrides
)
theme_update = {
'style_params_gcs_path': style_params_path,
'style_assets': theme_style_assets,
}
if youtube_desc and not effective_youtube_description:
theme_update['youtube_description_template'] = youtube_desc
job_manager.update_job(job_id, theme_update)
logger.info(f"Applied theme '{body.theme_id}' to job {job_id}")
except Exception as e:
logger.warning(f"Failed to prepare theme '{body.theme_id}' for job {job_id}: {e}")
# Continue without theme - job can still be processed with defaults
# Handle style file uploads if provided
style_upload_urls: List[StyleUploadUrl] = []
style_assets = {}
@@ -797,7 +705,7 @@ async def search_audio(
@router.get("/audio-search/{job_id}/results")
async def get_audio_search_results(
job_id: str,
auth_result: AuthResult = Depends(require_auth)
auth_data: Tuple[str, UserType, int] = Depends(require_auth)
):
"""
Get audio search results for a job.
@@ -832,7 +740,7 @@ async def select_audio_source(
job_id: str,
background_tasks: BackgroundTasks,
body: AudioSelectRequest,
auth_result: AuthResult = Depends(require_auth)
auth_data: Tuple[str, UserType, int] = Depends(require_auth)
):
"""
Select an audio source and start job processing.
+115 -263
View File
@@ -15,7 +15,6 @@ import json
import logging
import tempfile
import os
from dataclasses import dataclass
from fastapi import APIRouter, UploadFile, File, Form, HTTPException, BackgroundTasks, Request, Body, Depends
from pathlib import Path
from typing import Optional, List, Dict, Any, Tuple
@@ -33,7 +32,7 @@ from backend.config import get_settings
from backend.version import VERSION
from backend.services.metrics import metrics
from backend.api.dependencies import require_auth
from backend.services.auth_service import UserType, AuthResult
from backend.services.auth_service import UserType
logger = logging.getLogger(__name__)
router = APIRouter(tags=["jobs"])
@@ -92,9 +91,6 @@ class CreateJobFromUrlRequest(BaseModel):
backing_vocals_models: Optional[List[str]] = Field(None, description="Models for backing vocals separation")
other_stems_models: Optional[List[str]] = Field(None, description="Models for other stems")
# Non-interactive mode
non_interactive: bool = Field(False, description="Skip interactive steps (lyrics review, instrumental selection)")
class CreateJobFromUrlResponse(BaseModel):
"""Response from creating a job from URL."""
@@ -153,9 +149,6 @@ class CreateJobWithUploadUrlsRequest(BaseModel):
prep_only: bool = Field(False, description="Stop after review phase, don't run finalisation")
keep_brand_code: Optional[str] = Field(None, description="Preserve existing brand code instead of generating new one")
# Non-interactive mode
non_interactive: bool = Field(False, description="Skip interactive steps (lyrics review, instrumental selection)")
class SignedUploadUrl(BaseModel):
"""Signed URL for uploading a file."""
@@ -253,16 +246,6 @@ async def _trigger_workers_parallel(job_id: str) -> None:
)
async def _trigger_audio_worker_only(job_id: str) -> None:
"""
Trigger only the audio worker.
Used for URL jobs where audio needs to be downloaded first.
The audio worker will trigger the lyrics worker after download completes.
"""
await worker_service.trigger_audio_worker(job_id)
def _resolve_cdg_txt_defaults(
theme_id: Optional[str],
enable_cdg: Optional[bool],
@@ -292,46 +275,6 @@ def _resolve_cdg_txt_defaults(
return resolved_cdg, resolved_txt
@dataclass
class EffectiveDistributionSettings:
"""Settings with defaults applied from environment variables."""
dropbox_path: Optional[str]
gdrive_folder_id: Optional[str]
discord_webhook_url: Optional[str]
brand_prefix: Optional[str]
def _get_effective_distribution_settings(
dropbox_path: Optional[str] = None,
gdrive_folder_id: Optional[str] = None,
discord_webhook_url: Optional[str] = None,
brand_prefix: Optional[str] = None,
) -> EffectiveDistributionSettings:
"""
Get distribution settings with defaults applied from environment variables.
This ensures consistent handling of defaults across all job creation endpoints.
Each parameter, if not provided (None), falls back to the corresponding
environment variable configured in settings.
Args:
dropbox_path: Explicit Dropbox path or None for default
gdrive_folder_id: Explicit Google Drive folder ID or None for default
discord_webhook_url: Explicit Discord webhook URL or None for default
brand_prefix: Explicit brand prefix or None for default
Returns:
EffectiveDistributionSettings with defaults applied
"""
settings = get_settings()
return EffectiveDistributionSettings(
dropbox_path=dropbox_path or settings.default_dropbox_path,
gdrive_folder_id=gdrive_folder_id or settings.default_gdrive_folder_id,
discord_webhook_url=discord_webhook_url or settings.default_discord_webhook_url,
brand_prefix=brand_prefix or settings.default_brand_prefix,
)
def _prepare_theme_for_job(
job_id: str,
theme_id: str,
@@ -384,7 +327,7 @@ def _prepare_theme_for_job(
async def upload_and_create_job(
request: Request,
background_tasks: BackgroundTasks,
auth_result: AuthResult = Depends(require_auth),
auth_data: Tuple[str, UserType, int] = Depends(require_auth),
# Required fields
file: UploadFile = File(..., description="Audio file to process"),
artist: str = Form(..., description="Artist name"),
@@ -398,12 +341,9 @@ async def upload_and_create_job(
style_cdg_instrumental_background: Optional[UploadFile] = File(None, description="CDG instrumental background"),
style_cdg_title_background: Optional[UploadFile] = File(None, description="CDG title screen background"),
style_cdg_outro_background: Optional[UploadFile] = File(None, description="CDG outro screen background"),
# Theme configuration (use pre-made theme from GCS)
theme_id: Optional[str] = Form(None, description="Theme ID to use (e.g., 'nomad', 'default'). If set, CDG/TXT are enabled by default."),
color_overrides: Optional[str] = Form(None, description="JSON-encoded color overrides: artist_color, title_color, sung_lyrics_color, unsung_lyrics_color (hex #RRGGBB)"),
# Processing options (CDG/TXT require style config or theme, disabled by default unless theme is set)
enable_cdg: Optional[bool] = Form(None, description="Generate CDG+MP3 package. Default: True if theme_id set, False otherwise"),
enable_txt: Optional[bool] = Form(None, description="Generate TXT+MP3 package. Default: True if theme_id set, False otherwise"),
# Processing options (CDG/TXT require style config, disabled by default)
enable_cdg: bool = Form(False, description="Generate CDG+MP3 package (requires style config)"),
enable_txt: bool = Form(False, description="Generate TXT+MP3 package (requires style config)"),
# Finalisation options
brand_prefix: Optional[str] = Form(None, description="Brand code prefix (e.g., NOMAD)"),
enable_youtube_upload: bool = Form(False, description="Upload to YouTube"),
@@ -425,8 +365,6 @@ async def upload_and_create_job(
clean_instrumental_model: Optional[str] = Form(None, description="Model for clean instrumental separation (e.g., model_bs_roformer_ep_317_sdr_12.9755.ckpt)"),
backing_vocals_models: Optional[str] = Form(None, description="Comma-separated list of models for backing vocals separation"),
other_stems_models: Optional[str] = Form(None, description="Comma-separated list of models for other stems (bass, drums, guitar, etc.)"),
# Non-interactive mode
non_interactive: bool = Form(False, description="Skip interactive steps (lyrics review, instrumental selection)"),
):
"""
Upload an audio file and create a karaoke generation job with full style configuration.
@@ -494,42 +432,38 @@ async def upload_and_create_job(
)
# Apply default distribution settings from environment if not provided
dist = _get_effective_distribution_settings(
dropbox_path=dropbox_path,
gdrive_folder_id=gdrive_folder_id,
discord_webhook_url=discord_webhook_url,
brand_prefix=brand_prefix,
)
if dist.dropbox_path and not dropbox_path:
logger.info(f"Using default dropbox_path: {dist.dropbox_path}")
if dist.gdrive_folder_id and not gdrive_folder_id:
logger.info(f"Using default gdrive_folder_id: {dist.gdrive_folder_id}")
if dist.discord_webhook_url and not discord_webhook_url:
settings = get_settings()
effective_dropbox_path = dropbox_path or settings.default_dropbox_path
effective_gdrive_folder_id = gdrive_folder_id or settings.default_gdrive_folder_id
effective_discord_webhook_url = discord_webhook_url or settings.default_discord_webhook_url
if effective_dropbox_path and not dropbox_path:
logger.info(f"Using default dropbox_path: {effective_dropbox_path}")
if effective_gdrive_folder_id and not gdrive_folder_id:
logger.info(f"Using default gdrive_folder_id: {effective_gdrive_folder_id}")
if effective_discord_webhook_url and not discord_webhook_url:
logger.info("Using default discord_webhook_url (from env)")
if dist.brand_prefix and not brand_prefix:
logger.info(f"Using default brand_prefix: {dist.brand_prefix}")
# Validate credentials for requested distribution services (including defaults)
# This prevents accepting jobs that will fail later due to missing credentials
invalid_services = []
credential_manager = get_credential_manager()
if enable_youtube_upload:
result = credential_manager.check_youtube_credentials()
if result.status != CredentialStatus.VALID:
invalid_services.append(f"youtube ({result.message})")
if dist.dropbox_path:
if effective_dropbox_path:
result = credential_manager.check_dropbox_credentials()
if result.status != CredentialStatus.VALID:
invalid_services.append(f"dropbox ({result.message})")
if dist.gdrive_folder_id:
if effective_gdrive_folder_id:
result = credential_manager.check_gdrive_credentials()
if result.status != CredentialStatus.VALID:
invalid_services.append(f"gdrive ({result.message})")
if invalid_services:
raise HTTPException(
status_code=400,
@@ -543,35 +477,7 @@ async def upload_and_create_job(
# Extract request metadata for tracking and filtering
request_metadata = extract_request_metadata(request, created_from="upload")
# Parse color_overrides from JSON if provided
parsed_color_overrides: Dict[str, str] = {}
if color_overrides:
try:
parsed_color_overrides = json.loads(color_overrides)
except json.JSONDecodeError as e:
raise HTTPException(
status_code=400,
detail=f"Invalid color_overrides JSON: {e}"
)
# Resolve CDG/TXT defaults based on theme
resolved_cdg, resolved_txt = _resolve_cdg_txt_defaults(
theme_id, enable_cdg, enable_txt
)
# Check if any custom style files are being uploaded (overrides theme)
has_custom_style_files = any([
style_params,
style_intro_background,
style_karaoke_background,
style_end_background,
style_font,
style_cdg_instrumental_background,
style_cdg_title_background,
style_cdg_outro_background,
])
# Parse comma-separated model lists into arrays
parsed_backing_vocals_models = None
if backing_vocals_models:
@@ -581,27 +487,22 @@ async def upload_and_create_job(
if other_stems_models:
parsed_other_stems_models = [m.strip() for m in other_stems_models.split(',') if m.strip()]
# Prefer authenticated user's email over form parameter
effective_user_email = auth_result.user_email or user_email
# Create job first to get job_id
job_create = JobCreate(
artist=artist,
title=title,
filename=file.filename,
theme_id=theme_id,
color_overrides=parsed_color_overrides,
enable_cdg=resolved_cdg,
enable_txt=resolved_txt,
brand_prefix=dist.brand_prefix,
enable_cdg=enable_cdg,
enable_txt=enable_txt,
brand_prefix=brand_prefix,
enable_youtube_upload=enable_youtube_upload,
youtube_description=youtube_description,
discord_webhook_url=dist.discord_webhook_url,
discord_webhook_url=effective_discord_webhook_url,
webhook_url=webhook_url,
user_email=effective_user_email,
user_email=user_email,
# Native API distribution (preferred for remote CLI)
dropbox_path=dist.dropbox_path,
gdrive_folder_id=dist.gdrive_folder_id,
dropbox_path=effective_dropbox_path,
gdrive_folder_id=effective_gdrive_folder_id,
# Legacy rclone distribution (deprecated)
organised_dir_rclone_root=organised_dir_rclone_root,
# Lyrics configuration (overrides for search/transcription)
@@ -614,35 +515,15 @@ async def upload_and_create_job(
other_stems_models=parsed_other_stems_models,
# Request metadata for tracking and filtering
request_metadata=request_metadata,
# Non-interactive mode
non_interactive=non_interactive,
)
job = job_manager.create_job(job_create)
job_id = job.job_id
# Record job creation metric
metrics.record_job_created(job_id, source="upload")
logger.info(f"Created job {job_id} for {artist} - {title}")
# If theme is set and no custom style files are being uploaded, prepare theme style now
# This copies the theme's style_params.json to the job folder so LyricsTranscriber
# can access the style configuration for preview videos
theme_style_params_path = None
theme_style_assets = {}
theme_youtube_desc = None
if theme_id and not has_custom_style_files:
try:
theme_style_params_path, theme_style_assets, theme_youtube_desc = _prepare_theme_for_job(
job_id, theme_id, parsed_color_overrides or None
)
logger.info(f"Applied theme '{theme_id}' to job {job_id}")
except HTTPException:
raise # Re-raise validation errors (e.g., theme not found)
except Exception as e:
logger.warning(f"Failed to prepare theme '{theme_id}' for job {job_id}: {e}")
# Continue without theme - job can still be processed with defaults
# Upload main audio file to GCS
audio_gcs_path = f"uploads/{job_id}/audio/{file.filename}"
logger.info(f"Uploading audio to GCS: {audio_gcs_path}")
@@ -711,36 +592,27 @@ async def upload_and_create_job(
update_data = {
'input_media_gcs_path': audio_gcs_path,
'filename': file.filename,
'enable_cdg': resolved_cdg,
'enable_txt': resolved_txt,
'enable_cdg': enable_cdg,
'enable_txt': enable_txt,
}
# Handle style assets - either from custom uploads or from theme
if style_assets:
# Custom style files uploaded
update_data['style_assets'] = style_assets
if 'style_params' in style_assets:
update_data['style_params_gcs_path'] = style_assets['style_params']
elif theme_style_assets:
# Theme style assets (no custom uploads)
update_data['style_assets'] = theme_style_assets
if theme_style_params_path:
update_data['style_params_gcs_path'] = theme_style_params_path
if dist.brand_prefix:
update_data['brand_prefix'] = dist.brand_prefix
if dist.discord_webhook_url:
update_data['discord_webhook_url'] = dist.discord_webhook_url
# Use theme YouTube description if no custom one provided
effective_youtube_description = youtube_description or theme_youtube_desc
if effective_youtube_description:
update_data['youtube_description_template'] = effective_youtube_description
if brand_prefix:
update_data['brand_prefix'] = brand_prefix
if effective_discord_webhook_url:
update_data['discord_webhook_url'] = effective_discord_webhook_url
if youtube_description:
update_data['youtube_description_template'] = youtube_description
# Native API distribution (use effective values which include defaults)
if dist.dropbox_path:
update_data['dropbox_path'] = dist.dropbox_path
if dist.gdrive_folder_id:
update_data['gdrive_folder_id'] = dist.gdrive_folder_id
if effective_dropbox_path:
update_data['dropbox_path'] = effective_dropbox_path
if effective_gdrive_folder_id:
update_data['gdrive_folder_id'] = effective_gdrive_folder_id
# Legacy rclone distribution (deprecated)
if organised_dir_rclone_root:
@@ -796,21 +668,21 @@ async def upload_and_create_job(
# Build distribution services info for response
distribution_services: Dict[str, Any] = {}
if dist.dropbox_path:
if effective_dropbox_path:
dropbox_result = credential_manager.check_dropbox_credentials()
distribution_services["dropbox"] = {
"enabled": True,
"path": dist.dropbox_path,
"path": effective_dropbox_path,
"credentials_valid": dropbox_result.status == CredentialStatus.VALID,
"using_default": dropbox_path is None,
}
if dist.gdrive_folder_id:
if effective_gdrive_folder_id:
gdrive_result = credential_manager.check_gdrive_credentials()
distribution_services["gdrive"] = {
"enabled": True,
"folder_id": dist.gdrive_folder_id,
"folder_id": effective_gdrive_folder_id,
"credentials_valid": gdrive_result.status == CredentialStatus.VALID,
"using_default": gdrive_folder_id is None,
}
@@ -822,7 +694,7 @@ async def upload_and_create_job(
"credentials_valid": youtube_result.status == CredentialStatus.VALID,
}
if dist.discord_webhook_url:
if effective_discord_webhook_url:
distribution_services["discord"] = {
"enabled": True,
"using_default": discord_webhook_url is None,
@@ -996,7 +868,7 @@ def _get_gcs_path_for_file(job_id: str, file_type: str, filename: str) -> str:
async def create_job_with_upload_urls(
request: Request,
body: CreateJobWithUploadUrlsRequest,
auth_result: AuthResult = Depends(require_auth)
auth_data: Tuple[str, UserType, int] = Depends(require_auth)
):
"""
Create a karaoke generation job and return signed URLs for direct file upload to GCS.
@@ -1039,34 +911,32 @@ async def create_job_with_upload_urls(
status_code=400,
detail=f"Invalid file extension '{ext}' for file_type '{file_info.file_type}'. Allowed: {allowed_extensions}"
)
# Apply default distribution settings from environment if not provided
dist = _get_effective_distribution_settings(
dropbox_path=body.dropbox_path,
gdrive_folder_id=body.gdrive_folder_id,
discord_webhook_url=body.discord_webhook_url,
brand_prefix=body.brand_prefix,
)
settings = get_settings()
effective_dropbox_path = body.dropbox_path or settings.default_dropbox_path
effective_gdrive_folder_id = body.gdrive_folder_id or settings.default_gdrive_folder_id
effective_discord_webhook_url = body.discord_webhook_url or settings.default_discord_webhook_url
# Validate credentials for requested distribution services
invalid_services = []
credential_manager = get_credential_manager()
if body.enable_youtube_upload:
result = credential_manager.check_youtube_credentials()
if result.status != CredentialStatus.VALID:
invalid_services.append(f"youtube ({result.message})")
if dist.dropbox_path:
if effective_dropbox_path:
result = credential_manager.check_dropbox_credentials()
if result.status != CredentialStatus.VALID:
invalid_services.append(f"dropbox ({result.message})")
if dist.gdrive_folder_id:
if effective_gdrive_folder_id:
result = credential_manager.check_gdrive_credentials()
if result.status != CredentialStatus.VALID:
invalid_services.append(f"gdrive ({result.message})")
if invalid_services:
raise HTTPException(
status_code=400,
@@ -1077,7 +947,7 @@ async def create_job_with_upload_urls(
"auth_url": "/api/auth/status"
}
)
# Extract request metadata for tracking
request_metadata = extract_request_metadata(request, created_from="signed_url_upload")
@@ -1092,9 +962,6 @@ async def create_job_with_upload_urls(
# Check if style_params is being uploaded (overrides theme)
has_style_params_upload = any(f.file_type == 'style_params' for f in body.files)
# Prefer authenticated user's email over request body
effective_user_email = auth_result.user_email or body.user_email
# Create job
job_create = JobCreate(
artist=body.artist,
@@ -1104,15 +971,14 @@ async def create_job_with_upload_urls(
color_overrides=body.color_overrides or {},
enable_cdg=resolved_cdg,
enable_txt=resolved_txt,
brand_prefix=dist.brand_prefix,
brand_prefix=body.brand_prefix,
enable_youtube_upload=body.enable_youtube_upload,
youtube_description=body.youtube_description,
youtube_description_template=body.youtube_description, # video_worker reads this field
discord_webhook_url=dist.discord_webhook_url,
discord_webhook_url=effective_discord_webhook_url,
webhook_url=body.webhook_url,
user_email=effective_user_email,
dropbox_path=dist.dropbox_path,
gdrive_folder_id=dist.gdrive_folder_id,
user_email=body.user_email,
dropbox_path=effective_dropbox_path,
gdrive_folder_id=effective_gdrive_folder_id,
organised_dir_rclone_root=body.organised_dir_rclone_root,
lyrics_artist=body.lyrics_artist,
lyrics_title=body.lyrics_title,
@@ -1121,7 +987,6 @@ async def create_job_with_upload_urls(
backing_vocals_models=body.backing_vocals_models,
other_stems_models=body.other_stems_models,
request_metadata=request_metadata,
non_interactive=body.non_interactive,
)
job = job_manager.create_job(job_create)
job_id = job.job_id
@@ -1187,7 +1052,7 @@ async def mark_uploads_complete(
job_id: str,
background_tasks: BackgroundTasks,
body: UploadsCompleteRequest,
auth_result: AuthResult = Depends(require_auth)
auth_data: Tuple[str, UserType, int] = Depends(require_auth)
):
"""
Mark file uploads as complete and start job processing.
@@ -1433,7 +1298,7 @@ async def create_job_from_url(
request: Request,
background_tasks: BackgroundTasks,
body: CreateJobFromUrlRequest,
auth_result: AuthResult = Depends(require_auth)
auth_data: Tuple[str, UserType, int] = Depends(require_auth)
):
"""
Create a karaoke generation job from a YouTube or other online video URL.
@@ -1457,34 +1322,32 @@ async def create_job_from_url(
status_code=400,
detail="Invalid URL. Please provide a valid YouTube, Vimeo, SoundCloud, or other supported video URL."
)
# Apply default distribution settings from environment if not provided
dist = _get_effective_distribution_settings(
dropbox_path=body.dropbox_path,
gdrive_folder_id=body.gdrive_folder_id,
discord_webhook_url=body.discord_webhook_url,
brand_prefix=body.brand_prefix,
)
settings = get_settings()
effective_dropbox_path = body.dropbox_path or settings.default_dropbox_path
effective_gdrive_folder_id = body.gdrive_folder_id or settings.default_gdrive_folder_id
effective_discord_webhook_url = body.discord_webhook_url or settings.default_discord_webhook_url
# Validate credentials for requested distribution services
invalid_services = []
credential_manager = get_credential_manager()
if body.enable_youtube_upload:
result = credential_manager.check_youtube_credentials()
if result.status != CredentialStatus.VALID:
invalid_services.append(f"youtube ({result.message})")
if dist.dropbox_path:
if effective_dropbox_path:
result = credential_manager.check_dropbox_credentials()
if result.status != CredentialStatus.VALID:
invalid_services.append(f"dropbox ({result.message})")
if dist.gdrive_folder_id:
if effective_gdrive_folder_id:
result = credential_manager.check_gdrive_credentials()
if result.status != CredentialStatus.VALID:
invalid_services.append(f"gdrive ({result.message})")
if invalid_services:
raise HTTPException(
status_code=400,
@@ -1495,7 +1358,7 @@ async def create_job_from_url(
"auth_url": "/api/auth/status"
}
)
# Extract request metadata for tracking
request_metadata = extract_request_metadata(request, created_from="url")
@@ -1508,9 +1371,6 @@ async def create_job_from_url(
body.theme_id, body.enable_cdg, body.enable_txt
)
# Prefer authenticated user's email over request body
effective_user_email = auth_result.user_email or body.user_email
# Create job with URL
job_create = JobCreate(
url=body.url,
@@ -1521,14 +1381,14 @@ async def create_job_from_url(
color_overrides=body.color_overrides or {},
enable_cdg=resolved_cdg,
enable_txt=resolved_txt,
brand_prefix=dist.brand_prefix,
brand_prefix=body.brand_prefix,
enable_youtube_upload=body.enable_youtube_upload,
youtube_description=body.youtube_description,
discord_webhook_url=dist.discord_webhook_url,
discord_webhook_url=effective_discord_webhook_url,
webhook_url=body.webhook_url,
user_email=effective_user_email,
dropbox_path=dist.dropbox_path,
gdrive_folder_id=dist.gdrive_folder_id,
user_email=body.user_email,
dropbox_path=effective_dropbox_path,
gdrive_folder_id=effective_gdrive_folder_id,
organised_dir_rclone_root=body.organised_dir_rclone_root,
lyrics_artist=body.lyrics_artist,
lyrics_title=body.lyrics_title,
@@ -1537,7 +1397,6 @@ async def create_job_from_url(
backing_vocals_models=body.backing_vocals_models,
other_stems_models=body.other_stems_models,
request_metadata=request_metadata,
non_interactive=body.non_interactive,
)
job = job_manager.create_job(job_create)
job_id = job.job_id
@@ -1573,11 +1432,10 @@ async def create_job_from_url(
progress=5,
message="Starting audio download from URL"
)
# For URL jobs, trigger ONLY audio worker first
# The audio worker will trigger lyrics worker after download completes
# This prevents race condition where lyrics worker times out waiting for audio
background_tasks.add_task(_trigger_audio_worker_only, job_id)
# Trigger workers in parallel
# The audio worker will handle downloading from URL
background_tasks.add_task(_trigger_workers_parallel, job_id)
return CreateJobFromUrlResponse(
status="success",
@@ -1640,7 +1498,7 @@ def _get_gcs_path_for_finalise_file(job_id: str, file_type: str, filename: str)
async def create_finalise_only_job(
request: Request,
body: CreateFinaliseOnlyJobRequest,
auth_result: AuthResult = Depends(require_auth)
auth_data: Tuple[str, UserType, int] = Depends(require_auth)
):
"""
Create a finalise-only job for continuing from a local prep phase.
@@ -1705,32 +1563,30 @@ async def create_finalise_only_job(
)
# Apply default distribution settings
dist = _get_effective_distribution_settings(
dropbox_path=body.dropbox_path,
gdrive_folder_id=body.gdrive_folder_id,
discord_webhook_url=body.discord_webhook_url,
brand_prefix=body.brand_prefix,
)
settings = get_settings()
effective_dropbox_path = body.dropbox_path or settings.default_dropbox_path
effective_gdrive_folder_id = body.gdrive_folder_id or settings.default_gdrive_folder_id
effective_discord_webhook_url = body.discord_webhook_url or settings.default_discord_webhook_url
# Validate distribution credentials if services are requested
invalid_services = []
credential_manager = get_credential_manager()
if body.enable_youtube_upload:
result = credential_manager.check_youtube_credentials()
if result.status != CredentialStatus.VALID:
invalid_services.append(f"youtube ({result.message})")
if dist.dropbox_path:
if effective_dropbox_path:
result = credential_manager.check_dropbox_credentials()
if result.status != CredentialStatus.VALID:
invalid_services.append(f"dropbox ({result.message})")
if dist.gdrive_folder_id:
if effective_gdrive_folder_id:
result = credential_manager.check_gdrive_credentials()
if result.status != CredentialStatus.VALID:
invalid_services.append(f"gdrive ({result.message})")
if invalid_services:
raise HTTPException(
status_code=400,
@@ -1741,7 +1597,7 @@ async def create_finalise_only_job(
"auth_url": "/api/auth/status"
}
)
# Extract request metadata
request_metadata = extract_request_metadata(request, created_from="finalise_only_upload")
@@ -1753,9 +1609,6 @@ async def create_finalise_only_job(
# Check if style_params is being uploaded (overrides theme)
has_style_params_upload = any(f.file_type == 'style_params' for f in body.files)
# Use authenticated user's email
effective_user_email = auth_result.user_email
# Create job with finalise_only=True
job_create = JobCreate(
artist=body.artist,
@@ -1765,13 +1618,12 @@ async def create_finalise_only_job(
color_overrides=body.color_overrides or {},
enable_cdg=resolved_cdg,
enable_txt=resolved_txt,
brand_prefix=dist.brand_prefix,
brand_prefix=body.brand_prefix,
enable_youtube_upload=body.enable_youtube_upload,
youtube_description=body.youtube_description,
discord_webhook_url=dist.discord_webhook_url,
dropbox_path=dist.dropbox_path,
gdrive_folder_id=dist.gdrive_folder_id,
user_email=effective_user_email,
discord_webhook_url=effective_discord_webhook_url,
dropbox_path=effective_dropbox_path,
gdrive_folder_id=effective_gdrive_folder_id,
finalise_only=True,
keep_brand_code=body.keep_brand_code,
request_metadata=request_metadata,
@@ -1840,7 +1692,7 @@ async def mark_finalise_uploads_complete(
job_id: str,
background_tasks: BackgroundTasks,
body: UploadsCompleteRequest,
auth_result: AuthResult = Depends(require_auth)
auth_data: Tuple[str, UserType, int] = Depends(require_auth)
):
"""
Mark finalise-only file uploads as complete and start video generation.
+4 -173
View File
@@ -3,123 +3,16 @@ Health check routes.
"""
import os
import logging
import subprocess
import platform
from fastapi import APIRouter
from typing import Dict, Any, Optional
from backend.version import VERSION
from backend.services.flacfetch_client import get_flacfetch_client
from backend.services.email_service import get_email_service
from backend.services.stripe_service import get_stripe_service
from backend.services.encoding_service import get_encoding_service
router = APIRouter()
logger = logging.getLogger(__name__)
def get_system_info() -> Dict[str, Any]:
"""Get system information for performance analysis."""
info = {
"platform": platform.system(),
"platform_release": platform.release(),
"python_version": platform.python_version(),
}
# Get CPU info
try:
cpu_count = os.cpu_count() or 0
info["cpu_count"] = cpu_count
# Try to get more detailed CPU info on Linux
if platform.system() == "Linux":
try:
with open("/proc/cpuinfo", "r") as f:
for line in f:
if "model name" in line:
info["cpu_model"] = line.split(":")[1].strip()
break
except Exception:
pass
except Exception as e:
info["cpu_error"] = str(e)
# Get memory info
try:
if platform.system() == "Linux":
with open("/proc/meminfo", "r") as f:
for line in f:
if line.startswith("MemTotal:"):
mem_kb = int(line.split()[1])
info["memory_gb"] = round(mem_kb / (1024 * 1024), 1)
break
except Exception as e:
info["memory_error"] = str(e)
return info
def get_ffmpeg_info() -> Dict[str, Any]:
"""Get FFmpeg version and configuration for debugging encoding performance."""
try:
# Get FFmpeg version
result = subprocess.run(
["ffmpeg", "-version"],
capture_output=True,
text=True,
timeout=10
)
if result.returncode == 0:
lines = result.stdout.split("\n")
version_line = lines[0] if lines else "unknown"
# Check for hardware acceleration support
hw_accel = {}
config_result = subprocess.run(
["ffmpeg", "-hwaccels"],
capture_output=True,
text=True,
timeout=10
)
if config_result.returncode == 0:
hw_lines = config_result.stdout.strip().split("\n")
hw_accel["available"] = [h.strip() for h in hw_lines[1:] if h.strip()]
# Check encoder availability
encoders = {}
encoder_result = subprocess.run(
["ffmpeg", "-encoders"],
capture_output=True,
text=True,
timeout=10
)
if encoder_result.returncode == 0:
encoder_output = encoder_result.stdout
# Check for specific encoders we care about
encoders["libx264"] = "libx264" in encoder_output
encoders["h264_nvenc"] = "h264_nvenc" in encoder_output
encoders["h264_vaapi"] = "h264_vaapi" in encoder_output
encoders["hevc_nvenc"] = "hevc_nvenc" in encoder_output
return {
"available": True,
"version": version_line,
"hw_acceleration": hw_accel,
"encoders": encoders,
}
else:
return {
"available": False,
"error": result.stderr[:500] if result.stderr else "Unknown error",
}
except subprocess.TimeoutExpired:
return {"available": False, "error": "Timeout getting FFmpeg info"}
except FileNotFoundError:
return {"available": False, "error": "FFmpeg not found"}
except Exception as e:
return {"available": False, "error": str(e)}
def check_transmission_status() -> Dict[str, Any]:
"""Check if Transmission daemon is available and responsive."""
try:
@@ -206,96 +99,34 @@ async def check_flacfetch_service_status() -> Dict[str, Any]:
}
async def check_encoding_worker_status() -> Dict[str, Any]:
"""Check if GCE encoding worker is available and healthy."""
encoding_service = get_encoding_service()
if not encoding_service.is_configured:
return {
"configured": False,
"enabled": encoding_service.settings.use_gce_encoding,
"message": "GCE encoding worker not configured (ENCODING_WORKER_URL or API key not set)",
}
try:
health = await encoding_service.health_check()
return {
"configured": True,
"enabled": encoding_service.is_enabled,
"available": health.get("status") == "ok",
"status": health.get("status"),
"active_jobs": health.get("active_jobs", 0),
"queue_length": health.get("queue_length", 0),
"ffmpeg_version": health.get("ffmpeg_version"),
}
except Exception as e:
return {
"configured": True,
"enabled": encoding_service.is_enabled,
"available": False,
"error": str(e),
}
@router.get("/health/detailed")
async def detailed_health_check() -> Dict[str, Any]:
"""
Detailed health check including dependencies.
Use this to debug issues with Transmission, flacfetch service, etc.
"""
transmission_status = check_transmission_status()
flacfetch_status = await check_flacfetch_service_status()
encoding_status = await check_encoding_worker_status()
# Check email service
email_service = get_email_service()
email_status = {
"configured": email_service.is_configured(),
"provider": type(email_service.provider).__name__,
}
# Check Stripe service
stripe_service = get_stripe_service()
stripe_status = {
"configured": stripe_service.is_configured(),
}
# Log for debugging
if not transmission_status.get("available"):
logger.warning(f"Local Transmission not available: {transmission_status.get('error')}")
else:
logger.info(f"Local Transmission available at {transmission_status.get('host')}:{transmission_status.get('port')}")
if flacfetch_status.get("configured") and not flacfetch_status.get("available"):
logger.warning(f"Remote flacfetch service not available: {flacfetch_status.get('error')}")
elif flacfetch_status.get("available"):
logger.info(f"Remote flacfetch service healthy: {flacfetch_status.get('status')}")
if not email_status["configured"]:
logger.warning("Email service not configured - magic links will not work")
if not stripe_status["configured"]:
logger.warning("Stripe service not configured - payments will not work")
# Get system and FFmpeg info for performance analysis
system_info = get_system_info()
ffmpeg_info = get_ffmpeg_info()
return {
"status": "healthy",
"service": "karaoke-gen-backend",
"version": VERSION,
"system": system_info,
"ffmpeg": ffmpeg_info,
"dependencies": {
"transmission_local": transmission_status,
"flacfetch_remote": flacfetch_status,
"encoding_worker": encoding_status,
},
"services": {
"email": email_status,
"stripe": stripe_status,
}
}
+59 -334
View File
@@ -27,7 +27,7 @@ from backend.services.worker_service import get_worker_service
from backend.services.storage_service import StorageService
from backend.config import get_settings
from backend.api.dependencies import require_admin, require_auth, require_instrumental_auth
from backend.services.auth_service import UserType, AuthResult
from backend.services.auth_service import UserType
from backend.services.metrics import metrics
@@ -57,7 +57,7 @@ async def _trigger_workers_parallel(job_id: str) -> None:
async def create_job(
request: URLSubmissionRequest,
background_tasks: BackgroundTasks,
auth_result: AuthResult = Depends(require_auth)
auth_data: Tuple[str, UserType, int] = Depends(require_auth)
) -> JobResponse:
"""
Create a new karaoke generation job from a URL.
@@ -69,24 +69,6 @@ async def create_job(
4. When both complete, job transitions to AWAITING_REVIEW
"""
try:
# Determine job owner email:
# All authentication methods must provide a user_email for job ownership
if auth_result.user_email:
# Use authenticated user's email (standard case)
user_email = auth_result.user_email
else:
# This should never happen - all auth methods now require user_email
logger.error("Authentication succeeded but no user_email provided")
raise HTTPException(
status_code=500,
detail="Authentication error: no user identity available"
)
# Admins can optionally create jobs on behalf of other users
if request.user_email and auth_result.is_admin and request.user_email != auth_result.user_email:
user_email = request.user_email
logger.info(f"Admin {auth_result.user_email} creating job on behalf of {user_email}")
# Create job with all preferences
job_create = JobCreate(
url=str(request.url),
@@ -97,7 +79,7 @@ async def create_job(
enable_youtube_upload=request.enable_youtube_upload,
youtube_description=request.youtube_description,
webhook_url=request.webhook_url,
user_email=user_email
user_email=request.user_email
)
job = job_manager.create_job(job_create)
@@ -127,49 +109,20 @@ async def create_job(
@router.get("/{job_id}", response_model=Job)
async def get_job(
job_id: str,
auth_result: AuthResult = Depends(require_auth)
auth_data: Tuple[str, UserType, int] = Depends(require_auth)
) -> Job:
"""Get job status and details."""
job = job_manager.get_job(job_id)
if not job:
raise HTTPException(status_code=404, detail="Job not found")
# Check ownership - users can only see their own jobs, admins can see all
if not _check_job_ownership(job, auth_result):
raise HTTPException(status_code=403, detail="You don't have permission to access this job")
# If job is complete, include download URLs
if job.status == JobStatus.COMPLETE:
job.download_urls = job_manager.get_output_urls(job_id)
return job
def _check_job_ownership(job: Job, auth_result: AuthResult) -> bool:
"""
Check if the authenticated user owns the job or has admin access.
Returns:
True if user can access the job, False otherwise
"""
# Admins can access all jobs
if auth_result.is_admin:
return True
# Check if user owns the job
if auth_result.user_email and job.user_email:
return auth_result.user_email.lower() == job.user_email.lower()
# If no user_email on auth (token auth without email), deny access to jobs with user_email
# This prevents token-based auth from accessing user jobs
if job.user_email:
return False
# Legacy jobs without user_email - allow access for backward compatibility
# TODO: Consider restricting this in the future
return True
@router.get("", response_model=List[Job])
async def list_jobs(
status: Optional[JobStatus] = None,
@@ -178,13 +131,11 @@ async def list_jobs(
created_after: Optional[str] = None,
created_before: Optional[str] = None,
limit: int = 100,
auth_result: AuthResult = Depends(require_auth)
auth_data: Tuple[str, UserType, int] = Depends(require_auth)
) -> List[Job]:
"""
List jobs with optional filters.
Regular users only see their own jobs. Admins see all jobs.
Args:
status: Filter by job status (pending, complete, failed, etc.)
environment: Filter by request_metadata.environment (test/production/development)
@@ -192,52 +143,37 @@ async def list_jobs(
created_after: Filter jobs created after this ISO datetime (e.g., 2024-01-01T00:00:00Z)
created_before: Filter jobs created before this ISO datetime
limit: Maximum number of jobs to return (default 100)
Returns:
List of jobs matching filters, ordered by created_at descending
"""
from datetime import datetime
try:
# Parse datetime strings if provided
created_after_dt = None
created_before_dt = None
if created_after:
try:
created_after_dt = datetime.fromisoformat(created_after.replace('Z', '+00:00'))
except ValueError as e:
raise HTTPException(status_code=400, detail=f"Invalid created_after format: {created_after}") from e
except ValueError:
raise HTTPException(status_code=400, detail=f"Invalid created_after format: {created_after}")
if created_before:
try:
created_before_dt = datetime.fromisoformat(created_before.replace('Z', '+00:00'))
except ValueError as e:
raise HTTPException(status_code=400, detail=f"Invalid created_before format: {created_before}") from e
# Determine user_email filter based on admin status
# Admins see all jobs, regular users only see their own
user_email_filter = None
if not auth_result.is_admin:
if auth_result.user_email:
user_email_filter = auth_result.user_email
logger.debug(f"Filtering jobs for user: {user_email_filter}")
else:
# Token-based auth without user email - show no jobs for security
logger.warning("Non-admin auth without user_email, returning empty job list")
return []
except ValueError:
raise HTTPException(status_code=400, detail=f"Invalid created_before format: {created_before}")
jobs = job_manager.list_jobs(
status=status,
environment=environment,
client_id=client_id,
created_after=created_after_dt,
created_before=created_before_dt,
user_email=user_email_filter,
limit=limit
)
logger.debug(f"Listed {len(jobs)} jobs for user={auth_result.user_email}, admin={auth_result.is_admin}")
return jobs
except HTTPException:
raise
@@ -250,20 +186,16 @@ async def list_jobs(
async def delete_job(
job_id: str,
delete_files: bool = True,
auth_result: AuthResult = Depends(require_auth)
auth_data: Tuple[str, UserType, int] = Depends(require_auth)
) -> dict:
"""Delete a job and optionally its output files."""
try:
job = job_manager.get_job(job_id)
if not job:
raise HTTPException(status_code=404, detail="Job not found")
# Check ownership - users can only delete their own jobs
if not _check_job_ownership(job, auth_result):
raise HTTPException(status_code=403, detail="You don't have permission to delete this job")
job_manager.delete_job(job_id, delete_files=delete_files)
return {"status": "success", "message": f"Job {job_id} deleted"}
except HTTPException:
raise
@@ -280,7 +212,7 @@ async def bulk_delete_jobs(
created_before: Optional[str] = None,
delete_files: bool = True,
confirm: bool = False,
_auth_result: AuthResult = Depends(require_admin)
auth_data: Tuple[str, UserType, int] = Depends(require_admin)
) -> dict:
"""
Delete multiple jobs matching filter criteria.
@@ -384,22 +316,18 @@ async def bulk_delete_jobs(
@router.get("/{job_id}/review-data")
async def get_review_data(
job_id: str,
auth_result: AuthResult = Depends(require_auth)
auth_data: Tuple[str, UserType, int] = Depends(require_auth)
) -> Dict[str, Any]:
"""
Get data needed for lyrics review interface.
Returns corrections JSON URL and audio URL.
Frontend loads these to render the review UI.
"""
job = job_manager.get_job(job_id)
if not job:
raise HTTPException(status_code=404, detail="Job not found")
# Check ownership
if not _check_job_ownership(job, auth_result):
raise HTTPException(status_code=403, detail="You don't have permission to access this job")
if job.status not in [JobStatus.AWAITING_REVIEW, JobStatus.IN_REVIEW]:
raise HTTPException(
status_code=400,
@@ -448,21 +376,13 @@ async def get_review_data(
async def start_review(
job_id: str,
request: StartReviewRequest,
auth_result: AuthResult = Depends(require_auth)
auth_data: Tuple[str, UserType, int] = Depends(require_auth)
) -> dict:
"""
Mark job as IN_REVIEW (user opened review interface).
This helps track that the user is actively working on the review.
"""
job = job_manager.get_job(job_id)
if not job:
raise HTTPException(status_code=404, detail="Job not found")
# Check ownership
if not _check_job_ownership(job, auth_result):
raise HTTPException(status_code=403, detail="You don't have permission to access this job")
success = job_manager.transition_to_state(
job_id=job_id,
new_status=JobStatus.IN_REVIEW,
@@ -480,24 +400,20 @@ async def submit_corrections(
job_id: str,
submission: CorrectionsSubmission,
background_tasks: BackgroundTasks,
auth_result: AuthResult = Depends(require_auth)
auth_data: Tuple[str, UserType, int] = Depends(require_auth)
) -> dict:
"""
Save corrected lyrics during human review.
This endpoint saves review progress but does NOT complete the review.
Call POST /{job_id}/complete-review to finish and trigger video rendering.
Can be called multiple times to save progress.
"""
job = job_manager.get_job(job_id)
if not job:
raise HTTPException(status_code=404, detail="Job not found")
# Check ownership
if not _check_job_ownership(job, auth_result):
raise HTTPException(status_code=403, detail="You don't have permission to modify this job")
if job.status not in [JobStatus.AWAITING_REVIEW, JobStatus.IN_REVIEW]:
raise HTTPException(
status_code=400,
@@ -543,11 +459,11 @@ async def submit_corrections(
async def complete_review(
job_id: str,
background_tasks: BackgroundTasks,
auth_result: AuthResult = Depends(require_auth)
auth_data: Tuple[str, UserType, int] = Depends(require_auth)
) -> dict:
"""
Complete the human review and trigger video rendering.
This is the FIRST critical human-in-the-loop completion point.
After this:
1. Job transitions to REVIEW_COMPLETE
@@ -558,11 +474,7 @@ async def complete_review(
job = job_manager.get_job(job_id)
if not job:
raise HTTPException(status_code=404, detail="Job not found")
# Check ownership
if not _check_job_ownership(job, auth_result):
raise HTTPException(status_code=403, detail="You don't have permission to modify this job")
if job.status not in [JobStatus.AWAITING_REVIEW, JobStatus.IN_REVIEW]:
raise HTTPException(
status_code=400,
@@ -1036,22 +948,18 @@ async def select_instrumental(
@router.get("/{job_id}/download-urls")
async def get_download_urls(
job_id: str,
auth_result: AuthResult = Depends(require_auth)
auth_data: Tuple[str, UserType, int] = Depends(require_auth)
) -> dict:
"""
Get download URLs for all job output files.
Returns a dictionary mapping file types to download URLs.
Uses the streaming download endpoint which proxies through the backend.
"""
job = job_manager.get_job(job_id)
if not job:
raise HTTPException(status_code=404, detail="Job not found")
# Check ownership
if not _check_job_ownership(job, auth_result):
raise HTTPException(status_code=403, detail="You don't have permission to access this job")
if job.status != JobStatus.COMPLETE:
raise HTTPException(
status_code=400,
@@ -1082,42 +990,26 @@ async def get_download_urls(
}
# Map file keys to human-readable suffixes (matching Dropbox naming from karaoke_finalise.py)
DOWNLOAD_FILENAME_SUFFIXES = {
"lossless_4k_mp4": " (Final Karaoke Lossless 4k).mp4",
"lossless_4k_mkv": " (Final Karaoke Lossless 4k).mkv",
"lossy_4k_mp4": " (Final Karaoke Lossy 4k).mp4",
"lossy_720p_mp4": " (Final Karaoke Lossy 720p).mp4",
"cdg_zip": " (Final Karaoke CDG).zip",
"txt_zip": " (Final Karaoke TXT).zip",
"with_vocals": " (With Vocals).mkv",
}
@router.get("/{job_id}/download/{category}/{file_key}")
async def download_file(
job_id: str,
category: str,
file_key: str,
auth_result: AuthResult = Depends(require_auth)
auth_data: Tuple[str, UserType, int] = Depends(require_auth)
):
"""
Stream download a specific file from a completed job.
This endpoint proxies the file from GCS through the backend,
so no client-side authentication is required.
"""
from fastapi.responses import StreamingResponse
import tempfile
job = job_manager.get_job(job_id)
if not job:
raise HTTPException(status_code=404, detail="Job not found")
# Check ownership
if not _check_job_ownership(job, auth_result):
raise HTTPException(status_code=403, detail="You don't have permission to access this job")
if job.status != JobStatus.COMPLETE:
raise HTTPException(
status_code=400,
@@ -1158,28 +1050,8 @@ async def download_file(
}
content_type = content_types.get(ext, 'application/octet-stream')
# Build proper filename: "Artist - Title (Final Karaoke Lossy 4k).mp4"
# Sanitize artist/title to remove filesystem-unsafe characters
def sanitize_filename_part(s: str) -> str:
if not s:
return ""
# Remove/replace characters unsafe for filesystems: / \ : * ? " < > |
unsafe_chars = r'[/\\:*?"<>|]'
import re
sanitized = re.sub(unsafe_chars, '', s)
# Collapse multiple spaces and trim
sanitized = ' '.join(sanitized.split())
# Limit length to prevent overly long filenames
return sanitized[:100].strip()
artist_clean = sanitize_filename_part(job.artist) if job.artist else None
title_clean = sanitize_filename_part(job.title) if job.title else None
base_name = f"{artist_clean} - {title_clean}" if artist_clean and title_clean else None
if base_name and file_key in DOWNLOAD_FILENAME_SUFFIXES:
filename = f"{base_name}{DOWNLOAD_FILENAME_SUFFIXES[file_key]}"
else:
filename = gcs_path.split('/')[-1] # Fallback to original
# Get filename for Content-Disposition
filename = gcs_path.split('/')[-1]
try:
# Download to temp file and stream
@@ -1214,21 +1086,13 @@ async def download_file(
async def cancel_job(
job_id: str,
request: CancelJobRequest,
auth_result: AuthResult = Depends(require_auth)
auth_data: Tuple[str, UserType, int] = Depends(require_auth)
) -> dict:
"""
Cancel a job.
Jobs can be cancelled at any stage before completion.
"""
job = job_manager.get_job(job_id)
if not job:
raise HTTPException(status_code=404, detail="Job not found")
# Check ownership
if not _check_job_ownership(job, auth_result):
raise HTTPException(status_code=403, detail="You don't have permission to cancel this job")
success = job_manager.cancel_job(job_id, reason=request.reason)
if not success:
@@ -1245,7 +1109,7 @@ async def cancel_job(
async def retry_job(
job_id: str,
background_tasks: BackgroundTasks,
auth_result: AuthResult = Depends(require_auth)
auth_data: Tuple[str, UserType, int] = Depends(require_auth)
) -> dict:
"""
Retry a failed or cancelled job from the last successful checkpoint.
@@ -1263,10 +1127,6 @@ async def retry_job(
if not job:
raise HTTPException(status_code=404, detail="Job not found")
# Check ownership
if not _check_job_ownership(job, auth_result):
raise HTTPException(status_code=403, detail="You don't have permission to retry this job")
if job.status not in [JobStatus.FAILED, JobStatus.CANCELLED]:
raise HTTPException(
status_code=400,
@@ -1291,13 +1151,12 @@ async def retry_job(
logger.info(f"Job {job_id}: Has rendered video and instrumental selection, retrying video generation")
# Clear error state and reset worker progress for idempotency
# Clear error state
job_manager.update_job(job_id, {
'error_message': None,
'error_details': None,
})
job_manager.update_state_data(job_id, 'video_progress', {'stage': 'pending'})
# Reset to INSTRUMENTAL_SELECTED and trigger video worker
if not job_manager.transition_to_state(
job_id=job_id,
@@ -1325,14 +1184,13 @@ async def retry_job(
file_urls.get('screens', {}).get('title')):
logger.info(f"Job {job_id}: Has corrections and screens, retrying from render stage")
# Clear error state and reset worker progress for idempotency
# Clear error state
job_manager.update_job(job_id, {
'error_message': None,
'error_details': None,
})
job_manager.update_state_data(job_id, 'render_progress', {'stage': 'pending'})
# Reset to REVIEW_COMPLETE and trigger render worker
if not job_manager.transition_to_state(
job_id=job_id,
@@ -1360,14 +1218,13 @@ async def retry_job(
file_urls.get('lyrics', {}).get('corrections')):
logger.info(f"Job {job_id}: Has stems and corrections, retrying from screens stage")
# Clear error state and reset worker progress for idempotency
# Clear error state
job_manager.update_job(job_id, {
'error_message': None,
'error_details': None,
})
job_manager.update_state_data(job_id, 'screens_progress', {'stage': 'pending'})
# Reset to a state before screens and trigger screens worker
if not job_manager.transition_to_state(
job_id=job_id,
@@ -1444,19 +1301,19 @@ async def get_worker_logs(
job_id: str,
since_index: int = 0,
worker: Optional[str] = None,
auth_result: AuthResult = Depends(require_auth)
auth_data: Tuple[str, UserType, int] = Depends(require_auth)
) -> Dict[str, Any]:
"""
Get worker logs for debugging.
This endpoint returns worker logs stored in Firestore.
Use `since_index` for efficient polling (returns only new logs).
Args:
job_id: Job ID
since_index: Return only logs after this index (for pagination/polling)
worker: Filter by worker name (audio, lyrics, screens, video, render)
Returns:
{
"logs": [{"timestamp": "...", "level": "INFO", "worker": "audio", "message": "..."}],
@@ -1467,145 +1324,13 @@ async def get_worker_logs(
job = job_manager.get_job(job_id)
if not job:
raise HTTPException(status_code=404, detail="Job not found")
# Check ownership - users can only see logs for their own jobs
if not _check_job_ownership(job, auth_result):
raise HTTPException(status_code=403, detail="You don't have permission to access logs for this job")
logs = job_manager.get_worker_logs(job_id, since_index=since_index, worker=worker)
total = len(job.worker_logs) if job.worker_logs else 0
return {
"logs": logs,
"next_index": total,
"total_logs": total
}
@router.post("/{job_id}/cleanup-distribution")
async def cleanup_distribution(
job_id: str,
delete_job: bool = True,
auth_result: AuthResult = Depends(require_admin)
) -> dict:
"""
Clean up all distributed content for a job (YouTube, Dropbox, Google Drive).
This admin-only endpoint is designed for E2E test cleanup. It:
1. Deletes YouTube video (if uploaded)
2. Deletes Dropbox folder (if uploaded)
3. Deletes Google Drive files (if uploaded)
4. Optionally deletes the job itself
Args:
job_id: Job ID to clean up
delete_job: If True, also delete the job after cleaning up distribution
Returns:
Cleanup results for each service
"""
job = job_manager.get_job(job_id)
if not job:
raise HTTPException(status_code=404, detail="Job not found")
state_data = job.state_data or {}
results = {
"job_id": job_id,
"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"},
"job_deleted": False
}
# Clean up YouTube
youtube_url = state_data.get('youtube_url')
if youtube_url:
try:
# Extract video ID from URL (format: https://youtu.be/VIDEO_ID or https://www.youtube.com/watch?v=VIDEO_ID)
import re
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)
# Import and use karaoke_finalise for YouTube deletion
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:
# Create minimal KaraokeFinalise instance for deletion
finalise = KaraokeFinalise(
dry_run=False,
non_interactive=True,
enable_youtube=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": "failed", "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 cleaning up YouTube 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": "failed", "reason": "Dropbox credentials not configured"}
except Exception as e:
logger.error(f"Error cleaning up Dropbox 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:
# gdrive_files is a dict like {"mp4": "file_id", "mp4_720p": "file_id", "cdg": "file_id"}
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": "failed", "reason": "Google Drive credentials not configured"}
except Exception as e:
logger.error(f"Error cleaning up Google Drive for job {job_id}: {e}", exc_info=True)
results["gdrive"] = {"status": "error", "error": str(e)}
# Delete the job if requested
if delete_job:
try:
job_manager.delete_job(job_id, delete_files=True)
results["job_deleted"] = True
logger.info(f"Deleted job {job_id} after distribution cleanup")
except Exception as e:
logger.error(f"Error deleting job {job_id}: {e}", exc_info=True)
results["job_deleted"] = False
results["job_delete_error"] = str(e)
return results
File diff suppressed because it is too large. Load diff
+1 -17
View File
@@ -40,15 +40,7 @@ class Settings(BaseSettings):
# Processing
max_concurrent_jobs: int = int(os.getenv("MAX_CONCURRENT_JOBS", "5"))
job_timeout_seconds: int = int(os.getenv("JOB_TIMEOUT_SECONDS", "3600"))
# Agentic AI Correction (for lyrics correction via LLM)
# When enabled, uses Gemini via Vertex AI for intelligent lyrics correction
use_agentic_ai: bool = os.getenv("USE_AGENTIC_AI", "true").lower() in ("true", "1", "yes")
agentic_ai_model: str = os.getenv("AGENTIC_AI_MODEL", "vertexai/gemini-3-flash-preview")
# Timeout for agentic correction in seconds. If correction takes longer, abort and
# use uncorrected transcription - human review will fix any issues.
agentic_correction_timeout_seconds: int = int(os.getenv("AGENTIC_CORRECTION_TIMEOUT_SECONDS", "180"))
# Cloud Tasks (for scalable worker coordination)
# When enabled, workers are triggered via Cloud Tasks for guaranteed delivery
# When disabled (default), workers are triggered via direct HTTP (for development)
@@ -60,14 +52,6 @@ class Settings(BaseSettings):
# instead of Cloud Tasks. This supports encoding times >30 minutes (up to 24 hours).
# Default is false - Cloud Tasks is sufficient for most videos (15-20 min).
use_cloud_run_jobs_for_video: bool = os.getenv("USE_CLOUD_RUN_JOBS_FOR_VIDEO", "false").lower() in ("true", "1", "yes")
# GCE Encoding Worker (for high-performance video encoding)
# When enabled, video encoding is offloaded to a dedicated C4 GCE instance
# with faster CPU (Intel Granite Rapids 3.9 GHz) instead of Cloud Run.
# This provides 2-3x faster encoding times for CPU-bound FFmpeg libx264 encoding.
use_gce_encoding: bool = os.getenv("USE_GCE_ENCODING", "false").lower() in ("true", "1", "yes")
encoding_worker_url: Optional[str] = os.getenv("ENCODING_WORKER_URL") # e.g., http://136.119.50.148:8080
encoding_worker_api_key: Optional[str] = os.getenv("ENCODING_WORKER_API_KEY")
# Storage paths
temp_dir: str = os.getenv("TEMP_DIR", "/tmp/karaoke-gen")
+1 -7
View File
@@ -7,10 +7,9 @@ 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
from backend.api.routes import health, jobs, internal, file_upload, review, auth, audio_search, themes
from backend.services.tracing import setup_tracing, instrument_app, get_current_trace_id
from backend.services.structured_logging import setup_structured_logging
from backend.middleware.audit_logging import AuditLoggingMiddleware
from backend.version import VERSION
@@ -101,9 +100,6 @@ app.add_middleware(
allow_headers=["*"],
)
# Add audit logging middleware (captures all requests with request_id for correlation)
app.add_middleware(AuditLoggingMiddleware)
# Include routers
app.include_router(health.router, prefix="/api")
app.include_router(jobs.router, prefix="/api")
@@ -113,8 +109,6 @@ app.include_router(review.router, prefix="/api") # Review UI compatibility endp
app.include_router(auth.router, prefix="/api") # OAuth credential management
app.include_router(audio_search.router, prefix="/api") # Audio search (artist+title mode)
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.get("/")
-5
View File
@@ -1,5 +0,0 @@
"""Middleware package for FastAPI application."""
from backend.middleware.audit_logging import AuditLoggingMiddleware
__all__ = ["AuditLoggingMiddleware"]
-124
View File
@@ -1,124 +0,0 @@
"""
Audit logging middleware for tracking all HTTP requests.
This middleware captures request metadata and logs it to Cloud Logging
for audit trail and user activity investigation purposes.
"""
import logging
import time
import uuid
from starlette.middleware.base import BaseHTTPMiddleware
from starlette.requests import Request
from starlette.responses import Response
logger = logging.getLogger("audit")
# Endpoints to exclude from audit logging (high-frequency health checks)
EXCLUDED_PATHS = {
"/",
"/api/health",
"/api/health/detailed",
"/api/readiness",
"/healthz",
"/ready",
}
class AuditLoggingMiddleware(BaseHTTPMiddleware):
"""
Middleware that logs all HTTP requests for audit purposes.
Captures:
- request_id: UUID for correlating with auth logs
- method: HTTP method
- path: Request path
- status_code: Response status
- latency_ms: Request duration
- client_ip: Client IP (from X-Forwarded-For for proxied requests)
- user_agent: Browser/client identifier
The request_id is stored in request.state and added to response headers,
allowing correlation with auth logs that capture user_email.
"""
async def dispatch(self, request: Request, call_next) -> Response:
# Skip excluded paths (health checks)
if request.url.path in EXCLUDED_PATHS:
return await call_next(request)
# Generate unique request ID for correlation
request_id = str(uuid.uuid4())
request.state.request_id = request_id
# Capture start time
start_time = time.time()
# Extract client info
client_ip = self._get_client_ip(request)
user_agent = request.headers.get("user-agent", "")
# Process request
try:
response = await call_next(request)
except Exception:
# Log failed requests too (exception() auto-includes stack trace)
latency_ms = int((time.time() - start_time) * 1000)
logger.exception(
"request_audit_error",
extra={
"request_id": request_id,
"method": request.method,
"path": request.url.path,
"query_string": str(request.query_params) if request.query_params else None,
"latency_ms": latency_ms,
"client_ip": client_ip,
"user_agent": user_agent[:200] if user_agent else None,
"audit_type": "http_request",
}
)
raise
# Calculate latency
latency_ms = int((time.time() - start_time) * 1000)
# Log audit entry (INFO level for successful requests)
log_level = logging.WARNING if response.status_code >= 400 else logging.INFO
logger.log(
log_level,
"request_audit",
extra={
"request_id": request_id,
"method": request.method,
"path": request.url.path,
"query_string": str(request.query_params) if request.query_params else None,
"status_code": response.status_code,
"latency_ms": latency_ms,
"client_ip": client_ip,
"user_agent": user_agent[:200] if user_agent else None,
"audit_type": "http_request",
}
)
# Add request_id to response headers for debugging/correlation
response.headers["X-Request-ID"] = request_id
return response
def _get_client_ip(self, request: Request) -> str:
"""
Extract client IP address, handling proxy scenarios.
Cloud Run and other proxies set X-Forwarded-For header.
"""
# Check X-Forwarded-For for proxy scenarios (Cloud Run, load balancers)
forwarded = request.headers.get("x-forwarded-for", "")
if forwarded:
# First IP is the original client
return forwarded.split(",")[0].strip()
# Fall back to direct connection
if request.client:
return request.client.host
return "unknown"
-2
View File
@@ -204,7 +204,6 @@ class Job(BaseModel):
youtube_description: Optional[str] = None # YouTube video description
webhook_url: Optional[str] = None # Webhook for notifications
user_email: Optional[str] = None # Email for notifications
non_interactive: bool = False # Skip interactive steps (lyrics review, instrumental selection)
# Theme configuration (pre-made themes from GCS)
theme_id: Optional[str] = None # Theme identifier (e.g., "nomad", "default")
@@ -420,7 +419,6 @@ class JobCreate(BaseModel):
youtube_description: Optional[str] = None
webhook_url: Optional[str] = None
user_email: Optional[str] = None
non_interactive: bool = False # Skip interactive steps (lyrics review, instrumental selection)
# Theme configuration (pre-made themes from GCS)
theme_id: Optional[str] = None # Theme identifier (e.g., "nomad", "default")
-254
View File
@@ -1,254 +0,0 @@
"""
User model for authentication and credits.
Supports:
- Magic link authentication (email-based)
- Credit system for karaoke generation
- Role-based access control (user/admin)
- Stripe integration for payments
- Beta tester program with feedback collection
"""
from datetime import datetime
from enum import Enum
from typing import Optional, List
from pydantic import BaseModel, Field
class UserRole(str, Enum):
"""User roles for access control."""
USER = "user"
ADMIN = "admin"
class BetaTesterStatus(str, Enum):
"""Status of beta tester participation."""
ACTIVE = "active" # Enrolled, free credits available
PENDING_FEEDBACK = "pending_feedback" # Job completed, awaiting feedback
COMPLETED = "completed" # Feedback submitted
EXPIRED = "expired" # 24hr deadline passed without feedback
class CreditTransaction(BaseModel):
"""Record of a credit transaction."""
id: str
amount: int # Positive = add, negative = deduct
reason: str # e.g., "purchase", "refund", "admin_grant", "job_creation"
job_id: Optional[str] = None
stripe_session_id: Optional[str] = None
created_at: datetime = Field(default_factory=datetime.utcnow)
created_by: Optional[str] = None # Admin email if granted by admin
class User(BaseModel):
"""
User model stored in Firestore.
Users are identified by email address. Authentication is via magic links
(no passwords). Credits are consumed when creating karaoke jobs.
"""
email: str # Primary identifier
role: UserRole = UserRole.USER
credits: int = 0
# Stripe integration
stripe_customer_id: Optional[str] = None
# Account state
is_active: bool = True
email_verified: bool = False
# Timestamps
created_at: datetime = Field(default_factory=datetime.utcnow)
updated_at: datetime = Field(default_factory=datetime.utcnow)
last_login_at: Optional[datetime] = None
# Credit history (last 100 transactions)
credit_transactions: List[CreditTransaction] = Field(default_factory=list)
# Job tracking
total_jobs_created: int = 0
total_jobs_completed: int = 0
# Optional profile fields for future use
display_name: Optional[str] = None
# Beta tester program
is_beta_tester: bool = False
beta_tester_status: Optional[BetaTesterStatus] = None
beta_enrolled_at: Optional[datetime] = None
beta_promise_text: Optional[str] = None # User's promise statement
beta_feedback_due_at: Optional[datetime] = None # 24hr after job completion
beta_feedback_email_sent: bool = False
class MagicLinkToken(BaseModel):
"""
Magic link token for passwordless authentication.
Tokens are short-lived (15 minutes) and single-use.
Stored in Firestore with automatic TTL.
"""
token: str # Secure random token
email: str
created_at: datetime = Field(default_factory=datetime.utcnow)
expires_at: datetime
used: bool = False
used_at: Optional[datetime] = None
ip_address: Optional[str] = None
user_agent: Optional[str] = None
class Session(BaseModel):
"""
User session for authenticated requests.
Sessions are created after successful magic link verification.
Sessions expire after 7 days of inactivity or 30 days absolute.
"""
token: str # Secure random session token
user_email: str
created_at: datetime = Field(default_factory=datetime.utcnow)
expires_at: datetime
last_activity_at: datetime = Field(default_factory=datetime.utcnow)
ip_address: Optional[str] = None
user_agent: Optional[str] = None
is_active: bool = True
# Pydantic models for API requests/responses
class SendMagicLinkRequest(BaseModel):
"""Request to send a magic link email."""
email: str
class SendMagicLinkResponse(BaseModel):
"""Response after sending magic link."""
status: str
message: str
class VerifyMagicLinkRequest(BaseModel):
"""Request to verify a magic link token."""
token: str
class VerifyMagicLinkResponse(BaseModel):
"""Response after verifying magic link."""
status: str
session_token: str
user: "UserPublic"
message: str
class UserPublic(BaseModel):
"""Public user information (safe to expose to frontend)."""
email: str
role: UserRole
credits: int
display_name: Optional[str] = None
total_jobs_created: int = 0
total_jobs_completed: int = 0
class AddCreditsRequest(BaseModel):
"""Admin request to add credits to a user."""
email: str
amount: int
reason: str = "admin_grant"
class AddCreditsResponse(BaseModel):
"""Response after adding credits."""
status: str
email: str
credits_added: int
new_balance: int
message: str
class UserListResponse(BaseModel):
"""Response for listing users (admin only)."""
users: List[UserPublic]
total: int
# ============================================================================
# Beta Tester Program Models
# ============================================================================
class BetaTesterFeedback(BaseModel):
"""
Feedback from a beta tester after using the service.
Stored in Firestore 'beta_feedback' collection.
"""
id: str # Unique feedback ID
user_email: str
job_id: Optional[str] = None # The job they're providing feedback on
# Ratings (1-5 scale)
overall_rating: int = Field(ge=1, le=5)
ease_of_use_rating: int = Field(ge=1, le=5)
lyrics_accuracy_rating: int = Field(ge=1, le=5)
correction_experience_rating: int = Field(ge=1, le=5)
# Open-ended feedback
what_went_well: Optional[str] = None
what_could_improve: Optional[str] = None
additional_comments: Optional[str] = None
# Would they recommend / use again?
would_recommend: bool = True
would_use_again: bool = True
# Metadata
created_at: datetime = Field(default_factory=datetime.utcnow)
submitted_via: str = "web" # 'web' or 'email'
class BetaTesterEnrollRequest(BaseModel):
"""Request to enroll as a beta tester."""
email: str
promise_text: str = Field(
min_length=10,
description="User's promise to provide feedback (min 10 chars)"
)
accept_corrections_work: bool = Field(
description="User accepts they may need to review/correct lyrics"
)
class BetaTesterEnrollResponse(BaseModel):
"""Response after enrolling as beta tester."""
status: str
message: str
credits_granted: int
session_token: Optional[str] = None # If new user, provide session
class BetaFeedbackRequest(BaseModel):
"""Request to submit beta tester feedback."""
job_id: Optional[str] = None
# Ratings (1-5 scale)
overall_rating: int = Field(ge=1, le=5)
ease_of_use_rating: int = Field(ge=1, le=5)
lyrics_accuracy_rating: int = Field(ge=1, le=5)
correction_experience_rating: int = Field(ge=1, le=5)
# Open-ended feedback
what_went_well: Optional[str] = None
what_could_improve: Optional[str] = None
additional_comments: Optional[str] = None
# Would they recommend / use again?
would_recommend: bool = True
would_use_again: bool = True
class BetaFeedbackResponse(BaseModel):
"""Response after submitting feedback."""
status: str
message: str
bonus_credits: int = 0 # Bonus credits for great feedback
+16 -37
View File
@@ -276,35 +276,20 @@ class AudioSearchService:
Raises:
DownloadError: If download fails or no cached result for index
"""
# Use provided search_id or fall back to service-level cache
effective_search_id = remote_search_id or self._remote_search_id
# Check if we have local cached results
has_local_cache = result_index >= 0 and result_index < len(self._cached_results)
# If no local cache but we have remote search_id, use remote download
# This handles multi-instance deployments where the cache doesn't persist
if not has_local_cache:
if effective_search_id and self._remote_client:
logger.info(f"No local cache, using remote download with search_id={effective_search_id}, index={result_index}")
return self._download_remote(result_index, output_dir, output_filename, gcs_path, effective_search_id)
else:
# Provide clear error message based on whether cache is empty or index out of bounds
if len(self._cached_results) == 0:
raise DownloadError(
f"No cached result for index {result_index}. "
"No cached results available. Run search() first."
)
raise DownloadError(
f"No cached result for index {result_index}. "
f"Available indices: 0-{len(self._cached_results) - 1}. "
"Run search() first."
)
if result_index < 0 or result_index >= len(self._cached_results):
raise DownloadError(
f"No cached result for index {result_index}. "
f"Available indices: 0-{len(self._cached_results) - 1}. "
"Run search() first."
)
result = self._cached_results[result_index]
logger.info(f"Downloading: {result.artist} - {result.title} from {result.provider}")
# Use provided search_id or fall back to service-level cache
effective_search_id = remote_search_id or self._remote_search_id
# Check if this was a remote search (torrent sources need remote download)
if effective_search_id and self._remote_client:
# Check if this is a torrent source that needs remote handling
@@ -496,12 +481,8 @@ class AudioSearchService:
if not effective_search_id:
raise DownloadError("No remote search ID - run search() first")
# Try to get local result for metadata, but it's optional
# The remote service maintains its own cache by search_id
result = None
if result_index >= 0 and result_index < len(self._cached_results):
result = self._cached_results[result_index]
result = self._cached_results[result_index]
try:
# Enable nested event loops (needed when called from FastAPI async context)
try:
@@ -548,15 +529,13 @@ class AudioSearchService:
raise DownloadError("Remote download completed but no file path returned")
logger.info(f"Remote download complete: {filepath}")
# Use local result metadata if available, otherwise use empty strings
# (the actual download is handled by the remote service using search_id)
return AudioDownloadResult(
filepath=filepath,
artist=result.artist if result else "",
title=result.title if result else "",
provider=result.provider if result else "remote",
quality=result.quality if result else "",
artist=result.artist,
title=result.title,
provider=result.provider,
quality=result.quality,
)
except FlacfetchServiceError as e:
+19 -354
View File
@@ -3,81 +3,50 @@ Authentication service for karaoke backend.
Provides token-based authentication with support for:
- Admin tokens (hardcoded in environment)
- Admin by email domain (@nomadkaraoke.com)
- User tokens (stored in Firestore auth_tokens collection)
- Session tokens (stored in Firestore sessions collection, from magic link auth)
- API keys for business users
- User tokens (stored in Firestore)
- Usage tracking and limits
- Token management API
This is designed to be extensible for future Stripe integration
and admin dashboard functionality.
"""
import logging
import hashlib
import time
import secrets
from dataclasses import dataclass
from enum import Enum
from typing import Optional, Tuple, Dict, Any, List
from typing import Optional, Tuple, Dict, Any
from datetime import datetime
from backend.services.firestore_service import FirestoreService
from backend.config import get_settings
from backend.models.user import UserRole
logger = logging.getLogger(__name__)
# Admin email domains - users with these domains are automatically admin
ADMIN_EMAIL_DOMAINS = ["nomadkaraoke.com"]
class UserType(str, Enum):
"""User access levels."""
ADMIN = "admin" # Unlimited access, can manage tokens
UNLIMITED = "unlimited" # Unlimited karaoke generation
LIMITED = "limited" # Limited number of uses
STRIPE = "stripe" # Paid access via Stripe
API_KEY = "api_key" # Business API key access
@dataclass
class AuthResult:
"""Result of authentication validation."""
is_valid: bool
user_type: UserType
remaining_uses: int # -1 = unlimited, 0 = exhausted, >0 = remaining
message: str
user_email: Optional[str] = None # Email if authenticated via session/API key
is_admin: bool = False # True if admin token or admin email domain
api_key_id: Optional[str] = None # API key ID if authenticated via API key
def __iter__(self):
"""Allow unpacking as tuple for backward compatibility."""
return iter((self.is_valid, self.user_type, self.remaining_uses, self.message))
def is_admin_email(email: str) -> bool:
"""Check if an email belongs to an admin domain."""
if not email:
return False
email_lower = email.lower()
return any(email_lower.endswith(f"@{domain}") for domain in ADMIN_EMAIL_DOMAINS)
STRIPE = "stripe" # Paid access via Stripe (future)
class AuthService:
"""Service for authentication and token management."""
def __init__(self):
"""Initialize auth service."""
self.firestore = FirestoreService()
self.settings = get_settings()
self._init_admin_tokens()
def _init_admin_tokens(self):
"""Load admin tokens from environment variables."""
# Get admin tokens from secret manager or env vars
admin_tokens_str = self.settings.admin_tokens or ""
self.admin_tokens = [t.strip() for t in admin_tokens_str.split(",") if t.strip()]
if self.admin_tokens:
logger.info(f"Loaded {len(self.admin_tokens)} admin token(s)")
else:
@@ -109,30 +78,10 @@ class AuthService:
f"expected len={len(self.admin_tokens[0])}, got len={len(token)}"
)
# Check stored tokens in Firestore (auth_tokens collection)
# Check stored tokens in Firestore
token_data = self.firestore.get_token(token)
if not token_data:
# Fall back to checking session tokens (from magic link auth)
# Import here to avoid circular dependency
from backend.services.user_service import get_user_service
user_service = get_user_service()
is_valid, user, message = user_service.validate_session(token)
if is_valid and user:
# Session is valid - user is authenticated via magic link
# Return their credits as remaining uses
credits = user.credits
logger.info(f"Session token validated for user {user.email} (credits: {credits})")
if credits <= 0:
# User has no credits but is authenticated
return True, UserType.STRIPE, 0, f"Authenticated but no credits remaining"
return True, UserType.STRIPE, credits, f"Session valid: {credits} credits"
# Neither auth_token nor session found
return False, UserType.LIMITED, 0, "Invalid token"
# Check if token is active
@@ -180,319 +129,35 @@ class AuthService:
return True, token_type, -1, "Stripe access granted"
return False, UserType.LIMITED, 0, "Unknown token type"
def validate_token_full(self, token: str) -> AuthResult:
"""
Validate an access token and return full authentication details.
This is the preferred method for new code as it returns complete
authentication context including user email and admin status.
Returns:
AuthResult with full authentication details
"""
if not token:
return AuthResult(
is_valid=False,
user_type=UserType.LIMITED,
remaining_uses=0,
message="No token provided"
)
# Check for admin tokens (highest priority)
# Admin tokens from env var are associated with the system admin email
if token in self.admin_tokens:
logger.info("Admin token validated")
return AuthResult(
is_valid=True,
user_type=UserType.ADMIN,
remaining_uses=-1,
message="Admin access granted",
user_email="admin@nomadkaraoke.com",
is_admin=True
)
# Check stored tokens in Firestore (auth_tokens collection)
token_data = self.firestore.get_token(token)
if not token_data:
# Fall back to checking session tokens (from magic link auth)
from backend.services.user_service import get_user_service
user_service = get_user_service()
is_valid, user, _message = user_service.validate_session(token)
if is_valid and user:
# Session is valid - user is authenticated via magic link
credits = user.credits
user_email = user.email
# Check if user is admin by email domain or role
user_is_admin = is_admin_email(user_email) or user.role == UserRole.ADMIN
if user_is_admin:
logger.info(f"Admin session validated for {user_email}")
return AuthResult(
is_valid=True,
user_type=UserType.ADMIN,
remaining_uses=-1,
message="Admin access granted (domain)",
user_email=user_email,
is_admin=True
)
logger.info(f"Session token validated for user {user_email} (credits: {credits})")
if credits <= 0:
return AuthResult(
is_valid=True,
user_type=UserType.STRIPE,
remaining_uses=0,
message="Authenticated but no credits remaining",
user_email=user_email,
is_admin=False
)
return AuthResult(
is_valid=True,
user_type=UserType.STRIPE,
remaining_uses=credits,
message=f"Session valid: {credits} credits",
user_email=user_email,
is_admin=False
)
# Neither auth_token nor session found
return AuthResult(
is_valid=False,
user_type=UserType.LIMITED,
remaining_uses=0,
message="Invalid token"
)
# Check if token is active
if not token_data.get("active", True):
return AuthResult(
is_valid=False,
user_type=UserType(token_data["type"]),
remaining_uses=0,
message="Token has been revoked"
)
token_type = UserType(token_data["type"])
max_uses = token_data.get("max_uses", -1)
# All auth_tokens must have an associated user_email for job ownership
token_user_email = token_data.get("user_email")
api_key_id = token_data.get("api_key_id")
# Require user_email on all auth_tokens (no anonymous token auth)
if not token_user_email:
logger.warning("Auth token missing required user_email field")
return AuthResult(
is_valid=False,
user_type=token_type,
remaining_uses=0,
message="Token configuration error: missing user_email. Please contact support."
)
# Check if token's user is an admin (by email domain)
token_is_admin = is_admin_email(token_user_email)
# UNLIMITED tokens: no usage limits
if token_type == UserType.UNLIMITED:
return AuthResult(
is_valid=True,
user_type=token_type,
remaining_uses=-1,
message="Unlimited access granted",
user_email=token_user_email,
is_admin=token_is_admin,
api_key_id=api_key_id
)
# LIMITED tokens: check usage count
if token_type == UserType.LIMITED:
if max_uses <= 0: # -1 means unlimited
return AuthResult(
is_valid=True,
user_type=token_type,
remaining_uses=-1,
message="Limited token with unlimited uses",
user_email=token_user_email,
is_admin=token_is_admin,
api_key_id=api_key_id
)
current_uses = token_data.get("usage_count", 0)
remaining = max_uses - current_uses
if remaining <= 0:
return AuthResult(
is_valid=False,
user_type=token_type,
remaining_uses=0,
message="Token usage limit exceeded",
user_email=token_user_email,
api_key_id=api_key_id
)
return AuthResult(
is_valid=True,
user_type=token_type,
remaining_uses=remaining,
message=f"Limited token: {remaining} uses remaining",
user_email=token_user_email,
is_admin=token_is_admin,
api_key_id=api_key_id
)
# STRIPE tokens: check expiration and usage
if token_type == UserType.STRIPE:
expires_at = token_data.get("expires_at")
if expires_at and time.time() > expires_at:
return AuthResult(
is_valid=False,
user_type=token_type,
remaining_uses=0,
message="Token has expired",
user_email=token_user_email,
api_key_id=api_key_id
)
if max_uses > 0:
current_uses = token_data.get("usage_count", 0)
remaining = max_uses - current_uses
if remaining <= 0:
return AuthResult(
is_valid=False,
user_type=token_type,
remaining_uses=0,
message="Token usage limit exceeded",
user_email=token_user_email,
api_key_id=api_key_id
)
return AuthResult(
is_valid=True,
user_type=token_type,
remaining_uses=remaining,
message=f"Stripe token: {remaining} uses remaining",
user_email=token_user_email,
is_admin=token_is_admin,
api_key_id=api_key_id
)
return AuthResult(
is_valid=True,
user_type=token_type,
remaining_uses=-1,
message="Stripe access granted",
user_email=token_user_email,
is_admin=token_is_admin,
api_key_id=api_key_id
)
# API_KEY tokens
if token_type == UserType.API_KEY:
if max_uses > 0:
current_uses = token_data.get("usage_count", 0)
remaining = max_uses - current_uses
if remaining <= 0:
return AuthResult(
is_valid=False,
user_type=token_type,
remaining_uses=0,
message="API key usage limit exceeded",
user_email=token_user_email,
api_key_id=api_key_id
)
return AuthResult(
is_valid=True,
user_type=token_type,
remaining_uses=remaining,
message=f"API key valid: {remaining} uses remaining",
user_email=token_user_email,
is_admin=token_is_admin,
api_key_id=api_key_id
)
return AuthResult(
is_valid=True,
user_type=token_type,
remaining_uses=-1,
message="API key access granted",
user_email=token_user_email,
is_admin=token_is_admin,
api_key_id=api_key_id
)
return AuthResult(
is_valid=False,
user_type=UserType.LIMITED,
remaining_uses=0,
message="Unknown token type"
)
def increment_token_usage(self, token: str, job_id: str) -> bool:
"""
Increment usage count for a token and track the job.
For session tokens (magic link auth), this deducts a credit from the user.
For auth_tokens, this increments the usage count.
Args:
token: The access token
job_id: The job ID being created
Returns:
True if usage was tracked, False otherwise
"""
# Validate token first
is_valid, user_type, remaining_uses, message = self.validate_token(token)
if not is_valid:
logger.warning(f"Cannot increment usage for invalid token: {message}")
return False
# Don't track usage for admin or unlimited tokens
if user_type in [UserType.ADMIN, UserType.UNLIMITED]:
logger.debug(f"Skipping usage tracking for {user_type} token")
return True
# For admin tokens (not in Firestore), no tracking needed
if token in self.admin_tokens:
return True
# Check if this is a session token (STRIPE type from validate_token means it's a session)
# Session tokens are not in auth_tokens collection
token_data = self.firestore.get_token(token)
if not token_data:
# This is a session token - deduct credit from user
from backend.services.user_service import get_user_service
user_service = get_user_service()
# Get the user email from the session
is_valid, user, _ = user_service.validate_session(token)
if not is_valid or not user:
logger.error(f"Session token validation failed during usage increment")
return False
# Deduct one credit
success, new_balance, deduct_message = user_service.deduct_credit(
user.email, job_id, reason="job_creation"
)
if success:
logger.info(f"Deducted credit for user {user.email} (remaining: {new_balance})")
return True
else:
logger.error(f"Failed to deduct credit for user {user.email}: {deduct_message}")
return False
# Regular auth_token - increment usage in Firestore
# Increment usage in Firestore
try:
self.firestore.increment_token_usage(token, job_id)
logger.info(f"Incremented usage for token (remaining: {remaining_uses - 1})")
-172
View File
@@ -1,172 +0,0 @@
"""
Discord Notification Service.
Provides Discord webhook notification functionality, extracted from KaraokeFinalise
for use by both the cloud backend (video_worker) and local CLI.
This service handles:
- Posting messages to Discord webhooks
- Video upload notifications
- Validation of webhook URLs
"""
import logging
import re
from typing import Optional
import requests
logger = logging.getLogger(__name__)
class DiscordNotificationService:
"""
Service for sending Discord webhook notifications.
Supports posting messages to Discord channels via webhooks,
commonly used to notify when new karaoke videos are uploaded.
"""
# Discord webhook URL pattern
WEBHOOK_URL_PATTERN = re.compile(
r"^https://discord\.com/api/webhooks/\d+/[a-zA-Z0-9_-]+$"
)
def __init__(
self,
webhook_url: Optional[str] = None,
dry_run: bool = False,
logger: Optional[logging.Logger] = None,
):
"""
Initialize the Discord notification service.
Args:
webhook_url: Discord webhook URL for posting notifications
dry_run: If True, log actions without performing them
logger: Optional logger instance
"""
self.webhook_url = webhook_url
self.dry_run = dry_run
self.logger = logger or logging.getLogger(__name__)
# Validate webhook URL if provided
if webhook_url:
self._validate_webhook_url(webhook_url)
def _validate_webhook_url(self, url: str) -> None:
"""
Validate that the webhook URL is a valid Discord webhook URL.
Args:
url: URL to validate
Raises:
ValueError: If URL is not a valid Discord webhook URL
"""
url = url.strip()
if not url.startswith("https://discord.com/api/webhooks/"):
raise ValueError(
f"Invalid Discord webhook URL: {url}. "
"URL must start with 'https://discord.com/api/webhooks/'"
)
def post_message(
self,
message: str,
webhook_url: Optional[str] = None,
) -> bool:
"""
Post a message to a Discord channel via webhook.
Args:
message: The message content to post
webhook_url: Optional webhook URL (uses instance URL if not provided)
Returns:
True if message was posted successfully, False otherwise
Raises:
ValueError: If no webhook URL is available
requests.HTTPError: If the webhook request fails
"""
url = webhook_url or self.webhook_url
if not url:
raise ValueError("No Discord webhook URL provided")
url = url.strip()
self._validate_webhook_url(url)
if self.dry_run:
self.logger.info(
f"DRY RUN: Would post Discord message: '{message}' to {url}"
)
return True
self.logger.info(f"Posting message to Discord webhook...")
data = {"content": message}
response = requests.post(url, json=data, timeout=30)
response.raise_for_status()
self.logger.info("Message posted to Discord successfully")
return True
def post_video_notification(
self,
youtube_url: str,
webhook_url: Optional[str] = None,
) -> bool:
"""
Post a notification about a new video upload.
Args:
youtube_url: The YouTube URL of the uploaded video
webhook_url: Optional webhook URL (uses instance URL if not provided)
Returns:
True if notification was posted successfully, False otherwise
"""
if not youtube_url:
self.logger.info("Skipping Discord notification - no YouTube URL available")
return False
message = f"New upload: {youtube_url}"
return self.post_message(message, webhook_url)
def is_enabled(self) -> bool:
"""
Check if Discord notifications are enabled.
Returns:
True if a valid webhook URL is configured
"""
return bool(self.webhook_url)
# Singleton instance and factory function (following existing service pattern)
_discord_notification_service: Optional[DiscordNotificationService] = None
def get_discord_notification_service(
webhook_url: Optional[str] = None,
**kwargs
) -> DiscordNotificationService:
"""
Get a Discord notification service instance.
Args:
webhook_url: Discord webhook URL for notifications
**kwargs: Additional arguments passed to DiscordNotificationService
Returns:
DiscordNotificationService instance
"""
global _discord_notification_service
# Create new instance if webhook URL changed or not yet created
if _discord_notification_service is None or webhook_url:
_discord_notification_service = DiscordNotificationService(
webhook_url=webhook_url,
**kwargs
)
return _discord_notification_service
+5 -44
View File
@@ -199,7 +199,7 @@ class DropboxService:
def upload_folder(self, local_dir: str, remote_path: str) -> None:
"""
Recursively upload all files and subdirectories to Dropbox folder.
Upload all files in a directory to Dropbox folder.
Args:
local_dir: Local directory to upload
@@ -212,17 +212,10 @@ class DropboxService:
logger.info(f"Uploading folder {local_dir} to {remote_path}")
uploaded_count = 0
for root, _dirs, files in os.walk(local_dir):
# Calculate the relative path from local_dir to current root
rel_root = os.path.relpath(root, local_dir)
if rel_root == ".":
current_remote = remote_path
else:
current_remote = f"{remote_path}/{rel_root}"
for filename in files:
local_file = os.path.join(root, filename)
remote_file = f"{current_remote}/{filename}"
for filename in os.listdir(local_dir):
local_file = os.path.join(local_dir, filename)
if os.path.isfile(local_file):
remote_file = f"{remote_path}/{filename}"
self.upload_file(local_file, remote_file)
uploaded_count += 1
@@ -263,38 +256,6 @@ class DropboxService:
return links.links[0].url
raise
def delete_folder(self, path: str) -> bool:
"""
Delete a folder and all its contents from Dropbox.
Args:
path: Dropbox path to delete (e.g., "/Karaoke/Tracks-Organized/NOMAD-1234 - Artist - Title")
Returns:
True if deleted successfully, False otherwise
"""
from dropbox.exceptions import ApiError
# Ensure path starts with /
if not path.startswith("/"):
path = f"/{path}"
logger.info(f"Deleting Dropbox folder: {path}")
try:
self.client.files_delete_v2(path)
logger.info(f"Successfully deleted: {path}")
return True
except ApiError as e:
if e.error.is_path_lookup() and e.error.get_path_lookup().is_not_found():
logger.warning(f"Folder not found (already deleted?): {path}")
return True # Consider it success if already gone
logger.error(f"Failed to delete Dropbox folder: {e}")
return False
except Exception as e:
logger.error(f"Error deleting Dropbox folder: {e}")
return False
def get_dropbox_service() -> DropboxService:
"""Factory function to get a DropboxService instance."""
-829
View File
@@ -1,829 +0,0 @@
"""
Email service for sending transactional emails.
Supports multiple providers:
- SendGrid (recommended for production)
- Console logging (for development/testing)
Future providers can be added:
- Mailgun
- AWS SES
- Postmark
"""
import html
import logging
import os
from abc import ABC, abstractmethod
from typing import Optional
from backend.config import get_settings
logger = logging.getLogger(__name__)
class EmailProvider(ABC):
"""Abstract base class for email providers."""
@abstractmethod
def send_email(
self,
to_email: str,
subject: str,
html_content: str,
text_content: Optional[str] = None
) -> bool:
"""Send an email. Returns True if successful."""
pass
class ConsoleEmailProvider(EmailProvider):
"""
Development email provider that logs to console.
Useful for local development and testing.
"""
def send_email(
self,
to_email: str,
subject: str,
html_content: str,
text_content: Optional[str] = None
) -> bool:
logger.info("=" * 60)
logger.info(f"EMAIL TO: {to_email}")
logger.info(f"SUBJECT: {subject}")
logger.info("-" * 60)
logger.info(text_content or html_content)
logger.info("=" * 60)
return True
class SendGridEmailProvider(EmailProvider):
"""
SendGrid email provider for production.
Requires SENDGRID_API_KEY environment variable.
"""
def __init__(self, api_key: str, from_email: str, from_name: str = "Nomad Karaoke"):
self.api_key = api_key
self.from_email = from_email
self.from_name = from_name
def send_email(
self,
to_email: str,
subject: str,
html_content: str,
text_content: Optional[str] = None
) -> bool:
try:
# Import here to avoid requiring sendgrid in all environments
from sendgrid import SendGridAPIClient
from sendgrid.helpers.mail import Mail, Email, To, Content
sg = SendGridAPIClient(api_key=self.api_key)
message = Mail(
from_email=Email(self.from_email, self.from_name),
to_emails=To(to_email),
subject=subject,
html_content=Content("text/html", html_content)
)
if text_content:
message.add_content(Content("text/plain", text_content))
response = sg.send(message)
if response.status_code >= 200 and response.status_code < 300:
logger.info(f"Email sent to {to_email} via SendGrid")
return True
else:
logger.error(f"SendGrid returned status {response.status_code}")
return False
except Exception:
logger.exception("Failed to send email via SendGrid")
return False
class EmailService:
"""
High-level email service for sending transactional emails.
Automatically selects the appropriate provider based on configuration.
"""
def __init__(self):
self.settings = get_settings()
self.provider = self._get_provider()
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)
def _get_provider(self) -> EmailProvider:
"""Get the configured email provider."""
sendgrid_api_key = os.getenv("SENDGRID_API_KEY")
from_email = os.getenv("EMAIL_FROM", "gen@nomadkaraoke.com")
from_name = os.getenv("EMAIL_FROM_NAME", "Nomad Karaoke")
if sendgrid_api_key:
logger.info("Using SendGrid email provider")
return SendGridEmailProvider(sendgrid_api_key, from_email, from_name)
else:
logger.warning("No email provider configured, using console logging")
return ConsoleEmailProvider()
def is_configured(self) -> bool:
"""Check if a real email provider is configured (not just console logging)."""
return isinstance(self.provider, SendGridEmailProvider)
def send_magic_link(self, email: str, token: str) -> bool:
"""
Send a magic link email for authentication.
Args:
email: User's email address
token: Magic link token
Returns:
True if email was sent successfully
"""
magic_link_url = f"{self.frontend_url}/auth/verify?token={token}"
subject = "Sign in to Nomad Karaoke"
html_content = f"""
<!DOCTYPE html>
<html>
<head>
<style>
body {{
font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
line-height: 1.6;
color: #333;
max-width: 600px;
margin: 0 auto;
padding: 20px;
}}
.header {{
text-align: center;
padding: 20px 0;
}}
.logo {{
font-size: 24px;
font-weight: bold;
color: #3b82f6;
}}
.button {{
display: inline-block;
background-color: #3b82f6;
color: white;
padding: 14px 28px;
text-decoration: none;
border-radius: 8px;
font-weight: 600;
margin: 20px 0;
}}
.button:hover {{
background-color: #2563eb;
}}
.footer {{
margin-top: 30px;
padding-top: 20px;
border-top: 1px solid #eee;
font-size: 12px;
color: #666;
}}
.warning {{
background-color: #fef3c7;
border: 1px solid #fcd34d;
border-radius: 4px;
padding: 12px;
margin: 20px 0;
font-size: 14px;
}}
</style>
</head>
<body>
<div class="header">
<div class="logo">🎤 Nomad Karaoke</div>
</div>
<p>Hi there,</p>
<p>Click the button below to sign in to Nomad Karaoke:</p>
<p style="text-align: center;">
<a href="{magic_link_url}" class="button">Sign In</a>
</p>
<div class="warning">
⏰ This link expires in 15 minutes and can only be used once.
</div>
<p>If the button doesn't work, copy and paste this link into your browser:</p>
<p style="word-break: break-all; font-size: 14px; color: #666;">
{magic_link_url}
</p>
<p>If you didn't request this email, you can safely ignore it.</p>
<div class="footer">
<p>© {self._get_year()} Nomad Karaoke. All rights reserved.</p>
<p>This is an automated message, please do not reply.</p>
</div>
</body>
</html>
"""
text_content = f"""
Sign in to Nomad Karaoke
========================
Click this link to sign in:
{magic_link_url}
This link expires in 15 minutes and can only be used once.
If you didn't request this email, you can safely ignore it.
---
© {self._get_year()} Nomad Karaoke
"""
return self.provider.send_email(email, subject, html_content, text_content)
def send_credits_added(self, email: str, credits: int, total_credits: int) -> bool:
"""
Send notification when credits are added to account.
Args:
email: User's email address
credits: Number of credits added
total_credits: New total credit balance
Returns:
True if email was sent successfully
"""
subject = f"🎉 {credits} credits added to your Nomad Karaoke account"
html_content = f"""
<!DOCTYPE html>
<html>
<head>
<style>
body {{
font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
line-height: 1.6;
color: #333;
max-width: 600px;
margin: 0 auto;
padding: 20px;
}}
.header {{
text-align: center;
padding: 20px 0;
}}
.logo {{
font-size: 24px;
font-weight: bold;
color: #3b82f6;
}}
.credits-box {{
background-color: #ecfdf5;
border: 2px solid #10b981;
border-radius: 12px;
padding: 24px;
text-align: center;
margin: 20px 0;
}}
.credits-number {{
font-size: 48px;
font-weight: bold;
color: #10b981;
}}
.button {{
display: inline-block;
background-color: #3b82f6;
color: white;
padding: 14px 28px;
text-decoration: none;
border-radius: 8px;
font-weight: 600;
margin: 20px 0;
}}
.footer {{
margin-top: 30px;
padding-top: 20px;
border-top: 1px solid #eee;
font-size: 12px;
color: #666;
}}
</style>
</head>
<body>
<div class="header">
<div class="logo">🎤 Nomad Karaoke</div>
</div>
<p>Great news! 🎉</p>
<p><strong>{credits} credits</strong> have been added to your account.</p>
<div class="credits-box">
<div>Your balance:</div>
<div class="credits-number">{total_credits}</div>
<div>credits</div>
</div>
<p>Each credit lets you create one professional karaoke video with:</p>
<ul>
<li>AI-powered vocal/instrumental separation</li>
<li>Synchronized lyrics with word-level timing</li>
<li>4K video output</li>
<li>YouTube upload</li>
</ul>
<p style="text-align: center;">
<a href="{self.frontend_url}" class="button">Create Karaoke Now</a>
</p>
<div class="footer">
<p>© {self._get_year()} Nomad Karaoke. All rights reserved.</p>
</div>
</body>
</html>
"""
text_content = f"""
{credits} credits added to your Nomad Karaoke account!
Your new balance: {total_credits} credits
Each credit lets you create one professional karaoke video.
Start creating: {self.frontend_url}
---
© {self._get_year()} Nomad Karaoke
"""
return self.provider.send_email(email, subject, html_content, text_content)
def send_welcome_email(self, email: str, credits: int = 0) -> bool:
"""
Send welcome email to new users.
Args:
email: User's email address
credits: Initial credit balance (if any)
Returns:
True if email was sent successfully
"""
subject = "Welcome to Nomad Karaoke! 🎤"
credits_text = f"You have <strong>{credits} credits</strong> to get started!" if credits > 0 else ""
html_content = f"""
<!DOCTYPE html>
<html>
<head>
<style>
body {{
font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
line-height: 1.6;
color: #333;
max-width: 600px;
margin: 0 auto;
padding: 20px;
}}
.header {{
text-align: center;
padding: 20px 0;
}}
.logo {{
font-size: 24px;
font-weight: bold;
color: #3b82f6;
}}
.button {{
display: inline-block;
background-color: #3b82f6;
color: white;
padding: 14px 28px;
text-decoration: none;
border-radius: 8px;
font-weight: 600;
margin: 20px 0;
}}
.feature {{
display: flex;
align-items: flex-start;
margin: 16px 0;
}}
.feature-icon {{
font-size: 24px;
margin-right: 12px;
}}
.footer {{
margin-top: 30px;
padding-top: 20px;
border-top: 1px solid #eee;
font-size: 12px;
color: #666;
}}
</style>
</head>
<body>
<div class="header">
<div class="logo">🎤 Nomad Karaoke</div>
</div>
<p>Welcome to Nomad Karaoke!</p>
<p>Turn any song into a professional karaoke video in minutes. {credits_text}</p>
<p><strong>Here's how it works:</strong></p>
<div class="feature">
<span class="feature-icon">🎵</span>
<div>
<strong>1. Search for a song</strong><br>
Enter the artist and title, and we'll find high-quality audio.
</div>
</div>
<div class="feature">
<span class="feature-icon">✨</span>
<div>
<strong>2. AI does the magic</strong><br>
We separate vocals, transcribe lyrics, and sync everything perfectly.
</div>
</div>
<div class="feature">
<span class="feature-icon">✏️</span>
<div>
<strong>3. Review & customize</strong><br>
Fine-tune the lyrics if needed, choose your instrumental.
</div>
</div>
<div class="feature">
<span class="feature-icon">🎬</span>
<div>
<strong>4. Get your video</strong><br>
Download your 4K karaoke video or upload directly to YouTube.
</div>
</div>
<p style="text-align: center;">
<a href="{self.frontend_url}" class="button">Get Started</a>
</p>
<div class="footer">
<p>Questions? Reply to this email and we'll help you out.</p>
<p>© {self._get_year()} Nomad Karaoke. All rights reserved.</p>
</div>
</body>
</html>
"""
text_content = f"""
Welcome to Nomad Karaoke!
Turn any song into a professional karaoke video in minutes.
Here's how it works:
1. Search for a song
Enter the artist and title, and we'll find high-quality audio.
2. AI does the magic
We separate vocals, transcribe lyrics, and sync everything perfectly.
3. Review & customize
Fine-tune the lyrics if needed, choose your instrumental.
4. Get your video
Download your 4K karaoke video or upload directly to YouTube.
Get started: {self.frontend_url}
---
© {self._get_year()} Nomad Karaoke
"""
return self.provider.send_email(email, subject, html_content, text_content)
def send_beta_welcome_email(self, email: str, credits: int = 1) -> bool:
"""
Send welcome email to new beta testers.
Args:
email: User's email address
credits: Initial free credits granted
Returns:
True if email was sent successfully
"""
subject = "Welcome Beta Tester! Free Karaoke Credits Inside 🎤"
html_content = f"""
<!DOCTYPE html>
<html>
<head>
<style>
body {{
font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
line-height: 1.6;
color: #333;
max-width: 600px;
margin: 0 auto;
padding: 20px;
}}
.header {{
text-align: center;
padding: 20px 0;
}}
.logo {{
font-size: 24px;
font-weight: bold;
color: #3b82f6;
}}
.beta-badge {{
display: inline-block;
background: linear-gradient(135deg, #8b5cf6, #ec4899);
color: white;
padding: 4px 12px;
border-radius: 20px;
font-size: 12px;
font-weight: bold;
margin-left: 8px;
}}
.credits-box {{
background-color: #ecfdf5;
border: 2px solid #10b981;
border-radius: 12px;
padding: 24px;
text-align: center;
margin: 20px 0;
}}
.credits-number {{
font-size: 48px;
font-weight: bold;
color: #10b981;
}}
.reminder {{
background-color: #fef3c7;
border: 1px solid #fcd34d;
border-radius: 8px;
padding: 16px;
margin: 20px 0;
}}
.button {{
display: inline-block;
background-color: #3b82f6;
color: white;
padding: 14px 28px;
text-decoration: none;
border-radius: 8px;
font-weight: 600;
margin: 20px 0;
}}
.footer {{
margin-top: 30px;
padding-top: 20px;
border-top: 1px solid #eee;
font-size: 12px;
color: #666;
}}
</style>
</head>
<body>
<div class="header">
<span class="logo">🎤 Nomad Karaoke</span>
<span class="beta-badge">BETA TESTER</span>
</div>
<p>Thank you for joining our beta program! 🎉</p>
<p>As promised, here's your free credit to create a karaoke video:</p>
<div class="credits-box">
<div>Your balance:</div>
<div class="credits-number">{credits}</div>
<div>free credit{'' if credits == 1 else 's'}</div>
</div>
<div class="reminder">
<strong>📝 Your Promise:</strong><br>
Remember, as a beta tester you agreed to:
<ul style="margin: 10px 0; padding-left: 20px;">
<li>Review and correct any lyrics timing issues</li>
<li>Share your honest feedback after trying the tool</li>
</ul>
We'll send you a quick feedback form after your job completes!
</div>
<p style="text-align: center;">
<a href="{self.frontend_url}" class="button">Create Your Karaoke Video</a>
</p>
<p>Thanks for helping us make Nomad Karaoke better!</p>
<div class="footer">
<p>© {self._get_year()} Nomad Karaoke. All rights reserved.</p>
</div>
</body>
</html>
"""
text_content = f"""
Welcome Beta Tester!
Thank you for joining our beta program!
You've been granted {credits} free credit{'' if credits == 1 else 's'} to create karaoke videos.
YOUR PROMISE:
As a beta tester, you agreed to:
- Review and correct any lyrics timing issues
- Share your honest feedback after trying the tool
We'll send you a quick feedback form after your job completes!
Create your karaoke video: {self.frontend_url}
Thanks for helping us make Nomad Karaoke better!
---
© {self._get_year()} Nomad Karaoke
"""
return self.provider.send_email(email, subject, html_content, text_content)
def send_feedback_request_email(self, email: str, feedback_url: str, job_title: Optional[str] = None) -> bool:
"""
Send feedback request email to beta testers.
Args:
email: User's email address
feedback_url: URL to the feedback form
job_title: Optional title of the completed job
Returns:
True if email was sent successfully
"""
subject = "Quick feedback on your karaoke experience? 🎤"
# Escape job_title to prevent XSS in email clients that render HTML
safe_job_title = html.escape(job_title) if job_title else ""
job_context = f" for <strong>{safe_job_title}</strong>" if job_title else ""
html_content = f"""
<!DOCTYPE html>
<html>
<head>
<style>
body {{
font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
line-height: 1.6;
color: #333;
max-width: 600px;
margin: 0 auto;
padding: 20px;
}}
.header {{
text-align: center;
padding: 20px 0;
}}
.logo {{
font-size: 24px;
font-weight: bold;
color: #3b82f6;
}}
.feedback-box {{
background: linear-gradient(135deg, #f0f9ff, #e0f2fe);
border: 2px solid #3b82f6;
border-radius: 12px;
padding: 24px;
text-align: center;
margin: 20px 0;
}}
.stars {{
font-size: 36px;
margin: 10px 0;
}}
.button {{
display: inline-block;
background-color: #3b82f6;
color: white;
padding: 14px 28px;
text-decoration: none;
border-radius: 8px;
font-weight: 600;
margin: 20px 0;
}}
.time-note {{
background-color: #fef3c7;
border-radius: 8px;
padding: 12px;
margin: 20px 0;
font-size: 14px;
}}
.footer {{
margin-top: 30px;
padding-top: 20px;
border-top: 1px solid #eee;
font-size: 12px;
color: #666;
}}
</style>
</head>
<body>
<div class="header">
<div class="logo">🎤 Nomad Karaoke</div>
</div>
<p>Hi there!</p>
<p>Hope you enjoyed creating your karaoke video{job_context}! As a beta tester, your feedback is super valuable to us.</p>
<div class="feedback-box">
<div class="stars">⭐⭐⭐⭐⭐</div>
<p><strong>How was your experience?</strong></p>
<p>Quick 2-minute survey - we'd love to hear your thoughts!</p>
</div>
<p style="text-align: center;">
<a href="{feedback_url}" class="button">Share Your Feedback</a>
</p>
<div class="time-note">
⏱️ This takes less than 2 minutes and helps us improve the tool for everyone!
</div>
<p>Specifically, we'd love to know:</p>
<ul>
<li>How easy was it to use?</li>
<li>Were the lyrics accurate?</li>
<li>How was the correction experience?</li>
<li>What could we improve?</li>
</ul>
<p>Thanks for being part of making Nomad Karaoke better! 🙏</p>
<div class="footer">
<p>© {self._get_year()} Nomad Karaoke. All rights reserved.</p>
</div>
</body>
</html>
"""
text_content = f"""
Quick feedback on your karaoke experience?
Hi there!
Hope you enjoyed creating your karaoke video{' for ' + safe_job_title if safe_job_title else ''}!
As a beta tester, your feedback is super valuable to us.
Share your feedback (2-minute survey): {feedback_url}
We'd love to know:
- How easy was it to use?
- Were the lyrics accurate?
- How was the correction experience?
- What could we improve?
Thanks for being part of making Nomad Karaoke better!
---
© {self._get_year()} Nomad Karaoke
"""
return self.provider.send_email(email, subject, html_content, text_content)
def _get_year(self) -> int:
"""Get current year for copyright notices."""
from datetime import datetime
return datetime.now().year
# Global instance
_email_service = None
def get_email_service() -> EmailService:
"""Get the global email service instance."""
global _email_service
if _email_service is None:
_email_service = EmailService()
return _email_service
-429
View File
@@ -1,429 +0,0 @@
"""
Encoding Interface.
Defines the abstract interface for video encoding backends, allowing
the video worker orchestrator to use either GCE or local encoding
interchangeably.
This follows the Strategy pattern - different encoding implementations
can be swapped without changing the orchestration logic.
"""
import logging
from abc import ABC, abstractmethod
from dataclasses import dataclass, field
from typing import Dict, List, Optional, Any
logger = logging.getLogger(__name__)
@dataclass
class EncodingInput:
"""
Input configuration for video encoding.
Contains all the paths and metadata needed to encode a karaoke video.
"""
# Required input files
title_video_path: str # Title card video (MOV)
karaoke_video_path: str # Main karaoke video with vocals (MOV/MKV)
instrumental_audio_path: str # Instrumental audio track (FLAC)
# Optional input files
end_video_path: Optional[str] = None # End credits video (MOV)
# Metadata for output naming
artist: str = ""
title: str = ""
brand_code: Optional[str] = None
# Output directory
output_dir: str = ""
# Additional options
options: Dict[str, Any] = field(default_factory=dict)
@dataclass
class EncodingOutput:
"""
Output from video encoding.
Contains paths to all generated video files and status information.
"""
success: bool
error_message: Optional[str] = None
# Output file paths (relative to output_dir or absolute)
karaoke_mp4_path: Optional[str] = None # Karaoke video with instrumental audio
with_vocals_mp4_path: Optional[str] = None # With vocals MP4 version
lossless_4k_mp4_path: Optional[str] = None # Final lossless 4K MP4
lossy_4k_mp4_path: Optional[str] = None # Final lossy 4K MP4
lossless_mkv_path: Optional[str] = None # MKV with FLAC (for YouTube)
lossy_720p_mp4_path: Optional[str] = None # 720p web version
# All output files as a dict for convenience
output_files: Dict[str, str] = field(default_factory=dict)
# Encoding metadata
encoding_time_seconds: Optional[float] = None
encoding_backend: Optional[str] = None # "gce" or "local"
class EncodingBackend(ABC):
"""
Abstract base class for video encoding backends.
Implementations:
- GCEEncodingBackend: Cloud-based encoding using Google Compute Engine
- LocalEncodingBackend: Local FFmpeg-based encoding
"""
@property
@abstractmethod
def name(self) -> str:
"""Return the name of this encoding backend."""
pass
@abstractmethod
async def encode(self, input_config: EncodingInput) -> EncodingOutput:
"""
Encode video files according to the input configuration.
This method should:
1. Create karaoke video with instrumental audio
2. Convert with-vocals video to MP4 if needed
3. Encode lossless 4K MP4 (concatenating title + karaoke + end)
4. Encode lossy 4K MP4 with AAC audio
5. Create MKV with FLAC audio for YouTube
6. Encode 720p version for web
Args:
input_config: EncodingInput with all required paths and options
Returns:
EncodingOutput with paths to generated files and status
"""
pass
@abstractmethod
async def is_available(self) -> bool:
"""
Check if this encoding backend is available and configured.
Returns:
True if the backend can be used, False otherwise
"""
pass
@abstractmethod
async def get_status(self) -> Dict[str, Any]:
"""
Get the current status of the encoding backend.
Returns:
Dict with status information (availability, queue length, etc.)
"""
pass
class LocalEncodingBackend(EncodingBackend):
"""
Local FFmpeg-based encoding backend.
Wraps the LocalEncodingService to implement the EncodingBackend interface.
Uses asyncio.to_thread() to run synchronous FFmpeg operations asynchronously.
"""
def __init__(
self,
dry_run: bool = False,
logger: Optional[logging.Logger] = None,
):
"""
Initialize the local encoding backend.
Args:
dry_run: If True, log operations without executing
logger: Optional logger instance
"""
self.dry_run = dry_run
self.logger = logger or logging.getLogger(__name__)
self._service = None
@property
def name(self) -> str:
return "local"
def _get_service(self):
"""Lazy-load the local encoding service."""
if self._service is None:
from backend.services.local_encoding_service import LocalEncodingService
self._service = LocalEncodingService(
dry_run=self.dry_run,
logger=self.logger
)
return self._service
async def encode(self, input_config: EncodingInput) -> EncodingOutput:
"""
Encode video using local FFmpeg.
Args:
input_config: Encoding input configuration
Returns:
EncodingOutput with results
"""
import asyncio
import time
from backend.services.local_encoding_service import EncodingConfig
start_time = time.time()
# Build output file paths
base_name = f"{input_config.artist} - {input_config.title}"
output_dir = input_config.output_dir or "."
import os
config = EncodingConfig(
title_video=input_config.title_video_path,
karaoke_video=input_config.karaoke_video_path,
instrumental_audio=input_config.instrumental_audio_path,
end_video=input_config.end_video_path,
output_karaoke_mp4=os.path.join(output_dir, f"{base_name} (Karaoke).mp4"),
output_with_vocals_mp4=os.path.join(output_dir, f"{base_name} (With Vocals).mp4"),
output_lossless_4k_mp4=os.path.join(output_dir, f"{base_name} (Final Karaoke Lossless 4k).mp4"),
output_lossy_4k_mp4=os.path.join(output_dir, f"{base_name} (Final Karaoke Lossy 4k).mp4"),
output_lossless_mkv=os.path.join(output_dir, f"{base_name} (Final Karaoke Lossless 4k).mkv"),
output_720p_mp4=os.path.join(output_dir, f"{base_name} (Final Karaoke Lossy 720p).mp4"),
)
# Run encoding in thread pool to avoid blocking
service = self._get_service()
result = await asyncio.to_thread(service.encode_all_formats, config)
encoding_time = time.time() - start_time
if result.success:
return EncodingOutput(
success=True,
karaoke_mp4_path=config.output_karaoke_mp4,
with_vocals_mp4_path=config.output_with_vocals_mp4,
lossless_4k_mp4_path=config.output_lossless_4k_mp4,
lossy_4k_mp4_path=config.output_lossy_4k_mp4,
lossless_mkv_path=config.output_lossless_mkv,
lossy_720p_mp4_path=config.output_720p_mp4,
output_files=result.output_files,
encoding_time_seconds=encoding_time,
encoding_backend=self.name
)
else:
return EncodingOutput(
success=False,
error_message=result.error,
output_files=result.output_files,
encoding_time_seconds=encoding_time,
encoding_backend=self.name
)
async def is_available(self) -> bool:
"""Check if local encoding is available (FFmpeg installed)."""
import subprocess
import asyncio
try:
result = await asyncio.to_thread(
subprocess.run,
["ffmpeg", "-version"],
capture_output=True,
timeout=10
)
return result.returncode == 0
except (FileNotFoundError, subprocess.TimeoutExpired):
return False
async def get_status(self) -> Dict[str, Any]:
"""Get local encoding status."""
available = await self.is_available()
service = self._get_service()
return {
"backend": self.name,
"available": available,
"hwaccel_available": service.hwaccel_available if available else False,
"video_encoder": service.video_encoder if available else None,
}
class GCEEncodingBackend(EncodingBackend):
"""
GCE-based encoding backend.
Wraps the existing EncodingService to implement the EncodingBackend interface.
Submits jobs to a remote GCE worker for high-performance encoding.
"""
def __init__(
self,
dry_run: bool = False,
logger: Optional[logging.Logger] = None,
):
"""
Initialize the GCE encoding backend.
Args:
dry_run: Ignored for GCE backend (remote service doesn't support dry run)
logger: Optional logger instance
"""
self.dry_run = dry_run # Stored but not used (GCE is remote)
self.logger = logger or logging.getLogger(__name__)
self._service = None
@property
def name(self) -> str:
return "gce"
def _get_service(self):
"""Lazy-load the GCE encoding service."""
if self._service is None:
from backend.services.encoding_service import get_encoding_service
self._service = get_encoding_service()
return self._service
async def encode(self, input_config: EncodingInput) -> EncodingOutput:
"""
Encode video using GCE worker.
Note: GCE encoding requires files to be in GCS, so this method
expects input_config.options to contain 'input_gcs_path' and
'output_gcs_path'.
Args:
input_config: Encoding input configuration
Returns:
EncodingOutput with results
"""
import time
start_time = time.time()
service = self._get_service()
# GCE requires GCS paths
input_gcs_path = input_config.options.get("input_gcs_path")
output_gcs_path = input_config.options.get("output_gcs_path")
job_id = input_config.options.get("job_id", input_config.brand_code or "unknown")
if not input_gcs_path or not output_gcs_path:
return EncodingOutput(
success=False,
error_message="GCE encoding requires input_gcs_path and output_gcs_path in options",
encoding_backend=self.name
)
try:
# Build encoding config
encoding_config = {
"formats": ["mp4_4k_lossless", "mp4_4k_lossy", "mkv_4k", "mp4_720p"],
"artist": input_config.artist,
"title": input_config.title,
}
# Submit and wait for completion
result = await service.encode_videos(
job_id=job_id,
input_gcs_path=input_gcs_path,
output_gcs_path=output_gcs_path,
encoding_config=encoding_config,
)
encoding_time = time.time() - start_time
# Extract output file paths from result
# Handle case where GCE worker returns a list or unexpected format
if isinstance(result, list):
# If result is a list, try to find the output_files in the first dict
self.logger.warning(f"GCE returned list instead of dict: {result}")
result = result[0] if result and isinstance(result[0], dict) else {}
if not isinstance(result, dict):
self.logger.error(f"Unexpected GCE result type: {type(result)}")
result = {}
output_files = result.get("output_files", {})
return EncodingOutput(
success=True,
lossless_4k_mp4_path=output_files.get("mp4_4k_lossless"),
lossy_4k_mp4_path=output_files.get("mp4_4k_lossy"),
lossless_mkv_path=output_files.get("mkv_4k"),
lossy_720p_mp4_path=output_files.get("mp4_720p"),
output_files=output_files,
encoding_time_seconds=encoding_time,
encoding_backend=self.name
)
except Exception as e:
encoding_time = time.time() - start_time
self.logger.error(f"GCE encoding failed: {e}")
return EncodingOutput(
success=False,
error_message=str(e),
encoding_time_seconds=encoding_time,
encoding_backend=self.name
)
async def is_available(self) -> bool:
"""Check if GCE encoding is available and configured."""
service = self._get_service()
return service.is_enabled
async def get_status(self) -> Dict[str, Any]:
"""Get GCE encoding status."""
service = self._get_service()
status = {
"backend": self.name,
"available": service.is_enabled,
"configured": service.is_configured,
}
if service.is_configured:
try:
health = await service.health_check()
status["health"] = health
except Exception as e:
status["health_error"] = str(e)
return status
# Factory function to get an encoding backend
def get_encoding_backend(
backend_type: str = "auto",
**kwargs
) -> EncodingBackend:
"""
Get an encoding backend instance.
Args:
backend_type: Type of backend - "local", "gce", or "auto"
**kwargs: Additional arguments for the backend
Returns:
EncodingBackend instance
Raises:
ValueError: If backend_type is unknown
"""
if backend_type == "local":
return LocalEncodingBackend(**kwargs)
elif backend_type == "gce":
return GCEEncodingBackend(**kwargs)
elif backend_type == "auto":
# Check if GCE is available, otherwise use local
gce_backend = GCEEncodingBackend(**kwargs)
if gce_backend._get_service().is_enabled:
return gce_backend
return LocalEncodingBackend(**kwargs)
else:
raise ValueError(f"Unknown encoding backend type: {backend_type}")
-270
View File
@@ -1,270 +0,0 @@
"""
GCE Encoding Worker Service.
This service dispatches video encoding jobs to a dedicated high-performance
GCE instance (C4-standard with Intel Granite Rapids CPU) for faster encoding.
The GCE worker provides:
- 3.9 GHz all-core frequency (vs 3.7 GHz on Cloud Run)
- Dedicated vCPUs (no contention)
- 2-3x faster FFmpeg libx264 encoding
Usage:
encoding_service = get_encoding_service()
if encoding_service.is_configured:
result = await encoding_service.encode_videos(job_id, input_gcs_path, config)
"""
import asyncio
import logging
from typing import Optional, Dict, Any
import aiohttp
from backend.config import get_settings
logger = logging.getLogger(__name__)
class EncodingService:
"""Service for dispatching encoding jobs to GCE worker."""
def __init__(self):
self.settings = get_settings()
self._url = None
self._api_key = None
self._initialized = False
def _load_credentials(self):
"""Load encoding worker URL and API key from config/secrets."""
if self._initialized:
return
# Try environment variables first, then Secret Manager
self._url = self.settings.encoding_worker_url
self._api_key = self.settings.encoding_worker_api_key
# Fall back to Secret Manager
if not self._url:
self._url = self.settings.get_secret("encoding-worker-url")
if not self._api_key:
self._api_key = self.settings.get_secret("encoding-worker-api-key")
self._initialized = True
@property
def is_configured(self) -> bool:
"""Check if encoding service is configured with URL and API key."""
self._load_credentials()
return bool(self._url and self._api_key)
@property
def is_enabled(self) -> bool:
"""Check if GCE encoding is enabled and configured."""
return self.settings.use_gce_encoding and self.is_configured
async def submit_encoding_job(
self,
job_id: str,
input_gcs_path: str,
output_gcs_path: str,
encoding_config: Dict[str, Any],
) -> Dict[str, Any]:
"""
Submit an encoding job to the GCE worker.
Args:
job_id: Unique job identifier
input_gcs_path: GCS path to input files (gs://bucket/path/)
output_gcs_path: GCS path for output files (gs://bucket/path/)
encoding_config: Configuration for encoding (formats, quality, etc.)
Returns:
Response from the encoding worker
Raises:
Exception: If submission fails
"""
self._load_credentials()
if not self.is_configured:
raise RuntimeError("Encoding service not configured")
url = f"{self._url}/encode"
headers = {"X-API-Key": self._api_key, "Content-Type": "application/json"}
payload = {
"job_id": job_id,
"input_gcs_path": input_gcs_path,
"output_gcs_path": output_gcs_path,
"encoding_config": encoding_config,
}
logger.info(f"[job:{job_id}] Submitting encoding job to GCE worker: {url}")
async with aiohttp.ClientSession() as session:
async with session.post(url, json=payload, headers=headers, timeout=30) as resp:
if resp.status == 401:
raise RuntimeError("Invalid API key for encoding worker")
if resp.status == 409:
raise RuntimeError(f"Encoding job {job_id} already exists")
if resp.status != 200:
text = await resp.text()
raise RuntimeError(f"Failed to submit encoding job: {resp.status} - {text}")
return await resp.json()
async def get_job_status(self, job_id: str) -> Dict[str, Any]:
"""
Get the status of an encoding job.
Args:
job_id: Job identifier
Returns:
Job status including: status, progress, error, output_files
"""
self._load_credentials()
if not self.is_configured:
raise RuntimeError("Encoding service not configured")
url = f"{self._url}/status/{job_id}"
headers = {"X-API-Key": self._api_key}
async with aiohttp.ClientSession() as session:
async with session.get(url, headers=headers, timeout=30) as resp:
if resp.status == 401:
raise RuntimeError("Invalid API key for encoding worker")
if resp.status == 404:
raise RuntimeError(f"Encoding job {job_id} not found")
if resp.status != 200:
text = await resp.text()
raise RuntimeError(f"Failed to get job status: {resp.status} - {text}")
return await resp.json()
async def wait_for_completion(
self,
job_id: str,
poll_interval: float = 10.0,
timeout: float = 3600.0,
progress_callback=None,
) -> Dict[str, Any]:
"""
Poll for encoding job completion.
Args:
job_id: Job identifier
poll_interval: Seconds between status checks
timeout: Maximum time to wait (default 1 hour)
progress_callback: Optional callback(progress: int) for progress updates
Returns:
Final job status with output files
Raises:
TimeoutError: If job doesn't complete within timeout
RuntimeError: If job fails
"""
logger.info(f"[job:{job_id}] Waiting for GCE encoding to complete...")
start_time = asyncio.get_event_loop().time()
last_progress = 0
while True:
elapsed = asyncio.get_event_loop().time() - start_time
if elapsed > timeout:
raise TimeoutError(f"Encoding job {job_id} timed out after {timeout}s")
status = await self.get_job_status(job_id)
job_status = status.get("status", "unknown")
progress = status.get("progress", 0)
# Report progress
if progress != last_progress:
logger.info(f"[job:{job_id}] Encoding progress: {progress}%")
last_progress = progress
if progress_callback:
try:
progress_callback(progress)
except Exception as e:
logger.warning(f"Progress callback failed: {e}")
if job_status == "complete":
logger.info(f"[job:{job_id}] GCE encoding complete in {elapsed:.1f}s")
return status
if job_status == "failed":
error = status.get("error", "Unknown error")
raise RuntimeError(f"Encoding job {job_id} failed: {error}")
await asyncio.sleep(poll_interval)
async def encode_videos(
self,
job_id: str,
input_gcs_path: str,
output_gcs_path: str,
encoding_config: Optional[Dict[str, Any]] = None,
progress_callback=None,
) -> Dict[str, Any]:
"""
Submit encoding job and wait for completion.
This is a convenience method that combines submit + wait.
Args:
job_id: Unique job identifier
input_gcs_path: GCS path to input files
output_gcs_path: GCS path for output files
encoding_config: Optional encoding configuration
progress_callback: Optional callback for progress updates
Returns:
Final job status with output files
"""
config = encoding_config or {"formats": ["mp4_4k", "mp4_720p"]}
# Submit the job
await self.submit_encoding_job(job_id, input_gcs_path, output_gcs_path, config)
# Wait for completion
return await self.wait_for_completion(
job_id, progress_callback=progress_callback
)
async def health_check(self) -> Dict[str, Any]:
"""
Check the health of the encoding worker.
Returns:
Health status including active jobs and FFmpeg version
"""
self._load_credentials()
if not self.is_configured:
return {"status": "not_configured"}
url = f"{self._url}/health"
headers = {"X-API-Key": self._api_key}
try:
async with aiohttp.ClientSession() as session:
async with session.get(url, headers=headers, timeout=10) as resp:
if resp.status == 200:
return await resp.json()
return {"status": "error", "code": resp.status}
except Exception as e:
return {"status": "error", "error": str(e)}
# Singleton instance
_encoding_service: Optional[EncodingService] = None
def get_encoding_service() -> EncodingService:
"""Get the singleton encoding service instance."""
global _encoding_service
if _encoding_service is None:
_encoding_service = EncodingService()
return _encoding_service
+10 -16
View File
@@ -114,53 +114,47 @@ class FirestoreService:
client_id: Optional[str] = None,
created_after: Optional[datetime] = None,
created_before: Optional[datetime] = None,
user_email: Optional[str] = None,
limit: int = 100
) -> List[Job]:
"""
List jobs with optional filters.
Args:
status: Filter by job status
environment: Filter by request_metadata.environment (test/production/development)
client_id: Filter by request_metadata.client_id
created_after: Filter jobs created after this datetime
created_before: Filter jobs created before this datetime
user_email: Filter by user_email (owner of the job)
limit: Maximum number of jobs to return
Returns:
List of Job objects matching filters, ordered by created_at descending
"""
try:
query = self.db.collection(self.collection)
if status:
query = query.where(filter=FieldFilter('status', '==', status.value))
# Filter by request_metadata fields using dot notation
if environment:
query = query.where(filter=FieldFilter('request_metadata.environment', '==', environment))
if client_id:
query = query.where(filter=FieldFilter('request_metadata.client_id', '==', client_id))
# Filter by user_email (job owner)
if user_email:
query = query.where(filter=FieldFilter('user_email', '==', user_email.lower()))
# Date range filters
if created_after:
query = query.where(filter=FieldFilter('created_at', '>=', created_after))
if created_before:
query = query.where(filter=FieldFilter('created_at', '<=', created_before))
query = query.order_by('created_at', direction=firestore.Query.DESCENDING).limit(limit)
docs = query.stream()
jobs = [Job(**doc.to_dict()) for doc in docs]
return jobs
except Exception as e:
logger.error(f"Error listing jobs: {e}")
+3 -103
View File
@@ -408,11 +408,11 @@ class FlacfetchClient:
) -> Dict[str, Any]:
"""
Trigger disk cleanup.
Args:
strategy: Cleanup strategy (oldest, largest, lowest_ratio)
target_free_gb: Target free space to achieve
Returns:
Cleanup response with removed count and freed space
"""
@@ -429,112 +429,12 @@ class FlacfetchClient:
)
resp.raise_for_status()
return resp.json()
except httpx.RequestError as e:
raise FlacfetchServiceError(f"Cleanup failed: {e}")
except httpx.HTTPStatusError as e:
raise FlacfetchServiceError(f"Cleanup failed: {e.response.status_code}")
# =========================================================================
# Cache Management
# =========================================================================
async def clear_search_cache(self, artist: str, title: str) -> bool:
"""
Clear a specific cached search result by artist and title.
Args:
artist: Artist name
title: Track title
Returns:
True if a cache entry was deleted, False if no entry existed
Raises:
FlacfetchServiceError: On request failure
"""
try:
async with httpx.AsyncClient() as client:
resp = await client.request(
"DELETE",
f"{self.base_url}/cache/search",
headers=self._headers(),
json={"artist": artist, "title": title},
timeout=30,
)
resp.raise_for_status()
data = resp.json()
deleted = data.get("deleted", False)
logger.info(
f"Cleared flacfetch cache for '{artist}' - '{title}': "
f"{'deleted' if deleted else 'no entry found'}"
)
return deleted
except httpx.RequestError as e:
raise FlacfetchServiceError(f"Clear search cache request failed: {e}")
except httpx.HTTPStatusError as e:
raise FlacfetchServiceError(
f"Clear search cache failed: {e.response.status_code} - {e.response.text}"
)
async def clear_all_cache(self) -> int:
"""
Clear all cached search results.
Returns:
Number of cache entries deleted
Raises:
FlacfetchServiceError: On request failure
"""
try:
async with httpx.AsyncClient() as client:
resp = await client.delete(
f"{self.base_url}/cache",
headers=self._headers(),
timeout=60,
)
resp.raise_for_status()
data = resp.json()
deleted_count = data.get("deleted_count", 0)
logger.info(f"Cleared all flacfetch cache: {deleted_count} entries deleted")
return deleted_count
except httpx.RequestError as e:
raise FlacfetchServiceError(f"Clear all cache request failed: {e}")
except httpx.HTTPStatusError as e:
raise FlacfetchServiceError(
f"Clear all cache failed: {e.response.status_code} - {e.response.text}"
)
async def get_cache_stats(self) -> Dict[str, Any]:
"""
Get statistics about the cache.
Returns:
Dict with count, total_size_bytes, oldest_entry, newest_entry, configured
Raises:
FlacfetchServiceError: On request failure
"""
try:
async with httpx.AsyncClient() as client:
resp = await client.get(
f"{self.base_url}/cache/stats",
headers=self._headers(),
timeout=30,
)
resp.raise_for_status()
return resp.json()
except httpx.RequestError as e:
raise FlacfetchServiceError(f"Get cache stats request failed: {e}")
except httpx.HTTPStatusError as e:
raise FlacfetchServiceError(
f"Get cache stats failed: {e.response.status_code} - {e.response.text}"
)
# Singleton client instance
_client: Optional[FlacfetchClient] = None
+2 -45
View File
@@ -136,10 +136,8 @@ class GoogleDriveService:
logger.info(f"Looking for folder '{folder_name}' in parent {parent_id}")
# Search for existing folder
# Escape single quotes in folder name for Google Drive API query syntax
escaped_folder_name = folder_name.replace("'", "\\'")
query = (
f"name='{escaped_folder_name}' and '{parent_id}' in parents "
f"name='{folder_name}' and '{parent_id}' in parents "
f"and mimeType='application/vnd.google-apps.folder' and trashed=false"
)
results = self.service.files().list(q=query, fields="files(id, name)").execute()
@@ -205,10 +203,8 @@ class GoogleDriveService:
# Check for existing file with same name
if replace_existing:
# Escape single quotes in filename for Google Drive API query syntax
escaped_filename = filename.replace("'", "\\'")
query = (
f"name='{escaped_filename}' and '{parent_id}' in parents and trashed=false"
f"name='{filename}' and '{parent_id}' in parents and trashed=false"
)
results = self.service.files().list(q=query, fields="files(id)").execute()
for existing_file in results.get("files", []):
@@ -300,45 +296,6 @@ class GoogleDriveService:
logger.info(f"Public share upload complete: {len(uploaded_files)} files uploaded")
return uploaded_files
def delete_file(self, file_id: str) -> bool:
"""
Delete a file from Google Drive.
Args:
file_id: Google Drive file ID to delete
Returns:
True if deleted successfully, False otherwise
"""
logger.info(f"Deleting Google Drive file: {file_id}")
try:
self.service.files().delete(fileId=file_id).execute()
logger.info(f"Successfully deleted file: {file_id}")
return True
except Exception as e:
# Check if it's a 404 (already deleted)
if hasattr(e, 'resp') and e.resp.status == 404:
logger.warning(f"File not found (already deleted?): {file_id}")
return True
logger.error(f"Failed to delete Google Drive file: {e}")
return False
def delete_files(self, file_ids: list[str]) -> dict[str, bool]:
"""
Delete multiple files from Google Drive.
Args:
file_ids: List of Google Drive file IDs to delete
Returns:
Dictionary mapping file_id to success status
"""
results = {}
for file_id in file_ids:
results[file_id] = self.delete_file(file_id)
return results
# Singleton instance
_gdrive_service: Optional[GoogleDriveService] = None
+2 -10
View File
@@ -61,11 +61,6 @@ class JobManager:
discord_webhook_url=job_create.discord_webhook_url,
dropbox_path=job_create.dropbox_path,
gdrive_folder_id=job_create.gdrive_folder_id,
# Theme configuration
theme_id=job_create.theme_id,
color_overrides=job_create.color_overrides,
style_params_gcs_path=job_create.style_params_gcs_path,
style_assets=job_create.style_assets,
# Two-phase workflow (Batch 6)
prep_only=job_create.prep_only,
finalise_only=job_create.finalise_only,
@@ -111,21 +106,19 @@ class JobManager:
client_id: Optional[str] = None,
created_after: Optional[datetime] = None,
created_before: Optional[datetime] = None,
user_email: Optional[str] = None,
limit: int = 100
) -> List[Job]:
"""
List jobs with optional filtering.
Args:
status: Filter by job status
environment: Filter by request_metadata.environment (test/production/development)
client_id: Filter by request_metadata.client_id (customer identifier)
created_after: Filter jobs created after this datetime
created_before: Filter jobs created before this datetime
user_email: Filter by user_email (job owner)
limit: Maximum number of jobs to return
Returns:
List of Job objects matching filters
"""
@@ -135,7 +128,6 @@ class JobManager:
client_id=client_id,
created_after=created_after,
created_before=created_before,
user_email=user_email,
limit=limit
)
-590
View File
@@ -1,590 +0,0 @@
"""
Local Encoding Service.
Provides local FFmpeg-based video encoding functionality, extracted from KaraokeFinalise
for use by both the cloud backend (video_worker as a fallback) and local CLI.
This service handles:
- Concatenating title, karaoke, and end videos
- Encoding to multiple output formats (4K lossless, 4K lossy, 720p, MKV)
- Hardware acceleration detection and fallback to software encoding
- Remuxing video with instrumental audio
"""
import logging
import os
import shlex
import subprocess
import sys
from dataclasses import dataclass
from typing import Optional, List, Dict, Any, Tuple
logger = logging.getLogger(__name__)
@dataclass
class EncodingConfig:
"""Configuration for video encoding."""
title_video: str # Path to title video
karaoke_video: str # Path to karaoke video (with vocals)
instrumental_audio: str # Path to instrumental audio
end_video: Optional[str] = None # Optional path to end credits video
# Output paths
output_karaoke_mp4: Optional[str] = None
output_with_vocals_mp4: Optional[str] = None
output_lossless_4k_mp4: Optional[str] = None
output_lossy_4k_mp4: Optional[str] = None
output_lossless_mkv: Optional[str] = None
output_720p_mp4: Optional[str] = None
@dataclass
class EncodingResult:
"""Result of video encoding operation."""
success: bool
output_files: Dict[str, str]
error: Optional[str] = None
class LocalEncodingService:
"""
Service for local FFmpeg-based video encoding.
Supports hardware acceleration (NVENC) with automatic fallback
to software encoding (libx264) when unavailable.
"""
# MP4 flags for better compatibility
MP4_FLAGS = "-movflags +faststart"
def __init__(
self,
dry_run: bool = False,
log_level: int = logging.INFO,
logger: Optional[logging.Logger] = None,
):
"""
Initialize the local encoding service.
Args:
dry_run: If True, log commands without executing them
log_level: Logging level (affects FFmpeg verbosity)
logger: Optional logger instance
"""
self.dry_run = dry_run
self.log_level = log_level
self.logger = logger or logging.getLogger(__name__)
# Hardware acceleration settings (detected on first use)
self._hwaccel_available: Optional[bool] = None
self._video_encoder: Optional[str] = None
self._scale_filter: Optional[str] = None
self._hwaccel_decode_flags: Optional[str] = None
self._aac_codec: Optional[str] = None
# Build FFmpeg base command
self._ffmpeg_base_command = self._build_ffmpeg_base_command()
def _build_ffmpeg_base_command(self) -> str:
"""Build the FFmpeg base command with appropriate flags."""
# Use bundled FFmpeg for frozen builds
ffmpeg_path = os.path.join(sys._MEIPASS, "ffmpeg.exe") if getattr(sys, "frozen", False) else "ffmpeg"
base_cmd = f"{ffmpeg_path} -hide_banner -nostats -y"
if self.log_level == logging.DEBUG:
base_cmd += " -loglevel verbose"
else:
base_cmd += " -loglevel fatal"
return base_cmd
def _detect_hardware_acceleration(self) -> Tuple[bool, str, str, str, str]:
"""
Detect available hardware acceleration.
Returns:
Tuple of (hwaccel_available, video_encoder, scale_filter,
hwaccel_decode_flags, aac_codec)
"""
self.logger.info("Detecting hardware acceleration capabilities...")
# Try NVENC (NVIDIA)
try:
test_cmd = f"{self._ffmpeg_base_command} -hide_banner -loglevel error " \
f"-f lavfi -i testsrc=duration=1:size=320x240:rate=1 " \
f"-c:v h264_nvenc -f null -"
subprocess.run(
test_cmd, shell=True, check=True,
capture_output=True, timeout=30
)
self.logger.info("NVIDIA NVENC hardware acceleration available")
return (
True,
"h264_nvenc",
"scale_cuda",
"-hwaccel cuda -hwaccel_output_format cuda",
"aac"
)
except (subprocess.CalledProcessError, subprocess.TimeoutExpired, FileNotFoundError):
pass
# No hardware acceleration available
self.logger.info("No hardware acceleration available, using software encoding")
return (False, "libx264", "scale", "", "aac")
@property
def hwaccel_available(self) -> bool:
"""Check if hardware acceleration is available."""
if self._hwaccel_available is None:
self._detect_and_set_hwaccel()
return self._hwaccel_available
@property
def video_encoder(self) -> str:
"""Get the video encoder to use."""
if self._video_encoder is None:
self._detect_and_set_hwaccel()
return self._video_encoder
@property
def scale_filter(self) -> str:
"""Get the scale filter to use."""
if self._scale_filter is None:
self._detect_and_set_hwaccel()
return self._scale_filter
@property
def hwaccel_decode_flags(self) -> str:
"""Get hardware acceleration decode flags."""
if self._hwaccel_decode_flags is None:
self._detect_and_set_hwaccel()
return self._hwaccel_decode_flags
@property
def aac_codec(self) -> str:
"""Get the AAC codec to use."""
if self._aac_codec is None:
self._detect_and_set_hwaccel()
return self._aac_codec
def _detect_and_set_hwaccel(self) -> None:
"""Detect and set hardware acceleration settings."""
(
self._hwaccel_available,
self._video_encoder,
self._scale_filter,
self._hwaccel_decode_flags,
self._aac_codec
) = self._detect_hardware_acceleration()
def _get_nvenc_quality_settings(self, preset: str = "medium") -> str:
"""Get NVENC quality settings for different presets."""
if not self.hwaccel_available:
return ""
settings = {
"lossless": "-preset p7 -tune hq -rc vbr -cq 0 -qmin 0 -qmax 0",
"high": "-preset p7 -tune hq -rc vbr -cq 19 -b:v 0",
"medium": "-preset p4 -tune hq -rc vbr -cq 23 -b:v 0",
"fast": "-preset p2 -tune ll -rc vbr -cq 28 -b:v 0",
}
return settings.get(preset, settings["medium"])
def _execute_command(
self,
command: str,
description: str,
timeout: int = 3600, # 1 hour default
) -> bool:
"""
Execute an FFmpeg command.
Args:
command: The FFmpeg command to execute
description: Human-readable description of the operation
timeout: Command timeout in seconds
Returns:
True if successful, False otherwise
"""
self.logger.info(f"Executing: {description}")
self.logger.debug(f"Command: {command}")
if self.dry_run:
self.logger.info(f"DRY RUN: Would execute: {command}")
return True
try:
result = subprocess.run(
command,
shell=True,
check=True,
capture_output=True,
text=True,
timeout=timeout
)
self.logger.info(f"Completed: {description}")
return True
except subprocess.CalledProcessError as e:
self.logger.error(f"Failed: {description}")
self.logger.error(f"Error: {e.stderr}")
return False
except subprocess.TimeoutExpired:
self.logger.error(f"Timeout: {description}")
return False
def _execute_command_with_fallback(
self,
gpu_command: str,
cpu_command: str,
description: str,
) -> bool:
"""
Execute a command with GPU, falling back to CPU if it fails.
Args:
gpu_command: Hardware-accelerated command
cpu_command: Software fallback command
description: Human-readable description
Returns:
True if successful, False otherwise
"""
if self.hwaccel_available:
self.logger.info(f"Trying hardware-accelerated encoding for: {description}")
if self._execute_command(gpu_command, description):
return True
self.logger.warning(f"Hardware encoding failed, falling back to software")
return self._execute_command(cpu_command, description)
def remux_with_instrumental(
self,
input_video: str,
instrumental_audio: str,
output_file: str,
) -> bool:
"""
Remux video with instrumental audio track.
Args:
input_video: Path to input video file
instrumental_audio: Path to instrumental audio file
output_file: Path for output file
Returns:
True if successful, False otherwise
"""
command = (
f'{self._ffmpeg_base_command} -i "{input_video}" '
f'-i "{instrumental_audio}" -map 0:v -map 1:a -c copy '
f'{self.MP4_FLAGS} "{output_file}"'
)
return self._execute_command(command, "Remuxing with instrumental audio")
def convert_mov_to_mp4(
self,
input_file: str,
output_file: str,
) -> bool:
"""
Convert MOV to MP4 format.
Args:
input_file: Path to input MOV file
output_file: Path for output MP4 file
Returns:
True if successful, False otherwise
"""
gpu_command = (
f'{self._ffmpeg_base_command} {self.hwaccel_decode_flags} -i "{input_file}" '
f'-c:v {self.video_encoder} -c:a copy {self.MP4_FLAGS} "{output_file}"'
)
cpu_command = (
f'{self._ffmpeg_base_command} -i "{input_file}" '
f'-c:v libx264 -c:a copy {self.MP4_FLAGS} "{output_file}"'
)
return self._execute_command_with_fallback(
gpu_command, cpu_command, "Converting MOV to MP4"
)
def encode_lossless_mp4(
self,
title_video: str,
karaoke_video: str,
output_file: str,
end_video: Optional[str] = None,
) -> bool:
"""
Create lossless 4K MP4 by concatenating title, karaoke, and optionally end videos.
Args:
title_video: Path to title video
karaoke_video: Path to karaoke video
output_file: Path for output file
end_video: Optional path to end credits video
Returns:
True if successful, False otherwise
"""
# Quote file paths
title_quoted = shlex.quote(os.path.abspath(title_video))
karaoke_quoted = shlex.quote(os.path.abspath(karaoke_video))
# Build filter and inputs for concatenation
if end_video and os.path.isfile(end_video):
end_quoted = shlex.quote(os.path.abspath(end_video))
extra_input = f"-i {end_quoted}"
concat_filter = (
'-filter_complex "[0:v:0][0:a:0][1:v:0][1:a:0][2:v:0][2:a:0]'
'concat=n=3:v=1:a=1[outv][outa]"'
)
else:
extra_input = ""
concat_filter = (
'-filter_complex "[0:v:0][0:a:0][1:v:0][1:a:0]'
'concat=n=2:v=1:a=1[outv][outa]"'
)
gpu_command = (
f"{self._ffmpeg_base_command} {self.hwaccel_decode_flags} -i {title_quoted} "
f"{self.hwaccel_decode_flags} -i {karaoke_quoted} {extra_input} "
f'{concat_filter} -map "[outv]" -map "[outa]" -c:v {self.video_encoder} '
f'{self._get_nvenc_quality_settings("lossless")} -c:a pcm_s16le '
f'{self.MP4_FLAGS} "{output_file}"'
)
cpu_command = (
f"{self._ffmpeg_base_command} -i {title_quoted} -i {karaoke_quoted} {extra_input} "
f'{concat_filter} -map "[outv]" -map "[outa]" -c:v libx264 -c:a pcm_s16le '
f'{self.MP4_FLAGS} "{output_file}"'
)
return self._execute_command_with_fallback(
gpu_command, cpu_command, "Encoding lossless 4K MP4"
)
def encode_lossy_mp4(
self,
input_file: str,
output_file: str,
) -> bool:
"""
Create lossy 4K MP4 with AAC audio.
Args:
input_file: Path to input file (typically lossless MP4)
output_file: Path for output file
Returns:
True if successful, False otherwise
"""
command = (
f'{self._ffmpeg_base_command} -i "{input_file}" '
f'-c:v copy -c:a {self.aac_codec} -ar 48000 -b:a 320k '
f'{self.MP4_FLAGS} "{output_file}"'
)
return self._execute_command(command, "Encoding lossy 4K MP4 with AAC")
def encode_lossless_mkv(
self,
input_file: str,
output_file: str,
) -> bool:
"""
Create MKV with FLAC audio (for YouTube upload).
Args:
input_file: Path to input file
output_file: Path for output file
Returns:
True if successful, False otherwise
"""
command = (
f'{self._ffmpeg_base_command} -i "{input_file}" '
f'-c:v copy -c:a flac "{output_file}"'
)
return self._execute_command(command, "Creating MKV with FLAC for YouTube")
def encode_720p(
self,
input_file: str,
output_file: str,
) -> bool:
"""
Create 720p MP4 with AAC audio.
Args:
input_file: Path to input file
output_file: Path for output file
Returns:
True if successful, False otherwise
"""
gpu_command = (
f'{self._ffmpeg_base_command} {self.hwaccel_decode_flags} -i "{input_file}" '
f'-c:v {self.video_encoder} -vf "{self.scale_filter}=1280:720" '
f'{self._get_nvenc_quality_settings("medium")} -b:v 2000k '
f'-c:a {self.aac_codec} -ar 48000 -b:a 128k '
f'{self.MP4_FLAGS} "{output_file}"'
)
cpu_command = (
f'{self._ffmpeg_base_command} -i "{input_file}" '
f'-c:v libx264 -vf "scale=1280:720" -b:v 2000k -preset medium -tune animation '
f'-c:a {self.aac_codec} -ar 48000 -b:a 128k '
f'{self.MP4_FLAGS} "{output_file}"'
)
return self._execute_command_with_fallback(
gpu_command, cpu_command, "Encoding 720p MP4"
)
def encode_all_formats(
self,
config: EncodingConfig,
) -> EncodingResult:
"""
Encode video to all output formats.
This performs the full encoding pipeline:
1. Remux with instrumental audio
2. Convert to MP4 if needed
3. Encode lossless 4K MP4 (concatenated)
4. Encode lossy 4K MP4
5. Encode lossless MKV (for YouTube)
6. Encode 720p MP4
Args:
config: Encoding configuration with input/output paths
Returns:
EncodingResult with success status and output file paths
"""
output_files = {}
try:
# Step 1: Remux with instrumental audio
if config.output_karaoke_mp4:
self.logger.info("[Step 1/6] Remuxing video with instrumental audio...")
if not self.remux_with_instrumental(
config.karaoke_video,
config.instrumental_audio,
config.output_karaoke_mp4
):
return EncodingResult(
success=False,
output_files=output_files,
error="Failed to remux with instrumental audio"
)
output_files["karaoke_mp4"] = config.output_karaoke_mp4
# Step 2: Convert to MP4 if needed
if config.output_with_vocals_mp4:
if not config.karaoke_video.endswith(".mp4"):
self.logger.info("[Step 2/6] Converting karaoke video to MP4...")
if not self.convert_mov_to_mp4(
config.karaoke_video,
config.output_with_vocals_mp4
):
return EncodingResult(
success=False,
output_files=output_files,
error="Failed to convert to MP4"
)
output_files["with_vocals_mp4"] = config.output_with_vocals_mp4
else:
self.logger.info("[Step 2/6] Skipped - video already MP4")
# Step 3: Encode lossless 4K MP4
if config.output_lossless_4k_mp4:
self.logger.info("[Step 3/6] Encoding lossless 4K MP4...")
karaoke_for_concat = config.output_karaoke_mp4 or config.karaoke_video
if not self.encode_lossless_mp4(
config.title_video,
karaoke_for_concat,
config.output_lossless_4k_mp4,
config.end_video
):
return EncodingResult(
success=False,
output_files=output_files,
error="Failed to encode lossless 4K MP4"
)
output_files["lossless_4k_mp4"] = config.output_lossless_4k_mp4
# Step 4: Encode lossy 4K MP4
if config.output_lossy_4k_mp4 and config.output_lossless_4k_mp4:
self.logger.info("[Step 4/6] Encoding lossy 4K MP4...")
if not self.encode_lossy_mp4(
config.output_lossless_4k_mp4,
config.output_lossy_4k_mp4
):
return EncodingResult(
success=False,
output_files=output_files,
error="Failed to encode lossy 4K MP4"
)
output_files["lossy_4k_mp4"] = config.output_lossy_4k_mp4
# Step 5: Create MKV with FLAC audio
if config.output_lossless_mkv and config.output_lossless_4k_mp4:
self.logger.info("[Step 5/6] Creating MKV with FLAC audio...")
if not self.encode_lossless_mkv(
config.output_lossless_4k_mp4,
config.output_lossless_mkv
):
return EncodingResult(
success=False,
output_files=output_files,
error="Failed to create MKV"
)
output_files["lossless_mkv"] = config.output_lossless_mkv
# Step 6: Encode 720p version
if config.output_720p_mp4 and config.output_lossless_4k_mp4:
self.logger.info("[Step 6/6] Encoding 720p MP4...")
if not self.encode_720p(
config.output_lossless_4k_mp4,
config.output_720p_mp4
):
return EncodingResult(
success=False,
output_files=output_files,
error="Failed to encode 720p"
)
output_files["720p_mp4"] = config.output_720p_mp4
self.logger.info("All encoding steps completed successfully")
return EncodingResult(success=True, output_files=output_files)
except Exception as e:
self.logger.error(f"Encoding failed with exception: {e}")
return EncodingResult(
success=False,
output_files=output_files,
error=str(e)
)
# Singleton instance and factory function (following existing service pattern)
_local_encoding_service: Optional[LocalEncodingService] = None
def get_local_encoding_service(**kwargs) -> LocalEncodingService:
"""
Get a local encoding service instance.
Args:
**kwargs: Arguments passed to LocalEncodingService
Returns:
LocalEncodingService instance
"""
global _local_encoding_service
if _local_encoding_service is None:
_local_encoding_service = LocalEncodingService(**kwargs)
return _local_encoding_service
-216
View File
@@ -1,216 +0,0 @@
"""
LyricsTranscriber cache synchronization with GCS.
This service persists LyricsTranscriber's cache files to GCS so that
cloud workers (Cloud Run instances) can share cache across containers.
Cache files are stored flat in GCS under lyrics-transcriber-cache/ prefix:
- Transcription: {provider}_{audio_hash}_raw.json, {provider}_{audio_hash}_converted.json
- Lyrics: {provider}_{artist_title_hash}_raw.json, {provider}_{artist_title_hash}_converted.json
Hash computation matches LyricsTranscriber's implementation exactly:
- Audio hash: MD5 of audio file bytes
- Lyrics hash: MD5 of "{artist.lower()}_{title.lower()}"
"""
import hashlib
import logging
import os
from typing import Dict, List, Optional
from backend.services.storage_service import StorageService
logger = logging.getLogger(__name__)
# Providers that use audio file hash as cache key
TRANSCRIPTION_PROVIDERS = ["audioshake", "whisper", "localwhisper"]
# Providers that use artist+title hash as cache key
LYRICS_PROVIDERS = ["genius", "spotify", "lrclib", "musixmatch"]
# Cache file suffixes
CACHE_SUFFIXES = ["raw", "converted"]
class LyricsCacheService:
"""Service to sync LyricsTranscriber cache with GCS."""
GCS_CACHE_PREFIX = "lyrics-transcriber-cache/"
def __init__(self, storage: Optional[StorageService] = None):
"""Initialize the cache service.
Args:
storage: StorageService instance. If None, creates a new one.
"""
self.storage = storage or StorageService()
def compute_audio_hash(self, audio_path: str) -> str:
"""Compute MD5 hash of audio file bytes.
This matches LyricsTranscriber's _get_file_hash() method exactly.
Args:
audio_path: Path to the audio file.
Returns:
MD5 hex digest of the file contents.
"""
md5_hash = hashlib.md5()
with open(audio_path, "rb") as f:
for chunk in iter(lambda: f.read(4096), b""):
md5_hash.update(chunk)
return md5_hash.hexdigest()
def compute_lyrics_hash(self, artist: str, title: str) -> str:
"""Compute MD5 hash of artist and title.
This matches LyricsTranscriber's _get_artist_title_hash() method exactly.
Args:
artist: Artist name.
title: Track title.
Returns:
MD5 hex digest of "{artist.lower()}_{title.lower()}".
"""
combined = f"{artist.lower()}_{title.lower()}"
return hashlib.md5(combined.encode()).hexdigest()
def _get_cache_filenames(
self, providers: List[str], hash_value: str
) -> List[str]:
"""Generate list of possible cache filenames for given providers and hash.
Args:
providers: List of provider names (e.g., ["audioshake", "whisper"]).
hash_value: The hash to use in filenames.
Returns:
List of filenames like ["audioshake_abc123_raw.json", ...].
"""
filenames = []
for provider in providers:
for suffix in CACHE_SUFFIXES:
filenames.append(f"{provider}_{hash_value}_{suffix}.json")
return filenames
def sync_cache_from_gcs(
self,
local_cache_dir: str,
audio_hash: str,
lyrics_hash: str,
) -> Dict[str, int]:
"""Download relevant cache files from GCS to local directory.
Downloads cache files for both transcription (audio hash) and
lyrics (artist+title hash) providers.
Args:
local_cache_dir: Local directory to download cache files to.
audio_hash: MD5 hash of audio file.
lyrics_hash: MD5 hash of artist+title.
Returns:
Dict with counts: {"downloaded": N, "not_found": M, "errors": E}
"""
os.makedirs(local_cache_dir, exist_ok=True)
stats = {"downloaded": 0, "not_found": 0, "errors": 0}
# Get all possible cache filenames
transcription_files = self._get_cache_filenames(
TRANSCRIPTION_PROVIDERS, audio_hash
)
lyrics_files = self._get_cache_filenames(LYRICS_PROVIDERS, lyrics_hash)
all_files = transcription_files + lyrics_files
for filename in all_files:
gcs_path = f"{self.GCS_CACHE_PREFIX}{filename}"
local_path = os.path.join(local_cache_dir, filename)
try:
if self.storage.file_exists(gcs_path):
self.storage.download_file(gcs_path, local_path)
logger.info(f"Cache hit: downloaded {filename}")
stats["downloaded"] += 1
else:
logger.debug(f"Cache miss: {filename} not in GCS")
stats["not_found"] += 1
except Exception as e:
logger.warning(f"Error downloading cache file {filename}: {e}")
stats["errors"] += 1
logger.info(
f"Cache sync from GCS complete: "
f"{stats['downloaded']} downloaded, "
f"{stats['not_found']} not found, "
f"{stats['errors']} errors"
)
return stats
def sync_cache_to_gcs(
self,
local_cache_dir: str,
audio_hash: str,
lyrics_hash: str,
) -> Dict[str, int]:
"""Upload new cache files from local directory to GCS.
Only uploads files that match expected cache patterns for the given
hashes and don't already exist in GCS.
Args:
local_cache_dir: Local directory with cache files.
audio_hash: MD5 hash of audio file.
lyrics_hash: MD5 hash of artist+title.
Returns:
Dict with counts: {"uploaded": N, "skipped": M, "errors": E}
"""
stats = {"uploaded": 0, "skipped": 0, "errors": 0}
if not os.path.exists(local_cache_dir):
logger.warning(f"Local cache dir does not exist: {local_cache_dir}")
return stats
# Get all possible cache filenames we're interested in
transcription_files = self._get_cache_filenames(
TRANSCRIPTION_PROVIDERS, audio_hash
)
lyrics_files = self._get_cache_filenames(LYRICS_PROVIDERS, lyrics_hash)
expected_files = set(transcription_files + lyrics_files)
# Check each file in local cache dir
for filename in os.listdir(local_cache_dir):
# Only process files we expect (matching our hash patterns)
if filename not in expected_files:
continue
local_path = os.path.join(local_cache_dir, filename)
if not os.path.isfile(local_path):
continue
gcs_path = f"{self.GCS_CACHE_PREFIX}{filename}"
try:
# Skip if already exists in GCS (same hash = same content)
if self.storage.file_exists(gcs_path):
logger.debug(f"Cache file already in GCS: {filename}")
stats["skipped"] += 1
continue
self.storage.upload_file(local_path, gcs_path)
logger.info(f"Uploaded cache file: {filename}")
stats["uploaded"] += 1
except Exception as e:
logger.warning(f"Error uploading cache file {filename}: {e}")
stats["errors"] += 1
logger.info(
f"Cache sync to GCS complete: "
f"{stats['uploaded']} uploaded, "
f"{stats['skipped']} skipped (already exist), "
f"{stats['errors']} errors"
)
return stats
-287
View File
@@ -1,287 +0,0 @@
"""
Packaging Service.
Provides CDG and TXT package generation functionality, extracted from KaraokeFinalise
for use by both the cloud backend (video_worker) and local CLI.
This service handles:
- CDG (CD+G) file generation from LRC files
- TXT lyric file generation from LRC files
- ZIP packaging of CDG/MP3 and TXT/MP3 pairs
"""
import logging
import os
import zipfile
from typing import Optional, Dict, Any, Tuple
logger = logging.getLogger(__name__)
class PackagingService:
"""
Service for creating CDG and TXT karaoke packages.
CDG (CD+Graphics) is a format used by karaoke machines.
TXT packages are used by software karaoke players.
Both formats are packaged as ZIP files with an MP3 audio track.
"""
def __init__(
self,
cdg_styles: Optional[Dict[str, Any]] = None,
dry_run: bool = False,
non_interactive: bool = False,
logger: Optional[logging.Logger] = None,
):
"""
Initialize the packaging service.
Args:
cdg_styles: CDG style configuration for CDG generation
dry_run: If True, log actions without performing them
non_interactive: If True, skip interactive prompts
logger: Optional logger instance
"""
self.cdg_styles = cdg_styles
self.dry_run = dry_run
self.non_interactive = non_interactive
self.logger = logger or logging.getLogger(__name__)
def create_cdg_package(
self,
lrc_file: str,
audio_file: str,
output_zip_path: str,
artist: str,
title: str,
output_mp3_path: Optional[str] = None,
output_cdg_path: Optional[str] = None,
) -> Tuple[str, Optional[str], Optional[str]]:
"""
Create a CDG package (ZIP containing CDG and MP3 files).
Args:
lrc_file: Path to the LRC lyrics file
audio_file: Path to the instrumental audio file
output_zip_path: Path for the output ZIP file
artist: Artist name for metadata
title: Song title for metadata
output_mp3_path: Optional path for the extracted MP3 file
output_cdg_path: Optional path for the extracted CDG file
Returns:
Tuple of (zip_path, mp3_path, cdg_path)
Raises:
ValueError: If CDG styles are not configured
FileNotFoundError: If input files are missing
Exception: If CDG generation fails
"""
self.logger.info(f"Creating CDG package for {artist} - {title}")
# Validate inputs
if not os.path.isfile(lrc_file):
raise FileNotFoundError(f"LRC file not found: {lrc_file}")
if not os.path.isfile(audio_file):
raise FileNotFoundError(f"Audio file not found: {audio_file}")
# Check if ZIP already exists
if os.path.isfile(output_zip_path):
if self.non_interactive:
self.logger.info(
f"CDG ZIP exists, will be overwritten: {output_zip_path}"
)
else:
self.logger.info(f"CDG ZIP already exists: {output_zip_path}")
# Check if individual files exist (allows skipping generation)
if output_mp3_path and output_cdg_path:
if os.path.isfile(output_mp3_path) and os.path.isfile(output_cdg_path):
self.logger.info("Found existing MP3 and CDG files, creating ZIP directly")
if not self.dry_run:
self._create_zip_from_files(
output_zip_path,
[(output_mp3_path, os.path.basename(output_mp3_path)),
(output_cdg_path, os.path.basename(output_cdg_path))]
)
return output_zip_path, output_mp3_path, output_cdg_path
if self.dry_run:
self.logger.info(
f"DRY RUN: Would generate CDG package: {output_zip_path}"
)
return output_zip_path, output_mp3_path, output_cdg_path
# Generate CDG files
if self.cdg_styles is None:
raise ValueError(
"CDG styles configuration is required for CDG generation"
)
self.logger.info("Generating CDG and MP3 files")
from lyrics_transcriber.output.cdg import CDGGenerator
output_dir = os.path.dirname(output_zip_path) or os.getcwd()
generator = CDGGenerator(output_dir=output_dir, logger=self.logger)
cdg_file, mp3_file, zip_file = generator.generate_cdg_from_lrc(
lrc_file=lrc_file,
audio_file=audio_file,
title=title,
artist=artist,
cdg_styles=self.cdg_styles,
)
# Rename ZIP to expected output path if different
if os.path.isfile(zip_file) and zip_file != output_zip_path:
os.rename(zip_file, output_zip_path)
self.logger.info(f"Renamed CDG ZIP: {zip_file} -> {output_zip_path}")
if not os.path.isfile(output_zip_path):
raise Exception(f"Failed to create CDG ZIP file: {output_zip_path}")
# Extract the ZIP to get individual files if paths provided
extracted_mp3 = None
extracted_cdg = None
if output_mp3_path or output_cdg_path:
self.logger.info(f"Extracting CDG ZIP file: {output_zip_path}")
with zipfile.ZipFile(output_zip_path, "r") as zip_ref:
zip_ref.extractall(output_dir)
# Find extracted files
if output_mp3_path and os.path.isfile(output_mp3_path):
extracted_mp3 = output_mp3_path
self.logger.info(f"Extracted MP3: {extracted_mp3}")
if output_cdg_path and os.path.isfile(output_cdg_path):
extracted_cdg = output_cdg_path
self.logger.info(f"Extracted CDG: {extracted_cdg}")
self.logger.info(f"CDG package created: {output_zip_path}")
return output_zip_path, extracted_mp3, extracted_cdg
def create_txt_package(
self,
lrc_file: str,
mp3_file: str,
output_zip_path: str,
output_txt_path: Optional[str] = None,
) -> Tuple[str, Optional[str]]:
"""
Create a TXT package (ZIP containing TXT lyrics and MP3 files).
Args:
lrc_file: Path to the LRC lyrics file
mp3_file: Path to the MP3 audio file
output_zip_path: Path for the output ZIP file
output_txt_path: Optional path for the generated TXT file
Returns:
Tuple of (zip_path, txt_path)
Raises:
FileNotFoundError: If input files are missing
Exception: If TXT generation fails
"""
self.logger.info(f"Creating TXT package from {lrc_file}")
# Validate inputs
if not os.path.isfile(lrc_file):
raise FileNotFoundError(f"LRC file not found: {lrc_file}")
if not os.path.isfile(mp3_file):
raise FileNotFoundError(f"MP3 file not found: {mp3_file}")
# Check if ZIP already exists
if os.path.isfile(output_zip_path):
if self.non_interactive:
self.logger.info(
f"TXT ZIP exists, will be overwritten: {output_zip_path}"
)
else:
self.logger.info(f"TXT ZIP already exists: {output_zip_path}")
if self.dry_run:
self.logger.info(
f"DRY RUN: Would create TXT package: {output_zip_path}"
)
return output_zip_path, output_txt_path
# Generate TXT from LRC
self.logger.info(f"Converting LRC to TXT format: {lrc_file}")
from lyrics_converter import LyricsConverter
txt_converter = LyricsConverter(output_format="txt", filepath=lrc_file)
converted_txt = txt_converter.convert_file()
# Write TXT file
if output_txt_path is None:
# Default to same name as ZIP but with .txt extension
output_txt_path = output_zip_path.replace(".zip", ".txt")
with open(output_txt_path, "w") as txt_file:
txt_file.write(converted_txt)
self.logger.info(f"TXT file written: {output_txt_path}")
# Create ZIP containing MP3 and TXT
self.logger.info(f"Creating TXT ZIP: {output_zip_path}")
self._create_zip_from_files(
output_zip_path,
[(mp3_file, os.path.basename(mp3_file)),
(output_txt_path, os.path.basename(output_txt_path))]
)
if not os.path.isfile(output_zip_path):
raise Exception(f"Failed to create TXT ZIP file: {output_zip_path}")
self.logger.info(f"TXT package created: {output_zip_path}")
return output_zip_path, output_txt_path
def _create_zip_from_files(
self,
zip_path: str,
files: list,
) -> None:
"""
Create a ZIP file from a list of files.
Args:
zip_path: Path for the output ZIP file
files: List of (file_path, archive_name) tuples
"""
with zipfile.ZipFile(zip_path, "w") as zipf:
for file_path, archive_name in files:
if os.path.isfile(file_path):
zipf.write(file_path, archive_name)
self.logger.debug(f"Added to ZIP: {archive_name}")
else:
self.logger.warning(f"File not found for ZIP: {file_path}")
# Singleton instance and factory function (following existing service pattern)
_packaging_service: Optional[PackagingService] = None
def get_packaging_service(
cdg_styles: Optional[Dict[str, Any]] = None,
**kwargs
) -> PackagingService:
"""
Get a packaging service instance.
Args:
cdg_styles: CDG style configuration
**kwargs: Additional arguments passed to PackagingService
Returns:
PackagingService instance
"""
global _packaging_service
# Create new instance if settings changed
if _packaging_service is None or cdg_styles:
_packaging_service = PackagingService(
cdg_styles=cdg_styles,
**kwargs
)
return _packaging_service
-275
View File
@@ -1,275 +0,0 @@
"""
Stripe service for payment processing.
Handles:
- Creating checkout sessions for credit purchases
- Processing webhook events
- Managing customer records
"""
import logging
import os
from typing import Optional, Dict, Any, Tuple
import stripe
from backend.config import get_settings
logger = logging.getLogger(__name__)
# Credit packages available for purchase
CREDIT_PACKAGES = {
"1_credit": {
"credits": 1,
"price_cents": 500, # $5.00
"name": "1 Karaoke Credit",
"description": "Create 1 professional karaoke video",
},
"3_credits": {
"credits": 3,
"price_cents": 1200, # $12.00 (20% discount)
"name": "3 Karaoke Credits",
"description": "Create 3 professional karaoke videos (Save 20%)",
},
"5_credits": {
"credits": 5,
"price_cents": 1750, # $17.50 (30% discount)
"name": "5 Karaoke Credits",
"description": "Create 5 professional karaoke videos (Save 30%)",
},
"10_credits": {
"credits": 10,
"price_cents": 3000, # $30.00 (40% discount)
"name": "10 Karaoke Credits",
"description": "Create 10 professional karaoke videos (Save 40%)",
},
}
class StripeService:
"""Service for Stripe payment processing."""
def __init__(self):
"""Initialize Stripe with API key."""
self.settings = get_settings()
self.secret_key = os.getenv("STRIPE_SECRET_KEY")
self.webhook_secret = os.getenv("STRIPE_WEBHOOK_SECRET")
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)
if self.secret_key:
stripe.api_key = self.secret_key
logger.info("Stripe initialized with API key")
else:
logger.warning("STRIPE_SECRET_KEY not set - payments disabled")
def is_configured(self) -> bool:
"""Check if Stripe is properly configured."""
return bool(self.secret_key)
def get_credit_packages(self) -> Dict[str, Dict[str, Any]]:
"""Get available credit packages."""
return CREDIT_PACKAGES
def create_checkout_session(
self,
package_id: str,
user_email: str,
success_url: Optional[str] = None,
cancel_url: Optional[str] = None,
) -> Tuple[bool, Optional[str], str]:
"""
Create a Stripe Checkout session for purchasing credits.
Args:
package_id: ID of the credit package to purchase
user_email: Email of the purchasing user
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"
package = CREDIT_PACKAGES.get(package_id)
if not package:
return False, None, f"Invalid package: {package_id}"
try:
# Default URLs
if not success_url:
success_url = f"{self.frontend_url}/payment/success?session_id={{CHECKOUT_SESSION_ID}}"
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=[{
'price_data': {
'currency': 'usd',
'product_data': {
'name': package['name'],
'description': package['description'],
},
'unit_amount': package['price_cents'],
},
'quantity': 1,
}],
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,
)
logger.info(f"Created checkout session {session.id} for {user_email}, package {package_id}")
return True, session.url, "Checkout session created"
except stripe.error.StripeError as e:
logger.error(f"Stripe error creating checkout session: {e}")
return False, None, f"Payment error: {str(e)}"
except Exception as e:
logger.error(f"Error creating 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.
Args:
payload: Raw request body
signature: Stripe-Signature header value
Returns:
(valid, event_data, message)
"""
if not self.webhook_secret:
logger.error("STRIPE_WEBHOOK_SECRET not configured")
return False, None, "Webhook secret not configured"
try:
event = stripe.Webhook.construct_event(
payload, signature, self.webhook_secret
)
return True, event, "Webhook verified"
except stripe.error.SignatureVerificationError as e:
logger.error(f"Invalid webhook signature: {e}")
return False, None, "Invalid signature"
except Exception as e:
logger.error(f"Error verifying webhook: {e}")
return False, None, str(e)
def handle_checkout_completed(self, session: Dict) -> Tuple[bool, Optional[str], int, str]:
"""
Handle a completed checkout session.
Args:
session: Stripe checkout session object
Returns:
(success, user_email, credits_to_add, message)
"""
try:
metadata = session.get('metadata', {})
user_email = metadata.get('user_email') or session.get('customer_email')
try:
credits = int(metadata.get('credits', 0))
except (ValueError, TypeError):
logger.error(f"Invalid credits metadata in session {session.get('id')}: {metadata.get('credits')}")
return False, user_email, 0, "Invalid credit amount in session metadata"
package_id = metadata.get('package_id')
if not user_email:
logger.error(f"No user email in checkout session {session.get('id')}")
return False, None, 0, "No user email found"
if credits <= 0:
logger.error(f"Invalid credits in checkout session {session.get('id')}")
return False, user_email, 0, "Invalid credit amount"
logger.info(
f"Checkout completed: {user_email} purchased {credits} credits "
f"(package: {package_id}, session: {session.get('id')})"
)
return True, user_email, credits, f"Successfully purchased {credits} credits"
except Exception as e:
logger.error(f"Error handling checkout completed: {e}")
return False, None, 0, str(e)
def get_session(self, session_id: str) -> Optional[Dict]:
"""
Get a checkout session by ID.
Args:
session_id: Stripe checkout session ID
Returns:
Session data or None
"""
if not self.is_configured():
return None
try:
session = stripe.checkout.Session.retrieve(session_id)
return dict(session)
except Exception as e:
logger.error(f"Error retrieving session {session_id}: {e}")
return None
def create_customer(self, email: str, name: Optional[str] = None) -> Optional[str]:
"""
Create or get a Stripe customer for a user.
Args:
email: User's email
name: User's display name (optional)
Returns:
Stripe customer ID or None
"""
if not self.is_configured():
return None
try:
# Check if customer already exists
customers = stripe.Customer.list(email=email, limit=1)
if customers.data:
return customers.data[0].id
# Create new customer
customer = stripe.Customer.create(
email=email,
name=name,
metadata={'source': 'nomad_karaoke'},
)
logger.info(f"Created Stripe customer {customer.id} for {email}")
return customer.id
except Exception as e:
logger.error(f"Error creating Stripe customer: {e}")
return None
# Global instance
_stripe_service = None
def get_stripe_service() -> StripeService:
"""Get the global Stripe service instance."""
global _stripe_service
if _stripe_service is None:
_stripe_service = StripeService()
return _stripe_service
+1 -9
View File
@@ -91,15 +91,7 @@ class StructuredFormatter(logging.Formatter):
# Add custom fields from 'extra' dict
# Common fields we want to extract from log records
custom_fields = [
# Job-related fields
"job_id", "worker", "operation", "duration", "status", "error",
# Audit logging fields (from middleware and auth)
"request_id", "user_email", "client_ip", "latency_ms",
"audit_type", "method", "path", "status_code", "query_string",
"user_agent", "user_type", "is_admin", "remaining_uses",
"auth_message", "token_provided", "token_length", "auth_header_present",
]
custom_fields = ["job_id", "worker", "operation", "duration", "status", "error"]
for field in custom_fields:
value = getattr(record, field, None)
if value is not None:
-721
View File
@@ -1,721 +0,0 @@
"""
User service for authentication, credits, and user management.
Handles:
- Magic link authentication (send, verify)
- Session management
- Credit operations (add, deduct, refund)
- User CRUD operations
"""
import logging
import secrets
import uuid
from datetime import datetime, timedelta, timezone
from typing import Optional, List, Tuple
from google.cloud import firestore
from google.cloud.firestore_v1 import FieldFilter
from google.cloud.firestore_v1 import Increment
from backend.config import get_settings
from backend.models.user import (
User,
UserRole,
UserPublic,
MagicLinkToken,
Session,
CreditTransaction,
)
logger = logging.getLogger(__name__)
# Collection names
USERS_COLLECTION = "gen_users"
MAGIC_LINKS_COLLECTION = "magic_links"
SESSIONS_COLLECTION = "sessions"
PROCESSED_STRIPE_SESSIONS_COLLECTION = "processed_stripe_sessions"
# Token/session configuration
MAGIC_LINK_EXPIRY_MINUTES = 15
SESSION_EXPIRY_DAYS = 7
SESSION_ABSOLUTE_EXPIRY_DAYS = 30
MAX_CREDIT_TRANSACTIONS = 100 # Keep last N transactions
class UserService:
"""Service for user management and authentication."""
# Number of free credits granted to new users
NEW_USER_FREE_CREDITS = 1
def __init__(self):
"""Initialize user service with Firestore client."""
self.settings = get_settings()
self.db = firestore.Client(project=self.settings.google_cloud_project)
# =========================================================================
# User CRUD Operations
# =========================================================================
def get_user(self, email: str) -> Optional[User]:
"""Get a user by email."""
try:
doc_ref = self.db.collection(USERS_COLLECTION).document(email.lower())
doc = doc_ref.get()
if not doc.exists:
return None
return User(**doc.to_dict())
except Exception:
logger.exception(f"Error getting user {email}")
return None
def get_or_create_user(self, email: str) -> User:
"""
Get existing user or create a new one.
New users receive a welcome credit to try the service.
"""
email = email.lower()
user = self.get_user(email)
if user:
return user
# Create new user with welcome credit
welcome_credit = self.NEW_USER_FREE_CREDITS
welcome_transaction = CreditTransaction(
id=str(uuid.uuid4()),
amount=welcome_credit,
reason="welcome_credit",
)
user = User(
email=email,
credits=welcome_credit,
credit_transactions=[welcome_transaction],
)
self._save_user(user)
logger.info(f"Created new user: {email} with {welcome_credit} welcome credit(s)")
return user
def _save_user(self, user: User) -> None:
"""Save user to Firestore."""
try:
user.updated_at = datetime.utcnow()
doc_ref = self.db.collection(USERS_COLLECTION).document(user.email.lower())
doc_ref.set(user.model_dump(mode='json'))
except Exception:
logger.exception(f"Error saving user {user.email}")
raise
def update_user(self, email: str, **updates) -> Optional[User]:
"""Update user fields."""
try:
updates['updated_at'] = datetime.utcnow()
doc_ref = self.db.collection(USERS_COLLECTION).document(email.lower())
doc_ref.update(updates)
return self.get_user(email)
except Exception:
logger.exception(f"Error updating user {email}")
return None
def list_users(self, limit: int = 100, include_inactive: bool = False) -> List[User]:
"""List all users (admin only)."""
try:
query = self.db.collection(USERS_COLLECTION)
if not include_inactive:
query = query.where(filter=FieldFilter('is_active', '==', True))
query = query.order_by('created_at', direction=firestore.Query.DESCENDING)
query = query.limit(limit)
docs = query.stream()
return [User(**doc.to_dict()) for doc in docs]
except Exception:
logger.exception("Error listing users")
return []
def get_user_public(self, email: str) -> Optional[UserPublic]:
"""Get public user info."""
user = self.get_user(email)
if not user:
return None
return UserPublic(
email=user.email,
role=user.role,
credits=user.credits,
display_name=user.display_name,
total_jobs_created=user.total_jobs_created,
total_jobs_completed=user.total_jobs_completed,
)
# =========================================================================
# Magic Link Authentication
# =========================================================================
def create_magic_link(
self,
email: str,
ip_address: Optional[str] = None,
user_agent: Optional[str] = None
) -> MagicLinkToken:
"""
Create a magic link token for email authentication.
Returns the token object. The actual sending of the email
should be handled by the caller (or an email service).
"""
email = email.lower()
# Ensure user exists
self.get_or_create_user(email)
# Generate secure token
token = secrets.token_urlsafe(32)
magic_link = MagicLinkToken(
token=token,
email=email,
expires_at=datetime.utcnow() + timedelta(minutes=MAGIC_LINK_EXPIRY_MINUTES),
ip_address=ip_address,
user_agent=user_agent,
)
# Save to Firestore
doc_ref = self.db.collection(MAGIC_LINKS_COLLECTION).document(token)
doc_ref.set(magic_link.model_dump(mode='json'))
logger.info(f"Created magic link for {email}")
return magic_link
def verify_magic_link(self, token: str) -> Tuple[bool, Optional[User], str]:
"""
Verify a magic link token using a Firestore transaction to prevent race conditions.
Returns:
(success, user, message)
"""
try:
doc_ref = self.db.collection(MAGIC_LINKS_COLLECTION).document(token)
@firestore.transactional
def verify_in_transaction(transaction):
"""Atomically verify and mark magic link as used."""
doc = doc_ref.get(transaction=transaction)
if not doc.exists:
return False, None, "Invalid or expired link"
magic_link = MagicLinkToken(**doc.to_dict())
# Check if already used
if magic_link.used:
return False, None, "This link has already been used"
# Check expiry
if datetime.utcnow() > magic_link.expires_at:
return False, None, "This link has expired"
# Mark as used atomically within transaction
transaction.update(doc_ref, {
'used': True,
'used_at': datetime.utcnow()
})
return True, magic_link.email, "Success"
# Execute the transaction
transaction = self.db.transaction()
success, email_or_error, message = verify_in_transaction(transaction)
if not success:
return False, None, message
# Get user and mark email as verified (outside transaction)
user = self.get_user(email_or_error)
if user:
self.update_user(
email_or_error,
email_verified=True,
last_login_at=datetime.utcnow()
)
user = self.get_user(email_or_error) # Refresh
logger.info(f"Magic link verified for {email_or_error}")
return True, user, "Successfully authenticated"
except Exception:
logger.exception("Error verifying magic link")
return False, None, "An error occurred during verification"
# =========================================================================
# Session Management
# =========================================================================
def create_session(
self,
user_email: str,
ip_address: Optional[str] = None,
user_agent: Optional[str] = None
) -> Session:
"""Create a new session for an authenticated user."""
token = secrets.token_urlsafe(32)
token_prefix = token[:12]
session = Session(
token=token,
user_email=user_email.lower(),
expires_at=datetime.utcnow() + timedelta(days=SESSION_ABSOLUTE_EXPIRY_DAYS),
ip_address=ip_address,
user_agent=user_agent,
)
# Serialize and write to Firestore
session_data = session.model_dump(mode='json')
doc_ref = self.db.collection(SESSIONS_COLLECTION).document(token)
doc_ref.set(session_data)
# Verify the write succeeded by reading back
verify_doc = doc_ref.get()
if not verify_doc.exists:
logger.error(f"Session write verification FAILED for {user_email}: {token_prefix}...")
raise RuntimeError(f"Failed to persist session for {user_email}")
logger.info(f"Created and verified session for {user_email}: {token_prefix}... (expires: {session.expires_at})")
return session
def validate_session(self, token: str) -> Tuple[bool, Optional[User], str]:
"""
Validate a session token.
Returns:
(valid, user, message)
"""
# Log token info for debugging (only prefix for security)
token_prefix = token[:12] if token and len(token) >= 12 else token
logger.debug(f"Validating session token: {token_prefix}... (len={len(token) if token else 0})")
try:
doc_ref = self.db.collection(SESSIONS_COLLECTION).document(token)
doc = doc_ref.get()
if not doc.exists:
logger.warning(f"Session not found in Firestore: {token_prefix}...")
return False, None, "Invalid session"
raw_data = doc.to_dict()
logger.debug(f"Session data found for {token_prefix}...: user_email={raw_data.get('user_email')}, is_active={raw_data.get('is_active')}")
session = Session(**raw_data)
# Check if active
if not session.is_active:
logger.warning(f"Session revoked for {token_prefix}... (user: {session.user_email})")
return False, None, "Session has been revoked"
# Use timezone-aware datetime for all comparisons
# Firestore returns timezone-aware datetimes, so we must use aware datetimes
now = datetime.now(timezone.utc)
# Normalize session datetimes to be timezone-aware for comparison
# (handles legacy naive datetimes that may exist in Firestore)
expires_at = session.expires_at
if expires_at.tzinfo is None:
expires_at = expires_at.replace(tzinfo=timezone.utc)
last_activity = session.last_activity_at
if last_activity.tzinfo is None:
last_activity = last_activity.replace(tzinfo=timezone.utc)
# Check expiry
if now > expires_at:
logger.warning(f"Session expired for {token_prefix}... (user: {session.user_email}, expired_at: {expires_at}, now: {now})")
return False, None, "Session has expired"
# Check inactivity (7 days)
inactivity_limit = now - timedelta(days=SESSION_EXPIRY_DAYS)
if last_activity < inactivity_limit:
logger.warning(f"Session inactive for {token_prefix}... (user: {session.user_email}, last_activity: {last_activity}, limit: {inactivity_limit})")
return False, None, "Session expired due to inactivity"
# Update last activity (use timezone-aware datetime)
doc_ref.update({'last_activity_at': now})
# Get user
user = self.get_user(session.user_email)
if not user:
logger.warning(f"User not found for session {token_prefix}...: {session.user_email}")
return False, None, "User not found"
if not user.is_active:
logger.warning(f"User account disabled for session {token_prefix}...: {session.user_email}")
return False, None, "User account is disabled"
logger.debug(f"Session valid for {token_prefix}... (user: {user.email}, credits: {user.credits})")
return True, user, "Valid session"
except Exception:
logger.exception(f"Error validating session {token_prefix}...")
return False, None, "An error occurred during validation"
def revoke_session(self, token: str) -> bool:
"""Revoke a session (logout)."""
try:
doc_ref = self.db.collection(SESSIONS_COLLECTION).document(token)
doc_ref.update({'is_active': False})
logger.info("Session revoked")
return True
except Exception:
logger.exception("Error revoking session")
return False
def revoke_all_sessions(self, user_email: str) -> int:
"""Revoke all sessions for a user."""
try:
query = self.db.collection(SESSIONS_COLLECTION).where(
filter=FieldFilter('user_email', '==', user_email.lower())
).where(
filter=FieldFilter('is_active', '==', True)
)
count = 0
for doc in query.stream():
doc.reference.update({'is_active': False})
count += 1
logger.info(f"Revoked {count} sessions for {user_email}")
return count
except Exception:
logger.exception("Error revoking sessions")
return 0
def list_sessions_for_user(
self,
user_email: str,
include_revoked: bool = False,
limit: int = 50
) -> List[Session]:
"""
List all sessions for a user.
Args:
user_email: User's email address
include_revoked: If True, include revoked/inactive sessions
limit: Maximum number of sessions to return
Returns:
List of Session objects, ordered by created_at descending
"""
try:
query = self.db.collection(SESSIONS_COLLECTION).where(
filter=FieldFilter('user_email', '==', user_email.lower())
)
if not include_revoked:
query = query.where(filter=FieldFilter('is_active', '==', True))
query = query.order_by('created_at', direction=firestore.Query.DESCENDING)
query = query.limit(limit)
sessions = []
for doc in query.stream():
try:
sessions.append(Session(**doc.to_dict()))
except Exception as e:
logger.warning(f"Failed to parse session document: {e}")
logger.debug(f"Found {len(sessions)} sessions for {user_email}")
return sessions
except Exception:
logger.exception(f"Error listing sessions for {user_email}")
return []
# =========================================================================
# Credit Operations
# =========================================================================
def add_credits(
self,
email: str,
amount: int,
reason: str,
job_id: Optional[str] = None,
stripe_session_id: Optional[str] = None,
admin_email: Optional[str] = None
) -> Tuple[bool, int, str]:
"""
Add credits to a user account.
Returns:
(success, new_balance, message)
"""
try:
# For Stripe sessions, atomically check and mark as processed
# Uses create() which fails if document exists - ensures idempotency
if stripe_session_id:
doc_ref = self.db.collection(PROCESSED_STRIPE_SESSIONS_COLLECTION).document(stripe_session_id)
try:
doc_ref.create({
'stripe_session_id': stripe_session_id,
'email': email.lower(),
'amount': amount,
'processed_at': datetime.utcnow()
})
except Exception:
# Document already exists - this session was already processed
logger.info(f"Stripe session {stripe_session_id} already processed (idempotent skip)")
return False, 0, "Session already processed"
email = email.lower()
user = self.get_or_create_user(email)
# Create transaction record
transaction = CreditTransaction(
id=str(uuid.uuid4()),
amount=amount,
reason=reason,
job_id=job_id,
stripe_session_id=stripe_session_id,
created_by=admin_email,
)
# Add to transaction history (keep last N)
transactions = user.credit_transactions[-MAX_CREDIT_TRANSACTIONS + 1:]
transactions.append(transaction)
# Update user
new_balance = user.credits + amount
self.update_user(
email,
credits=new_balance,
credit_transactions=[t.model_dump(mode='json') for t in transactions]
)
logger.info(f"Added {amount} credits to {email} ({reason}). New balance: {new_balance}")
return True, new_balance, f"Added {amount} credits"
except Exception as e:
logger.exception(f"Error adding credits to {email}")
return False, 0, f"Failed to add credits: {e}"
def deduct_credit(
self,
email: str,
job_id: str,
reason: str = "job_creation"
) -> Tuple[bool, int, str]:
"""
Deduct one credit from a user account.
Uses Firestore transaction to prevent race conditions.
Returns:
(success, remaining_credits, message)
"""
try:
email = email.lower()
doc_ref = self.db.collection(USERS_COLLECTION).document(email)
@firestore.transactional
def deduct_in_transaction(transaction):
"""Atomically check and deduct credit."""
doc = doc_ref.get(transaction=transaction)
if not doc.exists:
return False, 0, "User not found"
user_data = doc.to_dict()
current_credits = user_data.get('credits', 0)
if current_credits <= 0:
return False, 0, "Insufficient credits"
# Create transaction record
credit_txn = CreditTransaction(
id=str(uuid.uuid4()),
amount=-1,
reason=reason,
job_id=job_id,
)
# Get existing transactions and add new one
existing_transactions = user_data.get('credit_transactions', [])
# Keep last N-1 transactions to make room for new one
transactions = existing_transactions[-(MAX_CREDIT_TRANSACTIONS - 1):]
transactions.append(credit_txn.model_dump(mode='json'))
# Calculate new values
new_balance = current_credits - 1
total_jobs = user_data.get('total_jobs_created', 0) + 1
# Update atomically within transaction
transaction.update(doc_ref, {
'credits': new_balance,
'credit_transactions': transactions,
'total_jobs_created': total_jobs,
'updated_at': datetime.utcnow()
})
return True, new_balance, f"Credit deducted. {new_balance} remaining"
# Execute the transaction
fs_transaction = self.db.transaction()
success, new_balance, message = deduct_in_transaction(fs_transaction)
if success:
logger.info(f"Deducted 1 credit from {email} for job {job_id}. Remaining: {new_balance}")
return success, new_balance, message
except Exception as e:
logger.exception(f"Error deducting credit from {email}")
return False, 0, f"Failed to deduct credit: {e}"
def refund_credit(
self,
email: str,
job_id: str,
reason: str = "job_failed"
) -> Tuple[bool, int, str]:
"""
Refund one credit to a user account (e.g., after job failure).
Returns:
(success, new_balance, message)
"""
return self.add_credits(email, 1, reason, job_id=job_id)
def check_credits(self, email: str) -> int:
"""Check user's credit balance."""
user = self.get_user(email)
return user.credits if user else 0
def has_credits(self, email: str) -> bool:
"""Check if user has at least one credit."""
return self.check_credits(email) > 0
def is_stripe_session_processed(self, stripe_session_id: str) -> bool:
"""
Check if a Stripe session ID has already been processed.
Used to ensure idempotency of webhook processing - prevents
duplicate credit additions if Stripe sends the same webhook twice.
Uses a dedicated collection for O(1) lookup instead of scanning all users.
Args:
stripe_session_id: The Stripe checkout session ID
Returns:
True if this session was already processed
"""
try:
doc_ref = self.db.collection(PROCESSED_STRIPE_SESSIONS_COLLECTION).document(stripe_session_id)
doc = doc_ref.get()
if doc.exists:
logger.info(f"Stripe session {stripe_session_id} already processed")
return True
return False
except Exception:
logger.exception(f"Error checking if stripe session {stripe_session_id} was processed")
# On error, return False to allow processing (better to risk duplicate than block)
return False
def _mark_stripe_session_processed(self, stripe_session_id: str, email: str, amount: int) -> None:
"""
Mark a Stripe session as processed.
Called after successfully adding credits from a Stripe webhook.
Args:
stripe_session_id: The Stripe checkout session ID
email: User email who received the credits
amount: Number of credits added
"""
try:
doc_ref = self.db.collection(PROCESSED_STRIPE_SESSIONS_COLLECTION).document(stripe_session_id)
doc_ref.set({
'stripe_session_id': stripe_session_id,
'email': email,
'amount': amount,
'processed_at': datetime.utcnow()
})
except Exception:
# Log but don't fail - the credits were already added
logger.exception(f"Error marking stripe session {stripe_session_id} as processed")
# =========================================================================
# Admin Operations
# =========================================================================
def set_user_role(self, email: str, role: UserRole, admin_email: str) -> bool:
"""Set a user's role (admin only)."""
try:
user = self.get_user(email)
if not user:
return False
self.update_user(email, role=role.value)
logger.info(f"Admin {admin_email} set role for {email} to {role.value}")
return True
except Exception:
logger.exception("Error setting user role")
return False
def disable_user(self, email: str, admin_email: str) -> bool:
"""Disable a user account (admin only)."""
try:
self.update_user(email, is_active=False)
self.revoke_all_sessions(email)
logger.info(f"Admin {admin_email} disabled user {email}")
return True
except Exception:
logger.exception("Error disabling user")
return False
def enable_user(self, email: str, admin_email: str) -> bool:
"""Enable a user account (admin only)."""
try:
self.update_user(email, is_active=True)
logger.info(f"Admin {admin_email} enabled user {email}")
return True
except Exception:
logger.exception("Error enabling user")
return False
def increment_jobs_completed(self, email: str) -> bool:
"""Increment the completed jobs counter for a user using atomic increment."""
try:
# Check user exists first
if not self.get_user(email):
return False
# Use atomic increment to prevent race conditions
doc_ref = self.db.collection(USERS_COLLECTION).document(email.lower())
doc_ref.update({
'total_jobs_completed': Increment(1),
'updated_at': datetime.utcnow()
})
return True
except Exception:
logger.exception(f"Error incrementing jobs completed for {email}")
return False
# Global instance
_user_service = None
def get_user_service() -> UserService:
"""Get the global user service instance."""
global _user_service
if _user_service is None:
_user_service = UserService()
return _user_service
+1 -22
View File
@@ -20,7 +20,6 @@ import os
import json
from typing import Optional
import httpx
from google.protobuf import duration_pb2
from backend.config import get_settings
from backend.services.tracing import inject_trace_context
@@ -39,18 +38,6 @@ WORKER_QUEUES = {
"video": "video-worker-queue",
}
# Dispatch deadlines for each worker type (in seconds)
# Cloud Tasks max is 1800s (30 min). These set how long Cloud Tasks waits
# for the HTTP handler to respond before considering it failed.
# Must be >= actual worker timeout + buffer for startup/upload.
WORKER_DISPATCH_DEADLINES = {
"audio": 1800, # 30 min - Modal separation can take 15-20 min
"lyrics": 1500, # 25 min - TRANSCRIPTION_TIMEOUT_SECONDS is 1200s (20 min)
"screens": 600, # 10 min - Screen generation is fast
"render-video": 1800, # 30 min - Video encoding can be slow
"video": 1800, # 30 min - Video encoding can be slow
}
class WorkerService:
"""
@@ -247,9 +234,6 @@ class WorkerService:
# This allows worker spans to link back to the original request trace
headers = inject_trace_context(headers)
# Get dispatch deadline for this worker type (how long Cloud Tasks waits for response)
dispatch_deadline_seconds = WORKER_DISPATCH_DEADLINES.get(worker_type, 600)
# Build task payload
task = {
"http_request": {
@@ -263,10 +247,6 @@ class WorkerService:
"service_account_email": f"karaoke-backend@{project}.iam.gserviceaccount.com",
},
},
# Set dispatch_deadline - how long Cloud Tasks waits for the handler to respond
# Default is 10 min, but audio separation can take 30+ min
# Max is 1800s (30 min) for Cloud Tasks
"dispatch_deadline": duration_pb2.Duration(seconds=dispatch_deadline_seconds),
}
# Create task
@@ -274,8 +254,7 @@ class WorkerService:
# This prevents duplicate task errors on retries
response = self.tasks_client.create_task(parent=parent, task=task)
logger.info(
f"[job:{job_id}] Created Cloud Task for {worker_type} worker: {response.name} "
f"(dispatch_deadline={dispatch_deadline_seconds}s)"
f"[job:{job_id}] Created Cloud Task for {worker_type} worker: {response.name}"
)
return True
-445
View File
@@ -1,445 +0,0 @@
"""
YouTube Upload Service.
Provides video upload functionality for YouTube, extracted from KaraokeFinalise
for use by both the cloud backend (video_worker) and local CLI.
This service handles:
- Video uploads with metadata (title, description, tags)
- Thumbnail uploads
- Duplicate video detection and replacement
- Authentication via pre-stored credentials or client secrets file
"""
import logging
import os
from typing import Optional, Dict, Any, Tuple
from thefuzz import fuzz
logger = logging.getLogger(__name__)
class YouTubeUploadService:
"""
Service for uploading videos to YouTube.
Supports two authentication modes:
1. Pre-stored credentials (for server-side/non-interactive use)
2. Client secrets file (for interactive CLI use with browser OAuth)
"""
YOUTUBE_URL_PREFIX = "https://www.youtube.com/watch?v="
SCOPES = ["https://www.googleapis.com/auth/youtube"]
def __init__(
self,
credentials: Optional[Dict[str, Any]] = None,
client_secrets_file: Optional[str] = None,
non_interactive: bool = False,
server_side_mode: bool = False,
dry_run: bool = False,
logger: Optional[logging.Logger] = None,
):
"""
Initialize the YouTube upload service.
Args:
credentials: Pre-stored OAuth credentials dict with keys:
- token: Access token
- refresh_token: Refresh token
- token_uri: Token endpoint URL
- client_id: OAuth client ID
- client_secret: OAuth client secret
- scopes: List of OAuth scopes
client_secrets_file: Path to OAuth client secrets JSON file
(for interactive authentication)
non_interactive: If True, skip interactive prompts
server_side_mode: If True, use exact matching for duplicate detection
dry_run: If True, log actions without performing them
logger: Optional logger instance
"""
self.credentials = credentials
self.client_secrets_file = client_secrets_file
self.non_interactive = non_interactive
self.server_side_mode = server_side_mode
self.dry_run = dry_run
self.logger = logger or logging.getLogger(__name__)
self._youtube_service = None
self._channel_id = None
def _authenticate(self):
"""
Authenticate with YouTube API and return service object.
Returns:
YouTube API service object
Raises:
Exception: If authentication fails or is required in non-interactive mode
"""
from google.auth.transport.requests import Request
from google.oauth2.credentials import Credentials
from googleapiclient.discovery import build
from google_auth_oauthlib.flow import InstalledAppFlow
import pickle
# Check if we have pre-stored credentials (for non-interactive mode)
if self.credentials and self.non_interactive:
try:
creds = Credentials(
token=self.credentials.get('token'),
refresh_token=self.credentials.get('refresh_token'),
token_uri=self.credentials.get('token_uri'),
client_id=self.credentials.get('client_id'),
client_secret=self.credentials.get('client_secret'),
scopes=self.credentials.get('scopes', self.SCOPES)
)
# Refresh token if needed
if creds.expired and creds.refresh_token:
creds.refresh(Request())
youtube = build('youtube', 'v3', credentials=creds)
self.logger.info("Successfully authenticated with YouTube using pre-stored credentials")
return youtube
except Exception as e:
self.logger.error(f"Failed to authenticate with pre-stored credentials: {str(e)}")
# Fall through to original authentication if pre-stored credentials fail
# For non-interactive mode without pre-stored credentials, raise error
if self.non_interactive:
raise Exception(
"YouTube authentication required but running in non-interactive mode. "
"Please pre-authenticate or disable YouTube upload."
)
# Interactive authentication using client secrets file
if not self.client_secrets_file:
raise Exception("No YouTube credentials or client secrets file provided")
# Token file stores the user's access and refresh tokens
youtube_token_file = "/tmp/karaoke-finalise-youtube-token.pickle"
creds = None
# Check if we have saved credentials
if os.path.exists(youtube_token_file):
with open(youtube_token_file, "rb") as token:
creds = pickle.load(token)
# If there are no valid credentials, let the user log in
if not creds or not creds.valid:
if creds and creds.expired and creds.refresh_token:
creds.refresh(Request())
else:
flow = InstalledAppFlow.from_client_secrets_file(
self.client_secrets_file, scopes=self.SCOPES
)
creds = flow.run_local_server(port=0)
# Save the credentials for the next run
with open(youtube_token_file, "wb") as token:
pickle.dump(creds, token)
return build("youtube", "v3", credentials=creds)
@property
def youtube_service(self):
"""Lazy-load YouTube service on first access."""
if self._youtube_service is None:
self._youtube_service = self._authenticate()
return self._youtube_service
def get_channel_id(self) -> Optional[str]:
"""
Get the authenticated user's YouTube channel ID.
Returns:
Channel ID string, or None if not found
"""
if self._channel_id:
return self._channel_id
request = self.youtube_service.channels().list(part="snippet", mine=True)
response = request.execute()
if "items" in response and len(response["items"]) > 0:
self._channel_id = response["items"][0]["id"]
return self._channel_id
return None
def check_duplicate(
self,
title: str,
exact_match: Optional[bool] = None
) -> Tuple[bool, Optional[str], Optional[str]]:
"""
Check if a video with the given title already exists on the channel.
Args:
title: Video title to search for
exact_match: If True, require exact title match. If None, uses
server_side_mode setting (exact in server mode, fuzzy in CLI)
Returns:
Tuple of (exists: bool, video_id: Optional[str], video_url: Optional[str])
"""
channel_id = self.get_channel_id()
if not channel_id:
self.logger.warning("Could not get channel ID, skipping duplicate check")
return False, None, None
use_exact_match = exact_match if exact_match is not None else self.server_side_mode
self.logger.info(f"Searching YouTube channel {channel_id} for title: {title}")
request = self.youtube_service.search().list(
part="snippet",
channelId=channel_id,
q=title,
type="video",
maxResults=10
)
response = request.execute()
if "items" not in response or len(response["items"]) == 0:
self.logger.info(f"No matching video found with title: {title}")
return False, None, None
for item in response["items"]:
# Verify the video actually belongs to our channel
result_channel_id = item["snippet"]["channelId"]
if result_channel_id != channel_id:
self.logger.debug(
f"Skipping video from different channel: {item['snippet']['title']} "
f"(channel: {result_channel_id})"
)
continue
found_title = item["snippet"]["title"]
# Determine if this is a match
if use_exact_match:
is_match = title.lower() == found_title.lower()
similarity_score = 100 if is_match else 0
else:
similarity_score = fuzz.ratio(title.lower(), found_title.lower())
is_match = similarity_score >= 70
if is_match:
video_id = item["id"]["videoId"]
video_url = f"{self.YOUTUBE_URL_PREFIX}{video_id}"
self.logger.info(
f"Potential match found on YouTube channel with ID: {video_id} "
f"and title: {found_title} (similarity: {similarity_score}%)"
)
# In non-interactive mode, return the match directly
if self.non_interactive:
self.logger.info("Non-interactive mode, found a match.")
return True, video_id, video_url
# Interactive confirmation
confirmation = input(
f"Is '{found_title}' the video you are finalising? (y/n): "
).strip().lower()
if confirmation == "y":
return True, video_id, video_url
self.logger.info(f"No matching video found with title: {title}")
return False, None, None
def delete_video(self, video_id: str) -> bool:
"""
Delete a YouTube video by its ID.
Args:
video_id: The YouTube video ID to delete
Returns:
True if successful, False otherwise
"""
self.logger.info(f"Deleting YouTube video with ID: {video_id}")
if self.dry_run:
self.logger.info(f"DRY RUN: Would delete YouTube video with ID: {video_id}")
return True
try:
self.youtube_service.videos().delete(id=video_id).execute()
self.logger.info(f"Successfully deleted YouTube video with ID: {video_id}")
return True
except Exception as e:
self.logger.error(f"Failed to delete YouTube video with ID {video_id}: {e}")
return False
@staticmethod
def truncate_title(title: str, max_length: int = 95) -> str:
"""
Truncate title to the nearest whole word within max_length.
Args:
title: Title to truncate
max_length: Maximum length (default 95 for YouTube)
Returns:
Truncated title with "..." if needed
"""
if len(title) <= max_length:
return title
truncated_title = title[:max_length].rsplit(" ", 1)[0]
if len(truncated_title) < max_length:
truncated_title += " ..."
return truncated_title
def upload_video(
self,
video_path: str,
title: str,
description: str,
thumbnail_path: Optional[str] = None,
tags: Optional[list] = None,
category_id: str = "10", # Music category
privacy_status: str = "public",
replace_existing: bool = False,
) -> Tuple[Optional[str], Optional[str]]:
"""
Upload a video to YouTube with metadata and optional thumbnail.
Args:
video_path: Path to the video file to upload
title: Video title (will be truncated to 95 chars if needed)
description: Video description
thumbnail_path: Optional path to thumbnail image
tags: Optional list of tags/keywords
category_id: YouTube category ID (default "10" for Music)
privacy_status: "public", "private", or "unlisted"
replace_existing: If True, delete existing video with same title
Returns:
Tuple of (video_id, video_url) or (None, None) if upload failed/skipped
"""
from googleapiclient.http import MediaFileUpload
# Truncate title if needed
youtube_title = self.truncate_title(title)
self.logger.info(f"Uploading video to YouTube: {youtube_title}")
if self.dry_run:
self.logger.info(
f"DRY RUN: Would upload {video_path} to YouTube with title: {youtube_title}"
)
return "dry_run_video_id", f"{self.YOUTUBE_URL_PREFIX}dry_run_video_id"
# Check for existing video
should_replace = True if self.server_side_mode else replace_existing
exists, existing_id, existing_url = self.check_duplicate(youtube_title)
if exists:
if should_replace:
self.logger.info(f"Video already exists on YouTube, deleting before re-upload: {existing_url}")
if self.delete_video(existing_id):
self.logger.info("Successfully deleted existing video, proceeding with upload")
else:
self.logger.error("Failed to delete existing video, aborting upload")
return None, None
else:
self.logger.warning(f"Video already exists on YouTube, skipping upload: {existing_url}")
return existing_id, existing_url
# Prepare video metadata
body = {
"snippet": {
"title": youtube_title,
"description": description,
"tags": tags or [],
"categoryId": category_id,
},
"status": {"privacyStatus": privacy_status},
}
# Determine MIME type based on file extension
ext = os.path.splitext(video_path)[1].lower()
mime_type = {
".mkv": "video/x-matroska",
".mp4": "video/mp4",
".mov": "video/quicktime",
".avi": "video/x-msvideo",
}.get(ext, "video/*")
# Upload video
self.logger.info(f"Authenticating with YouTube...")
media_file = MediaFileUpload(video_path, mimetype=mime_type, resumable=True)
self.logger.info(f"Uploading video to YouTube...")
request = self.youtube_service.videos().insert(
part="snippet,status",
body=body,
media_body=media_file
)
response = request.execute()
video_id = response.get("id")
video_url = f"{self.YOUTUBE_URL_PREFIX}{video_id}"
self.logger.info(f"Uploaded video to YouTube: {video_url}")
# Upload thumbnail if provided
if thumbnail_path and os.path.isfile(thumbnail_path):
try:
self.logger.info(f"Uploading thumbnail from: {thumbnail_path}")
media_thumbnail = MediaFileUpload(thumbnail_path, mimetype="image/jpeg")
self.youtube_service.thumbnails().set(
videoId=video_id,
media_body=media_thumbnail
).execute()
self.logger.info(f"Uploaded thumbnail for video ID {video_id}")
except Exception as e:
self.logger.error(f"Failed to upload thumbnail: {e}")
self.logger.warning(
"Video uploaded but thumbnail not set. "
"You may need to set it manually on YouTube."
)
elif thumbnail_path:
self.logger.warning(f"Thumbnail file not found, skipping: {thumbnail_path}")
return video_id, video_url
# Singleton instance and factory function (following existing service pattern)
_youtube_upload_service: Optional[YouTubeUploadService] = None
def get_youtube_upload_service(
credentials: Optional[Dict[str, Any]] = None,
client_secrets_file: Optional[str] = None,
**kwargs
) -> YouTubeUploadService:
"""
Get a YouTube upload service instance.
For server-side use, pass credentials from YouTubeService.
For CLI use, pass client_secrets_file.
Args:
credentials: Pre-stored OAuth credentials dict
client_secrets_file: Path to OAuth client secrets JSON file
**kwargs: Additional arguments passed to YouTubeUploadService
Returns:
YouTubeUploadService instance
"""
global _youtube_upload_service
# Create new instance if credentials/settings changed
if _youtube_upload_service is None or credentials or client_secrets_file:
_youtube_upload_service = YouTubeUploadService(
credentials=credentials,
client_secrets_file=client_secrets_file,
**kwargs
)
return _youtube_upload_service
+7 -13
View File
@@ -6,30 +6,24 @@ Provides common mocks and test utilities across all test modules.
NOTE: Module-level mocks are NOT applied here to allow emulator tests to work.
Individual tests must mock dependencies as needed.
"""
# IMPORTANT: Set environment variables FIRST, before ANY imports that might
# trigger backend module loading and Settings singleton creation.
import os
# Set up test environment variables BEFORE importing any backend modules
# This must happen before Settings is instantiated, which occurs on first import
if 'FIRESTORE_EMULATOR_HOST' not in os.environ:
os.environ.setdefault('ADMIN_TOKENS', 'test-admin-token')
os.environ.setdefault('GOOGLE_CLOUD_PROJECT', 'test-project')
os.environ.setdefault('GCS_BUCKET_NAME', 'test-bucket')
os.environ.setdefault('FIRESTORE_COLLECTION', 'jobs')
os.environ.setdefault('ENVIRONMENT', 'test')
import pytest
from unittest.mock import Mock, MagicMock, AsyncMock, patch
from datetime import datetime, UTC
from fastapi.testclient import TestClient
# Mock google.auth.default AND firestore for unit tests if not using emulator
# This prevents DefaultCredentialsError and FirestoreClient initialization during imports
if 'FIRESTORE_EMULATOR_HOST' not in os.environ:
from unittest.mock import MagicMock
# Set up test environment variables BEFORE importing any backend modules
os.environ.setdefault('ADMIN_TOKENS', 'test-admin-token')
os.environ.setdefault('GOOGLE_CLOUD_PROJECT', 'test-project')
os.environ.setdefault('GCS_BUCKET_NAME', 'test-bucket')
os.environ.setdefault('FIRESTORE_COLLECTION', 'jobs')
os.environ.setdefault('ENVIRONMENT', 'test')
# Mock google.auth.default - prevents credential errors
try:
import google.auth
@@ -330,7 +330,7 @@ class TestReviewEndpoints:
class TestRenderVideoWorker:
"""Test render video worker endpoint."""
def test_render_video_worker_endpoint_exists(self, client, auth_headers):
"""Test that render-video worker endpoint exists."""
# Create a job
@@ -340,9 +340,9 @@ class TestRenderVideoWorker:
json={"url": "https://youtube.com/watch?v=render-test"}
)
job_id = create_resp.json()["job_id"]
time.sleep(0.2)
# Test render-video worker endpoint exists
response = client.post(
"/api/internal/workers/render-video",
+4 -254
View File
@@ -460,18 +460,16 @@ class TestAudioSearchServiceDownload:
url="https://youtube.com/watch?v=abc123",
index=0,
)
service = AudioSearchService(red_api_key=None, red_api_url=None, ops_api_key=None, ops_api_url=None)
service._fetcher = Mock()
service._fetcher.search.return_value = [mock_result]
# Ensure no remote client so we test the local cache path
service._remote_client = None
service.search("ABBA", "Waterloo")
with pytest.raises(DownloadError) as exc_info:
service.download(99, "/tmp")
assert "No cached result for index 99" in str(exc_info.value)
@@ -800,254 +798,6 @@ class TestRemoteDownloadPath:
assert result.filepath == "/tmp/test.flac"
class TestAudioSearchThemeSupport:
"""Test theme support in audio search requests.
These tests verify that theme_id and color_overrides are properly:
1. Accepted in AudioSearchRequest model
2. Passed through to JobCreate
3. Result in correct CDG/TXT defaults when theme is set
4. Theme style is PREPARED (copied to job folder) when theme_id is set
"""
def test_audio_search_request_accepts_theme_id(self):
"""Test AudioSearchRequest model has theme_id field."""
from backend.api.routes.audio_search import AudioSearchRequest
request = AudioSearchRequest(
artist="Test Artist",
title="Test Song",
theme_id="nomad"
)
assert request.theme_id == "nomad"
def test_audio_search_request_accepts_color_overrides(self):
"""Test AudioSearchRequest model has color_overrides field."""
from backend.api.routes.audio_search import AudioSearchRequest
request = AudioSearchRequest(
artist="Test Artist",
title="Test Song",
theme_id="nomad",
color_overrides={
"artist_color": "#ff0000",
"title_color": "#00ff00",
}
)
assert request.color_overrides["artist_color"] == "#ff0000"
assert request.color_overrides["title_color"] == "#00ff00"
def test_audio_search_request_theme_defaults_cdg_txt(self):
"""Test that when theme_id is set, CDG/TXT defaults to enabled.
This is the key behavior: selecting a theme should automatically
enable CDG and TXT output formats.
"""
from backend.api.routes.audio_search import AudioSearchRequest, _resolve_cdg_txt_defaults
# When theme_id is set, enable_cdg/enable_txt should default to True
request = AudioSearchRequest(
artist="Test Artist",
title="Test Song",
theme_id="nomad"
# enable_cdg and enable_txt are None (not specified)
)
resolved_cdg, resolved_txt = _resolve_cdg_txt_defaults(
request.theme_id, request.enable_cdg, request.enable_txt
)
assert resolved_cdg is True, "CDG should be enabled by default when theme is set"
assert resolved_txt is True, "TXT should be enabled by default when theme is set"
def test_audio_search_request_no_theme_no_cdg_txt(self):
"""Test that without theme_id, CDG/TXT defaults to disabled."""
from backend.api.routes.audio_search import AudioSearchRequest, _resolve_cdg_txt_defaults
request = AudioSearchRequest(
artist="Test Artist",
title="Test Song"
# No theme_id, no enable_cdg, no enable_txt
)
resolved_cdg, resolved_txt = _resolve_cdg_txt_defaults(
request.theme_id, request.enable_cdg, request.enable_txt
)
assert resolved_cdg is False, "CDG should be disabled by default without theme"
assert resolved_txt is False, "TXT should be disabled by default without theme"
def test_explicit_cdg_txt_overrides_theme_default(self):
"""Test that explicit enable_cdg/enable_txt values override theme defaults."""
from backend.api.routes.audio_search import AudioSearchRequest, _resolve_cdg_txt_defaults
# Theme set (would default to True), but explicitly disabled
request = AudioSearchRequest(
artist="Test Artist",
title="Test Song",
theme_id="nomad",
enable_cdg=False,
enable_txt=False,
)
resolved_cdg, resolved_txt = _resolve_cdg_txt_defaults(
request.theme_id, request.enable_cdg, request.enable_txt
)
assert resolved_cdg is False, "Explicit False should override theme default"
assert resolved_txt is False, "Explicit False should override theme default"
def test_explicit_cdg_txt_enables_without_theme(self):
"""Test that explicit True enables CDG/TXT even without theme."""
from backend.api.routes.audio_search import AudioSearchRequest, _resolve_cdg_txt_defaults
# No theme (would default to False), but explicitly enabled
request = AudioSearchRequest(
artist="Test Artist",
title="Test Song",
enable_cdg=True,
enable_txt=True,
)
resolved_cdg, resolved_txt = _resolve_cdg_txt_defaults(
request.theme_id, request.enable_cdg, request.enable_txt
)
assert resolved_cdg is True, "Explicit True should enable CDG without theme"
assert resolved_txt is True, "Explicit True should enable TXT without theme"
def test_job_create_receives_theme_from_audio_search(self):
"""Test that JobCreate model can receive theme_id and color_overrides."""
job_create = JobCreate(
artist="Test Artist",
title="Test Song",
theme_id="nomad",
color_overrides={
"artist_color": "#ff0000",
"sung_lyrics_color": "#00ff00"
},
enable_cdg=True,
enable_txt=True,
)
assert job_create.theme_id == "nomad"
assert job_create.color_overrides["artist_color"] == "#ff0000"
assert job_create.color_overrides["sung_lyrics_color"] == "#00ff00"
assert job_create.enable_cdg is True
assert job_create.enable_txt is True
def test_job_model_stores_theme_configuration(self):
"""Test Job model stores theme configuration correctly."""
job = Job(
job_id="test123",
status=JobStatus.PENDING,
created_at=datetime.utcnow(),
updated_at=datetime.utcnow(),
artist="Test Artist",
title="Test Song",
theme_id="nomad",
color_overrides={
"artist_color": "#ff0000"
},
enable_cdg=True,
enable_txt=True,
)
assert job.theme_id == "nomad"
assert job.color_overrides["artist_color"] == "#ff0000"
assert job.enable_cdg is True
assert job.enable_txt is True
class TestAudioSearchThemePreparation:
"""Test that audio search endpoint properly prepares theme styles.
CRITICAL: This test class was added to catch the bug where audio_search.py
accepted theme_id but never called prepare_job_style(), resulting in jobs
with theme_id set but no style_params_gcs_path or style_assets.
The symptom: Preview videos show black background instead of themed background.
Job ID ffb0b8fa in production demonstrated this issue.
"""
def test_audio_search_with_theme_calls_prepare_job_style(self):
"""Test that creating a job via audio search with theme_id prepares the style.
CRITICAL: This test verifies that when a job is created via the audio-search
endpoint with a theme_id (and no custom style files), the code calls
prepare_job_style() to set:
1. style_params_gcs_path (pointing to the copied style_params.json)
2. style_assets (populated with asset mappings)
Without this, LyricsTranscriber won't have access to the theme's styles
and preview videos will have black backgrounds instead of themed ones.
"""
# Import the endpoint module to access internal functions
from backend.api.routes import audio_search as audio_search_module
# Check if there's an import of prepare_job_style from theme_service
source_code_path = audio_search_module.__file__
with open(source_code_path, 'r') as f:
source_code = f.read()
# Check for either:
# 1. Import of _prepare_theme_for_job from file_upload
# 2. Import of prepare_job_style from theme_service
# 3. Inline call to theme_service.prepare_job_style
has_theme_prep_import = (
'_prepare_theme_for_job' in source_code or
'prepare_job_style' in source_code
)
assert has_theme_prep_import, (
"audio_search.py does not import or call prepare_job_style() or _prepare_theme_for_job(). "
"When theme_id is provided without custom style files, the endpoint MUST call "
"prepare_job_style() to copy the theme's style_params.json to the job folder. "
"Without this, LyricsTranscriber won't have style configuration and preview "
"videos will have black backgrounds instead of themed ones."
)
def test_audio_search_code_handles_theme_preparation(self):
"""Verify audio_search.py has theme preparation logic similar to file_upload.py.
This test compares audio_search.py with file_upload.py to ensure they have
similar theme preparation patterns. file_upload.py correctly prepares themes,
audio_search.py should do the same.
"""
from backend.api.routes import audio_search as audio_search_module
from backend.api.routes import file_upload as file_upload_module
# Read source code of both modules
with open(audio_search_module.__file__, 'r') as f:
audio_search_code = f.read()
with open(file_upload_module.__file__, 'r') as f:
file_upload_code = f.read()
# file_upload.py has this pattern for theme preparation:
# if body.theme_id and not has_style_params_upload:
# style_params_path, style_assets, youtube_desc = _prepare_theme_for_job(...)
assert '_prepare_theme_for_job' in file_upload_code, \
"file_upload.py should have _prepare_theme_for_job function"
# audio_search.py should have similar pattern
# Look for either the function or a similar conditional check
# STRICT CHECK: Look for actual theme preparation logic being CALLED, not just mentioned
has_theme_preparation_call = (
# Check for import or call of theme preparation function
'_prepare_theme_for_job(' in audio_search_code or
'prepare_job_style(' in audio_search_code
)
assert has_theme_preparation_call, (
"audio_search.py does not CALL theme preparation logic. "
"It accepts theme_id but never prepares the theme style like file_upload.py does. "
"Add a call to _prepare_theme_for_job() when theme_id is set and no style files are uploaded."
)
class TestFlacfetchIntegration:
"""
Integration tests that verify flacfetch imports work correctly.
+1 -89
View File
@@ -114,97 +114,9 @@ class TestWorkerServiceBasics:
assert 'http' in url
class TestSessionTokenValidation:
"""Tests for session token validation in AuthService.
PR #120: Fixed authentication to recognize session tokens from magic link auth.
Previously, validate_token() only checked admin tokens and auth_tokens collection.
Session tokens (created via magic link) are stored in the sessions collection,
so they were incorrectly rejected as "Invalid token".
"""
def test_validate_token_checks_session_on_fallback(self):
"""Test that validate_token falls back to checking session tokens."""
mock_firestore = MagicMock()
mock_firestore.get_token.return_value = None # Token not in auth_tokens
mock_user = MagicMock()
mock_user.email = "test@example.com"
mock_user.credits = 5
mock_user_service = MagicMock()
mock_user_service.validate_session.return_value = (True, mock_user, "Valid session")
with patch('backend.services.auth_service.FirestoreService', return_value=mock_firestore), \
patch('backend.services.user_service.get_user_service', return_value=mock_user_service), \
patch.dict('os.environ', {'ADMIN_TOKENS': 'admin-token-123'}):
# Clear the cached instance to get fresh state
import backend.services.auth_service
backend.services.auth_service._auth_service = None
from backend.services.auth_service import AuthService, UserType
service = AuthService()
is_valid, user_type, remaining, msg = service.validate_token("session-token-xyz")
assert is_valid is True
assert user_type == UserType.STRIPE
assert remaining == 5 # User's credits
mock_user_service.validate_session.assert_called_once_with("session-token-xyz")
def test_validate_token_returns_invalid_when_session_invalid(self):
"""Test that validate_token returns invalid when session validation fails."""
mock_firestore = MagicMock()
mock_firestore.get_token.return_value = None # Token not in auth_tokens
mock_user_service = MagicMock()
mock_user_service.validate_session.return_value = (False, None, "Invalid session")
with patch('backend.services.auth_service.FirestoreService', return_value=mock_firestore), \
patch('backend.services.user_service.get_user_service', return_value=mock_user_service), \
patch.dict('os.environ', {'ADMIN_TOKENS': 'admin-token-123'}):
import backend.services.auth_service
backend.services.auth_service._auth_service = None
from backend.services.auth_service import AuthService, UserType
service = AuthService()
is_valid, user_type, remaining, msg = service.validate_token("invalid-session")
assert is_valid is False
assert remaining == 0
assert "Invalid token" in msg
def test_validate_token_returns_zero_credits_when_user_has_none(self):
"""Test that validate_token handles users with 0 credits correctly."""
mock_firestore = MagicMock()
mock_firestore.get_token.return_value = None
mock_user = MagicMock()
mock_user.email = "test@example.com"
mock_user.credits = 0
mock_user_service = MagicMock()
mock_user_service.validate_session.return_value = (True, mock_user, "Valid session")
with patch('backend.services.auth_service.FirestoreService', return_value=mock_firestore), \
patch('backend.services.user_service.get_user_service', return_value=mock_user_service), \
patch.dict('os.environ', {'ADMIN_TOKENS': 'admin-token-123'}):
import backend.services.auth_service
backend.services.auth_service._auth_service = None
from backend.services.auth_service import AuthService, UserType
service = AuthService()
is_valid, user_type, remaining, msg = service.validate_token("session-token")
# User is authenticated but has no credits
assert is_valid is True
assert user_type == UserType.STRIPE
assert remaining == 0
assert "no credits" in msg.lower()
class TestJobManagerBasics:
"""Basic tests for JobManager."""
def test_job_manager_can_import(self):
"""Test JobManager can be imported."""
from backend.services.job_manager import JobManager
-244
View File
@@ -1,244 +0,0 @@
"""
Tests for DiscordNotificationService.
Tests cover:
- Service initialization
- Webhook URL validation
- Message posting
- Video notification posting
- Dry run mode
"""
import pytest
from unittest.mock import MagicMock, patch
from backend.services.discord_service import (
DiscordNotificationService,
get_discord_notification_service,
)
class TestDiscordNotificationServiceInit:
"""Test service initialization."""
def test_init_with_webhook_url(self):
"""Test initialization with valid webhook URL."""
url = "https://discord.com/api/webhooks/123456789/abcdef123456"
service = DiscordNotificationService(webhook_url=url)
assert service.webhook_url == url
assert service.is_enabled() is True
def test_init_without_webhook_url(self):
"""Test initialization without webhook URL."""
service = DiscordNotificationService()
assert service.webhook_url is None
assert service.is_enabled() is False
def test_init_with_dry_run(self):
"""Test initialization with dry run mode."""
service = DiscordNotificationService(dry_run=True)
assert service.dry_run is True
def test_init_with_invalid_webhook_url_raises(self):
"""Test that invalid webhook URL raises ValueError."""
with pytest.raises(ValueError) as exc_info:
DiscordNotificationService(webhook_url="https://example.com/webhook")
assert "Invalid Discord webhook URL" in str(exc_info.value)
def test_init_with_non_discord_url_raises(self):
"""Test that non-Discord URL raises ValueError."""
with pytest.raises(ValueError):
DiscordNotificationService(
webhook_url="https://slack.com/api/webhooks/123"
)
class TestDiscordNotificationServiceValidation:
"""Test webhook URL validation."""
def test_validate_valid_webhook_url(self):
"""Test that valid webhook URL passes validation."""
service = DiscordNotificationService()
# Should not raise
service._validate_webhook_url(
"https://discord.com/api/webhooks/123456789/abcdef"
)
def test_validate_invalid_webhook_url(self):
"""Test that invalid webhook URL raises ValueError."""
service = DiscordNotificationService()
with pytest.raises(ValueError) as exc_info:
service._validate_webhook_url("https://example.com/webhook")
assert "Invalid Discord webhook URL" in str(exc_info.value)
def test_validate_strips_whitespace(self):
"""Test that whitespace is stripped from URL."""
service = DiscordNotificationService()
# Should not raise - whitespace is stripped
service._validate_webhook_url(
" https://discord.com/api/webhooks/123456789/abcdef "
)
class TestDiscordNotificationServicePostMessage:
"""Test message posting."""
@patch("backend.services.discord_service.requests.post")
def test_post_message_success(self, mock_post):
"""Test successful message posting."""
mock_response = MagicMock()
mock_response.raise_for_status = MagicMock()
mock_post.return_value = mock_response
url = "https://discord.com/api/webhooks/123456789/abcdef"
service = DiscordNotificationService(webhook_url=url)
result = service.post_message("Test message")
assert result is True
mock_post.assert_called_once_with(
url,
json={"content": "Test message"},
timeout=30
)
@patch("backend.services.discord_service.requests.post")
def test_post_message_with_custom_webhook(self, mock_post):
"""Test message posting with custom webhook URL."""
mock_response = MagicMock()
mock_response.raise_for_status = MagicMock()
mock_post.return_value = mock_response
service = DiscordNotificationService()
custom_url = "https://discord.com/api/webhooks/987654321/fedcba"
result = service.post_message("Test message", webhook_url=custom_url)
assert result is True
mock_post.assert_called_once_with(
custom_url,
json={"content": "Test message"},
timeout=30
)
def test_post_message_no_webhook_raises(self):
"""Test that posting without webhook URL raises ValueError."""
service = DiscordNotificationService()
with pytest.raises(ValueError) as exc_info:
service.post_message("Test message")
assert "No Discord webhook URL provided" in str(exc_info.value)
def test_post_message_dry_run(self):
"""Test message posting in dry run mode."""
url = "https://discord.com/api/webhooks/123456789/abcdef"
service = DiscordNotificationService(webhook_url=url, dry_run=True)
result = service.post_message("Test message")
assert result is True
# In dry run mode, no actual request should be made
@patch("backend.services.discord_service.requests.post")
def test_post_message_http_error(self, mock_post):
"""Test handling of HTTP errors."""
import requests as req
mock_response = MagicMock()
mock_response.raise_for_status.side_effect = req.HTTPError("404 Not Found")
mock_post.return_value = mock_response
url = "https://discord.com/api/webhooks/123456789/abcdef"
service = DiscordNotificationService(webhook_url=url)
with pytest.raises(req.HTTPError):
service.post_message("Test message")
class TestDiscordNotificationServiceVideoNotification:
"""Test video notification posting."""
@patch("backend.services.discord_service.requests.post")
def test_post_video_notification_success(self, mock_post):
"""Test successful video notification."""
mock_response = MagicMock()
mock_response.raise_for_status = MagicMock()
mock_post.return_value = mock_response
url = "https://discord.com/api/webhooks/123456789/abcdef"
service = DiscordNotificationService(webhook_url=url)
result = service.post_video_notification(
"https://www.youtube.com/watch?v=abc123"
)
assert result is True
mock_post.assert_called_once()
call_args = mock_post.call_args
assert "New upload:" in call_args[1]["json"]["content"]
assert "abc123" in call_args[1]["json"]["content"]
def test_post_video_notification_no_youtube_url(self):
"""Test video notification with empty YouTube URL."""
url = "https://discord.com/api/webhooks/123456789/abcdef"
service = DiscordNotificationService(webhook_url=url)
result = service.post_video_notification("")
assert result is False
def test_post_video_notification_none_youtube_url(self):
"""Test video notification with None YouTube URL."""
url = "https://discord.com/api/webhooks/123456789/abcdef"
service = DiscordNotificationService(webhook_url=url)
result = service.post_video_notification(None)
assert result is False
def test_post_video_notification_dry_run(self):
"""Test video notification in dry run mode."""
url = "https://discord.com/api/webhooks/123456789/abcdef"
service = DiscordNotificationService(webhook_url=url, dry_run=True)
result = service.post_video_notification(
"https://www.youtube.com/watch?v=abc123"
)
assert result is True
class TestGetDiscordNotificationService:
"""Test factory function."""
def test_get_service_creates_instance(self):
"""Test that factory function creates a new instance."""
import backend.services.discord_service as module
module._discord_notification_service = None
url = "https://discord.com/api/webhooks/123456789/abcdef"
service = get_discord_notification_service(webhook_url=url)
assert service is not None
assert isinstance(service, DiscordNotificationService)
assert service.webhook_url == url
def test_get_service_without_webhook(self):
"""Test factory function without webhook URL."""
import backend.services.discord_service as module
module._discord_notification_service = None
service = get_discord_notification_service()
assert service is not None
assert service.webhook_url is None
assert service.is_enabled() is False
def test_get_service_with_dry_run(self):
"""Test factory function with dry run mode."""
import backend.services.discord_service as module
module._discord_notification_service = None
url = "https://discord.com/api/webhooks/123456789/abcdef"
service = get_discord_notification_service(webhook_url=url, dry_run=True)
assert service.dry_run is True
+9 -73
View File
@@ -321,95 +321,31 @@ class TestUploadFile:
class TestUploadFolder:
"""Test upload_folder method."""
@patch("backend.services.dropbox_service.secretmanager.SecretManagerServiceClient")
def test_upload_folder(self, mock_sm_client_class, tmp_path):
"""Test uploading a folder with multiple files."""
from backend.services.dropbox_service import DropboxService
mock_sm_client = Mock()
mock_response = Mock()
mock_response.payload.data = json.dumps({"access_token": "token"}).encode()
mock_sm_client.access_secret_version.return_value = mock_response
mock_sm_client_class.return_value = mock_sm_client
# Create test folder with files (no subdirs for this test)
# Create test folder with files
(tmp_path / "file1.txt").write_text("content1")
(tmp_path / "file2.txt").write_text("content2")
(tmp_path / "subdir").mkdir() # Should be skipped
service = DropboxService()
with patch.object(service, "upload_file") as mock_upload:
service.upload_folder(str(tmp_path), "/Uploads/folder")
# Should upload 2 files
# Should upload 2 files (not subdir)
assert mock_upload.call_count == 2
@patch("backend.services.dropbox_service.secretmanager.SecretManagerServiceClient")
def test_upload_folder_recursive(self, mock_sm_client_class, tmp_path):
"""Test uploading a folder recursively includes subdirectories."""
from backend.services.dropbox_service import DropboxService
mock_sm_client = Mock()
mock_response = Mock()
mock_response.payload.data = json.dumps({"access_token": "token"}).encode()
mock_sm_client.access_secret_version.return_value = mock_response
mock_sm_client_class.return_value = mock_sm_client
# Create test folder with files and subdirectories
(tmp_path / "root_file.txt").write_text("root content")
(tmp_path / "stems").mkdir()
(tmp_path / "stems" / "vocals.flac").write_text("vocals")
(tmp_path / "stems" / "instrumental.flac").write_text("instrumental")
(tmp_path / "lyrics").mkdir()
(tmp_path / "lyrics" / "song.lrc").write_text("lyrics")
service = DropboxService()
uploaded_files = []
def capture_upload(local_path, remote_path):
uploaded_files.append(remote_path)
with patch.object(service, "upload_file", side_effect=capture_upload) as mock_upload:
service.upload_folder(str(tmp_path), "/Uploads/folder")
# Should upload 4 files (1 root + 2 stems + 1 lyrics)
assert mock_upload.call_count == 4
# Check that subdirectory structure is preserved
assert "/Uploads/folder/root_file.txt" in uploaded_files
assert "/Uploads/folder/stems/vocals.flac" in uploaded_files
assert "/Uploads/folder/stems/instrumental.flac" in uploaded_files
assert "/Uploads/folder/lyrics/song.lrc" in uploaded_files
@patch("backend.services.dropbox_service.secretmanager.SecretManagerServiceClient")
def test_upload_folder_deeply_nested(self, mock_sm_client_class, tmp_path):
"""Test uploading deeply nested folder structure."""
from backend.services.dropbox_service import DropboxService
mock_sm_client = Mock()
mock_response = Mock()
mock_response.payload.data = json.dumps({"access_token": "token"}).encode()
mock_sm_client.access_secret_version.return_value = mock_response
mock_sm_client_class.return_value = mock_sm_client
# Create deeply nested structure
(tmp_path / "level1").mkdir()
(tmp_path / "level1" / "level2").mkdir()
(tmp_path / "level1" / "level2" / "deep_file.txt").write_text("deep")
service = DropboxService()
uploaded_files = []
def capture_upload(local_path, remote_path):
uploaded_files.append(remote_path)
with patch.object(service, "upload_file", side_effect=capture_upload):
service.upload_folder(str(tmp_path), "/Uploads/folder")
# Check deeply nested file is uploaded with correct path
assert "/Uploads/folder/level1/level2/deep_file.txt" in uploaded_files
class TestCreateSharedLink:
"""Test create_shared_link method."""
-412
View File
@@ -1,412 +0,0 @@
"""
Tests for Encoding Interface.
Tests cover:
- EncodingInput and EncodingOutput dataclasses
- LocalEncodingBackend implementation
- Backend factory function
"""
import pytest
from unittest.mock import MagicMock, patch, AsyncMock
from backend.services.encoding_interface import (
EncodingInput,
EncodingOutput,
EncodingBackend,
LocalEncodingBackend,
GCEEncodingBackend,
get_encoding_backend,
)
class TestEncodingInput:
"""Test EncodingInput dataclass."""
def test_required_fields(self):
"""Test that required fields must be provided."""
input_config = EncodingInput(
title_video_path="/path/title.mov",
karaoke_video_path="/path/karaoke.mov",
instrumental_audio_path="/path/audio.flac",
)
assert input_config.title_video_path == "/path/title.mov"
assert input_config.end_video_path is None
def test_all_fields(self):
"""Test all fields including optional ones."""
input_config = EncodingInput(
title_video_path="/path/title.mov",
karaoke_video_path="/path/karaoke.mov",
instrumental_audio_path="/path/audio.flac",
end_video_path="/path/end.mov",
artist="Test Artist",
title="Test Title",
brand_code="NOMAD-1234",
output_dir="/output",
options={"quality": "high"}
)
assert input_config.artist == "Test Artist"
assert input_config.brand_code == "NOMAD-1234"
assert input_config.options["quality"] == "high"
class TestEncodingOutput:
"""Test EncodingOutput dataclass."""
def test_success_output(self):
"""Test successful output."""
output = EncodingOutput(
success=True,
lossless_4k_mp4_path="/output/video.mp4",
encoding_backend="local"
)
assert output.success is True
assert output.error_message is None
def test_failure_output(self):
"""Test failure output."""
output = EncodingOutput(
success=False,
error_message="Encoding failed",
encoding_backend="gce"
)
assert output.success is False
assert output.error_message == "Encoding failed"
def test_output_files_dict(self):
"""Test output_files dictionary."""
output = EncodingOutput(
success=True,
output_files={
"lossless_4k_mp4": "/output/lossless.mp4",
"720p_mp4": "/output/720p.mp4"
}
)
assert "lossless_4k_mp4" in output.output_files
assert output.output_files["720p_mp4"] == "/output/720p.mp4"
class TestLocalEncodingBackend:
"""Test LocalEncodingBackend implementation."""
def test_name(self):
"""Test backend name."""
backend = LocalEncodingBackend()
assert backend.name == "local"
def test_init_with_dry_run(self):
"""Test initialization with dry run."""
backend = LocalEncodingBackend(dry_run=True)
assert backend.dry_run is True
@pytest.mark.asyncio
@patch("subprocess.run")
async def test_is_available_success(self, mock_run):
"""Test availability check when FFmpeg is installed."""
mock_run.return_value = MagicMock(returncode=0)
backend = LocalEncodingBackend()
available = await backend.is_available()
assert available is True
@pytest.mark.asyncio
@patch("subprocess.run")
async def test_is_available_not_found(self, mock_run):
"""Test availability check when FFmpeg is not installed."""
mock_run.side_effect = FileNotFoundError()
backend = LocalEncodingBackend()
available = await backend.is_available()
assert available is False
@pytest.mark.asyncio
@patch.object(LocalEncodingBackend, "is_available")
@patch.object(LocalEncodingBackend, "_get_service")
async def test_get_status(self, mock_get_service, mock_is_available):
"""Test status retrieval."""
mock_is_available.return_value = True
mock_service = MagicMock()
mock_service.hwaccel_available = True
mock_service.video_encoder = "h264_nvenc"
mock_get_service.return_value = mock_service
backend = LocalEncodingBackend()
status = await backend.get_status()
assert status["backend"] == "local"
assert status["available"] is True
@pytest.mark.asyncio
@patch("asyncio.to_thread")
@patch.object(LocalEncodingBackend, "_get_service")
async def test_encode_success(self, mock_get_service, mock_to_thread):
"""Test successful encoding."""
from backend.services.local_encoding_service import EncodingResult
mock_result = EncodingResult(
success=True,
output_files={"key": "/path/file.mp4"}
)
mock_to_thread.return_value = mock_result
mock_service = MagicMock()
mock_get_service.return_value = mock_service
backend = LocalEncodingBackend()
input_config = EncodingInput(
title_video_path="/input/title.mov",
karaoke_video_path="/input/karaoke.mov",
instrumental_audio_path="/input/audio.flac",
artist="Test Artist",
title="Test Title",
output_dir="/output"
)
output = await backend.encode(input_config)
assert output.success is True
assert output.encoding_backend == "local"
assert output.encoding_time_seconds is not None
@pytest.mark.asyncio
@patch("asyncio.to_thread")
@patch.object(LocalEncodingBackend, "_get_service")
async def test_encode_failure(self, mock_get_service, mock_to_thread):
"""Test encoding failure."""
from backend.services.local_encoding_service import EncodingResult
mock_result = EncodingResult(
success=False,
output_files={},
error="FFmpeg failed"
)
mock_to_thread.return_value = mock_result
mock_service = MagicMock()
mock_get_service.return_value = mock_service
backend = LocalEncodingBackend()
input_config = EncodingInput(
title_video_path="/input/title.mov",
karaoke_video_path="/input/karaoke.mov",
instrumental_audio_path="/input/audio.flac",
artist="Test",
title="Test",
)
output = await backend.encode(input_config)
assert output.success is False
assert output.error_message == "FFmpeg failed"
class TestGCEEncodingBackend:
"""Test GCEEncodingBackend implementation."""
def test_name(self):
"""Test backend name."""
backend = GCEEncodingBackend()
assert backend.name == "gce"
@patch.object(GCEEncodingBackend, "_get_service")
@pytest.mark.asyncio
async def test_is_available_enabled(self, mock_get_service):
"""Test availability when GCE is enabled."""
mock_service = MagicMock()
mock_service.is_enabled = True
mock_get_service.return_value = mock_service
backend = GCEEncodingBackend()
available = await backend.is_available()
assert available is True
@patch.object(GCEEncodingBackend, "_get_service")
@pytest.mark.asyncio
async def test_is_available_disabled(self, mock_get_service):
"""Test availability when GCE is disabled."""
mock_service = MagicMock()
mock_service.is_enabled = False
mock_get_service.return_value = mock_service
backend = GCEEncodingBackend()
available = await backend.is_available()
assert available is False
@patch.object(GCEEncodingBackend, "_get_service")
@pytest.mark.asyncio
async def test_encode_missing_gcs_paths(self, mock_get_service):
"""Test encoding fails without GCS paths."""
backend = GCEEncodingBackend()
input_config = EncodingInput(
title_video_path="/input/title.mov",
karaoke_video_path="/input/karaoke.mov",
instrumental_audio_path="/input/audio.flac",
# Missing GCS paths in options
)
output = await backend.encode(input_config)
assert output.success is False
assert "gcs_path" in output.error_message.lower()
@patch.object(GCEEncodingBackend, "_get_service")
@pytest.mark.asyncio
async def test_encode_success(self, mock_get_service):
"""Test successful GCE encoding."""
mock_service = MagicMock()
mock_service.encode_videos = AsyncMock(return_value={
"status": "complete",
"output_files": {
"mp4_4k_lossless": "gs://bucket/output/lossless.mp4",
"mp4_720p": "gs://bucket/output/720p.mp4",
}
})
mock_get_service.return_value = mock_service
backend = GCEEncodingBackend()
input_config = EncodingInput(
title_video_path="/input/title.mov",
karaoke_video_path="/input/karaoke.mov",
instrumental_audio_path="/input/audio.flac",
artist="Test Artist",
title="Test Title",
options={
"job_id": "test-job",
"input_gcs_path": "gs://bucket/input/",
"output_gcs_path": "gs://bucket/output/",
}
)
output = await backend.encode(input_config)
assert output.success is True
assert output.encoding_backend == "gce"
mock_service.encode_videos.assert_called_once()
@patch.object(GCEEncodingBackend, "_get_service")
@pytest.mark.asyncio
async def test_encode_failure(self, mock_get_service):
"""Test GCE encoding failure handling."""
mock_service = MagicMock()
mock_service.encode_videos = AsyncMock(side_effect=Exception("GCE worker error"))
mock_get_service.return_value = mock_service
backend = GCEEncodingBackend()
input_config = EncodingInput(
title_video_path="/input/title.mov",
karaoke_video_path="/input/karaoke.mov",
instrumental_audio_path="/input/audio.flac",
options={
"job_id": "test-job",
"input_gcs_path": "gs://bucket/input/",
"output_gcs_path": "gs://bucket/output/",
}
)
output = await backend.encode(input_config)
assert output.success is False
assert "GCE worker error" in output.error_message
@patch.object(GCEEncodingBackend, "_get_service")
@pytest.mark.asyncio
async def test_encode_handles_list_result(self, mock_get_service):
"""Test GCE encoding handles list response gracefully.
This would have caught: 'list' object has no attribute 'get' error
when GCE worker returns a list instead of a dict.
"""
mock_service = MagicMock()
# Simulate GCE worker returning a list instead of dict
mock_service.encode_videos = AsyncMock(return_value=[
{"output_files": {"mp4_4k_lossless": "gs://bucket/output/lossless.mp4"}}
])
mock_get_service.return_value = mock_service
backend = GCEEncodingBackend()
input_config = EncodingInput(
title_video_path="/input/title.mov",
karaoke_video_path="/input/karaoke.mov",
instrumental_audio_path="/input/audio.flac",
options={
"job_id": "test-job",
"input_gcs_path": "gs://bucket/input/",
"output_gcs_path": "gs://bucket/output/",
}
)
# This should not raise an error
output = await backend.encode(input_config)
# Should still succeed by extracting from the list
assert output.success is True
assert output.lossless_4k_mp4_path == "gs://bucket/output/lossless.mp4"
class TestGetEncodingBackend:
"""Test encoding backend factory function."""
def test_get_local_backend(self):
"""Test getting local backend."""
backend = get_encoding_backend("local")
assert isinstance(backend, LocalEncodingBackend)
assert backend.name == "local"
@patch.object(GCEEncodingBackend, "_get_service")
def test_get_auto_backend_gce_disabled(self, mock_get_service):
"""Test getting auto backend falls back to local when GCE disabled."""
mock_service = MagicMock()
mock_service.is_enabled = False
mock_get_service.return_value = mock_service
backend = get_encoding_backend("auto")
assert isinstance(backend, LocalEncodingBackend)
def test_get_local_backend_with_options(self):
"""Test getting local backend with options."""
backend = get_encoding_backend("local", dry_run=True)
assert backend.dry_run is True
def test_get_gce_backend(self):
"""Test getting GCE backend."""
backend = get_encoding_backend("gce")
assert isinstance(backend, GCEEncodingBackend)
assert backend.name == "gce"
def test_get_unknown_backend_raises(self):
"""Test that unknown backend raises ValueError."""
with pytest.raises(ValueError) as exc_info:
get_encoding_backend("unknown")
assert "Unknown encoding backend type" in str(exc_info.value)
def test_get_gce_backend_with_options(self):
"""Test getting GCE backend with common options like dry_run.
This ensures all backends accept the same kwargs, preventing
errors when get_encoding_backend() passes **kwargs to different backends.
"""
# This would have caught: GCEEncodingBackend.__init__() got an unexpected keyword argument 'dry_run'
backend = get_encoding_backend("gce", dry_run=True)
assert isinstance(backend, GCEEncodingBackend)
assert backend.dry_run is True
@patch.object(GCEEncodingBackend, "_get_service")
def test_all_backends_accept_dry_run(self, mock_get_service):
"""Test that all backend types accept dry_run parameter.
This is an integration test to ensure the factory function
can pass dry_run to any backend without TypeError.
"""
mock_service = MagicMock()
mock_service.is_enabled = False
mock_get_service.return_value = mock_service
for backend_type in ["local", "gce", "auto"]:
# This should not raise TypeError
backend = get_encoding_backend(backend_type, dry_run=True)
assert backend is not None
-128
View File
@@ -1606,133 +1606,5 @@ class TestIsUrlFunction:
assert is_url("") is False
class TestUploadEndpointThemeSupport:
"""Test that /jobs/upload endpoint supports theme configuration.
CRITICAL: These tests verify that the /api/jobs/upload endpoint correctly handles
theme_id and color_overrides parameters, ensuring preview videos have themed
backgrounds instead of black backgrounds.
This addresses a bug where:
- The frontend sends theme_id and color_overrides when uploading files
- But the backend /api/jobs/upload endpoint was ignoring these parameters
- Result: Jobs created via file upload had black backgrounds instead of themed ones
"""
def test_upload_endpoint_accepts_theme_id_parameter(self):
"""Verify the upload endpoint has theme_id as a form parameter.
CRITICAL: The frontend sends theme_id when uploading files with a theme.
If this parameter is missing from the endpoint, the theme is silently ignored
and preview videos will have black backgrounds instead of themed ones.
"""
from backend.api.routes import file_upload as file_upload_module
with open(file_upload_module.__file__, 'r') as f:
source_code = f.read()
has_theme_id_param = 'theme_id: Optional[str] = Form(' in source_code
assert has_theme_id_param, (
"file_upload.py /jobs/upload endpoint does not have theme_id as a Form parameter. "
"The frontend sends theme_id when uploading files with a theme, but the backend "
"ignores it. Add: theme_id: Optional[str] = Form(None, description='Theme ID...')"
)
def test_upload_endpoint_accepts_color_overrides_parameter(self):
"""Verify the upload endpoint has color_overrides as a form parameter."""
from backend.api.routes import file_upload as file_upload_module
with open(file_upload_module.__file__, 'r') as f:
source_code = f.read()
has_color_overrides_param = 'color_overrides: Optional[str] = Form(' in source_code
assert has_color_overrides_param, (
"file_upload.py /jobs/upload endpoint does not have color_overrides as a Form parameter. "
"The frontend sends color_overrides when customizing theme colors."
)
def test_upload_endpoint_calls_prepare_theme_for_job(self):
"""Verify the upload endpoint calls _prepare_theme_for_job when theme_id is set.
CRITICAL: When a job is created via the upload endpoint with a theme_id
(and no custom style files), the code must call _prepare_theme_for_job() to set:
1. style_params_gcs_path (pointing to the copied style_params.json)
2. style_assets (populated with asset mappings)
Without this, LyricsTranscriber won't have access to the theme's styles
and preview videos will have black backgrounds instead of themed ones.
"""
from backend.api.routes import file_upload as file_upload_module
with open(file_upload_module.__file__, 'r') as f:
source_code = f.read()
# The function should be called in upload_and_create_job
has_theme_prep_call = '_prepare_theme_for_job(' in source_code
assert has_theme_prep_call, (
"file_upload.py does not call _prepare_theme_for_job(). "
"When theme_id is provided to /jobs/upload without custom style files, "
"the endpoint MUST call _prepare_theme_for_job() to copy the theme's "
"style_params.json to the job folder."
)
def test_upload_endpoint_uses_resolve_cdg_txt_defaults(self):
"""Verify the upload endpoint uses _resolve_cdg_txt_defaults for theme-based defaults."""
from backend.api.routes import file_upload as file_upload_module
with open(file_upload_module.__file__, 'r') as f:
source_code = f.read()
has_resolve_call = '_resolve_cdg_txt_defaults(' in source_code
assert has_resolve_call, (
"file_upload.py does not call _resolve_cdg_txt_defaults(). "
"When theme_id is set, enable_cdg and enable_txt should default to True."
)
def test_upload_endpoint_has_optional_cdg_txt_params(self):
"""Verify enable_cdg and enable_txt are Optional[bool] to support theme defaults.
CRITICAL: If enable_cdg/enable_txt are bool instead of Optional[bool],
they will default to False and override the theme-based defaults.
"""
from backend.api.routes import file_upload as file_upload_module
with open(file_upload_module.__file__, 'r') as f:
source_code = f.read()
has_optional_cdg = 'enable_cdg: Optional[bool] = Form(' in source_code
has_optional_txt = 'enable_txt: Optional[bool] = Form(' in source_code
assert has_optional_cdg, (
"file_upload.py has enable_cdg as bool instead of Optional[bool]. "
"This prevents theme-based defaults from working."
)
assert has_optional_txt, (
"file_upload.py has enable_txt as bool instead of Optional[bool]. "
"This prevents theme-based defaults from working."
)
def test_job_create_includes_theme_id_and_color_overrides(self):
"""Verify JobCreate is called with theme_id and color_overrides."""
from backend.api.routes import file_upload as file_upload_module
with open(file_upload_module.__file__, 'r') as f:
source_code = f.read()
has_theme_id_in_job_create = 'theme_id=theme_id,' in source_code
has_color_overrides_in_job_create = 'color_overrides=parsed_color_overrides' in source_code
assert has_theme_id_in_job_create, (
"file_upload.py does not pass theme_id to JobCreate."
)
assert has_color_overrides_in_job_create, (
"file_upload.py does not pass color_overrides to JobCreate."
)
if __name__ == "__main__":
pytest.main([__file__, "-v"])
@@ -1,583 +0,0 @@
"""
Regression tests for job creation issues discovered 2024-12-31.
These tests ensure:
1. user_email is properly extracted from AuthResult and set on jobs
2. URL jobs trigger workers sequentially (audio first, then lyrics)
3. Audio search downloads work without relying on in-memory cache
4. Transcription has proper timeout handling
See docs/archive/2024-12-31-job-failure-investigation.md for details.
"""
import asyncio
import pytest
from unittest.mock import Mock, AsyncMock, patch, MagicMock
from datetime import datetime, timezone
from backend.services.auth_service import AuthResult, UserType
class TestUserEmailExtraction:
"""
Issue 1: user_email not being set on jobs.
Root cause: Job creation endpoints used require_auth but didn't extract
auth_result.user_email and set it on the job.
These tests verify that authenticated user's email is properly set on jobs.
"""
@pytest.fixture
def mock_auth_result_with_email(self):
"""AuthResult for a logged-in user with email."""
return AuthResult(
is_valid=True,
user_type=UserType.UNLIMITED, # Session-based users typically have UNLIMITED
remaining_uses=-1,
message="Valid session",
user_email="testuser@example.com",
is_admin=False,
)
@pytest.fixture
def mock_auth_result_admin_token(self):
"""AuthResult for admin token without email."""
return AuthResult(
is_valid=True,
user_type=UserType.ADMIN,
remaining_uses=-1,
message="Valid admin token",
user_email=None,
is_admin=True,
)
def test_auth_result_has_user_email_field(self):
"""AuthResult must have user_email field for job association."""
result = AuthResult(
is_valid=True,
user_type=UserType.UNLIMITED,
remaining_uses=-1,
message="test",
user_email="user@example.com",
)
assert hasattr(result, 'user_email')
assert result.user_email == "user@example.com"
def test_auth_result_user_email_can_be_none(self):
"""AuthResult user_email can be None for token-based auth."""
result = AuthResult(
is_valid=True,
user_type=UserType.ADMIN,
remaining_uses=-1,
message="test",
user_email=None,
)
assert result.user_email is None
def test_upload_endpoint_extracts_user_email_from_auth(self):
"""
/jobs/upload endpoint must set user_email from authenticated user.
This verifies the code pattern by inspecting the source.
Integration tests verify the full behavior.
"""
from backend.api.routes import file_upload
import inspect
# Get the source code of upload_and_create_job
source = inspect.getsource(file_upload.upload_and_create_job)
# Verify the endpoint extracts user_email from auth_result
assert 'auth_result.user_email' in source, \
"upload_and_create_job must extract user_email from auth_result"
assert 'effective_user_email' in source, \
"upload_and_create_job must use effective_user_email pattern"
assert 'user_email=effective_user_email' in source or 'user_email=' in source, \
"upload_and_create_job must pass user_email to JobCreate"
def test_all_job_creation_endpoints_extract_user_email(self):
"""
All job creation endpoints must extract user_email from AuthResult.
This is a regression guard for Issue 1 (user_email not being set).
"""
from backend.api.routes import file_upload, audio_search
import inspect
endpoints_to_check = [
(file_upload, 'upload_and_create_job'),
(file_upload, 'create_job_from_url'),
(audio_search, 'search_audio'),
]
for module, func_name in endpoints_to_check:
func = getattr(module, func_name)
source = inspect.getsource(func)
assert 'auth_result.user_email' in source, \
f"{func_name} must extract user_email from auth_result"
@pytest.mark.asyncio
async def test_create_from_url_endpoint_sets_user_email(self, mock_auth_result_with_email):
"""
/jobs/create-from-url endpoint must set user_email from authenticated user.
"""
from backend.api.routes.file_upload import create_job_from_url, CreateJobFromUrlRequest
mock_request = Mock()
mock_request.headers = {}
mock_request.client = Mock(host="127.0.0.1")
mock_request.url = Mock(path="/api/jobs/create-from-url")
mock_background_tasks = Mock()
body = CreateJobFromUrlRequest(
url="https://www.youtube.com/watch?v=dQw4w9WgXcQ",
artist="Rick Astley",
title="Never Gonna Give You Up",
)
with patch('backend.api.routes.file_upload.job_manager') as mock_jm, \
patch('backend.api.routes.file_upload.worker_service') as mock_worker, \
patch('backend.api.routes.file_upload.get_credential_manager') as mock_cred:
mock_job = Mock()
mock_job.job_id = "test-job-456"
mock_jm.create_job.return_value = mock_job
mock_cred.return_value.check_youtube_credentials.return_value = Mock(status=Mock(value="valid"))
await create_job_from_url(
request=mock_request,
background_tasks=mock_background_tasks,
body=body,
auth_result=mock_auth_result_with_email,
)
mock_jm.create_job.assert_called_once()
job_create_arg = mock_jm.create_job.call_args[0][0]
assert job_create_arg.user_email == "testuser@example.com", \
"create-from-url must set user_email from AuthResult"
@pytest.mark.asyncio
async def test_audio_search_endpoint_sets_user_email(self, mock_auth_result_with_email):
"""
/audio-search/search endpoint must set user_email from authenticated user.
"""
from backend.api.routes.audio_search import search_audio, AudioSearchRequest
mock_request = Mock()
mock_request.headers = {}
mock_request.client = Mock(host="127.0.0.1")
mock_request.url = Mock(path="/api/audio-search/search")
mock_background_tasks = Mock()
body = AudioSearchRequest(
artist="Test Artist",
title="Test Song",
)
with patch('backend.api.routes.audio_search.job_manager') as mock_jm, \
patch('backend.api.routes.audio_search.get_audio_search_service') as mock_search, \
patch('backend.api.routes.audio_search.get_credential_manager') as mock_cred:
mock_job = Mock()
mock_job.job_id = "test-job-789"
mock_job.state_data = {}
mock_jm.create_job.return_value = mock_job
mock_jm.get_job.return_value = mock_job
mock_cred.return_value.check_youtube_credentials.return_value = Mock(status=Mock(value="valid"))
mock_search.return_value.search.return_value = []
await search_audio(
request=mock_request,
background_tasks=mock_background_tasks,
body=body,
auth_result=mock_auth_result_with_email,
)
mock_jm.create_job.assert_called_once()
job_create_arg = mock_jm.create_job.call_args[0][0]
assert job_create_arg.user_email == "testuser@example.com", \
"audio-search must set user_email from AuthResult"
def test_effective_user_email_prefers_auth_over_form(self):
"""
When both auth_result.user_email and form user_email are provided,
the authenticated user's email should take precedence.
"""
auth_email = "authenticated@example.com"
form_email = "form@example.com"
# This is the logic used in the endpoints
effective_user_email = auth_email or form_email
assert effective_user_email == auth_email, \
"Authenticated user's email should take precedence over form parameter"
def test_effective_user_email_falls_back_to_form(self):
"""
When auth_result.user_email is None (e.g., admin token),
form user_email should be used as fallback.
"""
auth_email = None
form_email = "form@example.com"
effective_user_email = auth_email or form_email
assert effective_user_email == form_email, \
"Form parameter should be used when auth has no email"
class TestUrlJobWorkerSequencing:
"""
Issue 2: YouTube URL download race condition.
Root cause: Both audio and lyrics workers were triggered in parallel.
For URL jobs, lyrics worker would timeout waiting for audio to download.
These tests verify that URL jobs trigger workers sequentially.
"""
@pytest.mark.asyncio
async def test_url_job_triggers_only_audio_worker_initially(self):
"""
create-from-url must only trigger audio worker, not lyrics worker.
The audio worker will trigger lyrics after download completes.
"""
from backend.api.routes.file_upload import _trigger_audio_worker_only
with patch('backend.api.routes.file_upload.worker_service') as mock_ws:
mock_ws.trigger_audio_worker = AsyncMock()
mock_ws.trigger_lyrics_worker = AsyncMock()
await _trigger_audio_worker_only("test-job-id")
mock_ws.trigger_audio_worker.assert_called_once_with("test-job-id")
mock_ws.trigger_lyrics_worker.assert_not_called()
@pytest.mark.asyncio
async def test_parallel_worker_triggers_both_workers(self):
"""
_trigger_workers_parallel should trigger both workers (for uploaded files).
"""
from backend.api.routes.file_upload import _trigger_workers_parallel
with patch('backend.api.routes.file_upload.worker_service') as mock_ws:
mock_ws.trigger_audio_worker = AsyncMock()
mock_ws.trigger_lyrics_worker = AsyncMock()
await _trigger_workers_parallel("test-job-id")
mock_ws.trigger_audio_worker.assert_called_once_with("test-job-id")
mock_ws.trigger_lyrics_worker.assert_called_once_with("test-job-id")
@pytest.mark.asyncio
async def test_audio_worker_triggers_lyrics_after_url_download(self):
"""
Audio worker must trigger lyrics worker after successful URL download.
"""
from backend.workers.audio_worker import _trigger_lyrics_worker_after_url_download
# Mock at the source module where it's imported from
with patch('backend.services.worker_service.get_worker_service') as mock_get_ws:
mock_ws = Mock()
mock_ws.trigger_lyrics_worker = AsyncMock()
mock_get_ws.return_value = mock_ws
await _trigger_lyrics_worker_after_url_download("test-job-id")
mock_ws.trigger_lyrics_worker.assert_called_once_with("test-job-id")
@pytest.mark.asyncio
async def test_audio_worker_lyrics_trigger_handles_errors_gracefully(self):
"""
If lyrics worker trigger fails, audio processing should continue.
"""
from backend.workers.audio_worker import _trigger_lyrics_worker_after_url_download
# Mock at the source module where it's imported from
with patch('backend.services.worker_service.get_worker_service') as mock_get_ws:
mock_ws = Mock()
mock_ws.trigger_lyrics_worker = AsyncMock(side_effect=Exception("Network error"))
mock_get_ws.return_value = mock_ws
# Should not raise exception
await _trigger_lyrics_worker_after_url_download("test-job-id")
class TestAudioSearchCacheIndependence:
"""
Issue 3: Audio search cache not persisting across Cloud Run instances.
Root cause: AudioSearchService used in-memory cache that doesn't persist
across horizontally scaled instances.
These tests verify downloads work using state_data, not in-memory cache.
"""
def test_search_results_stored_in_job_state_data(self):
"""
Search results must be stored in job.state_data for persistence.
This tests the Job model's ability to store search results.
"""
from backend.models.job import Job, JobStatus
job = Job(
job_id="test-123",
artist="Test Artist",
title="Test Song",
status=JobStatus.PENDING,
created_at=datetime.now(timezone.utc),
updated_at=datetime.now(timezone.utc),
state_data={
'audio_search_results': [
{
'provider': 'YouTube',
'title': 'Test Song',
'artist': 'Test Artist',
'url': 'https://youtube.com/watch?v=abc123',
'source_id': 'abc123',
}
]
}
)
assert 'audio_search_results' in job.state_data
assert len(job.state_data['audio_search_results']) == 1
assert job.state_data['audio_search_results'][0]['url'] == 'https://youtube.com/watch?v=abc123'
def test_audio_search_endpoint_stores_results_in_state_data(self):
"""
Verify that the search_audio code path stores results in job.state_data.
This tests that the audio_search route has the correct pattern for
persisting search results. The actual integration is tested elsewhere.
"""
# Verify the import and module structure exists
from backend.api.routes import audio_search
import inspect
# Get the source code of search_audio
source = inspect.getsource(audio_search.search_audio)
# Verify the endpoint stores results in state_data
# The code uses job_manager.update_job with state_data dict
assert 'audio_search_results' in source, \
"search_audio must store results under 'audio_search_results' key"
assert 'state_data' in source, \
"search_audio must use state_data for persistence"
def test_download_code_has_youtube_direct_download_branch(self):
"""
Verify that _download_and_start_processing has the YouTube direct download path.
This checks that the code path exists for downloading YouTube audio directly
using the URL from state_data, avoiding the in-memory cache dependency.
"""
from backend.api.routes import audio_search
import inspect
# Get the source of _download_and_start_processing
source = inspect.getsource(audio_search._download_and_start_processing)
# Verify the YouTube direct download branch exists
assert "source_name == 'YouTube'" in source, \
"_download_and_start_processing must check for YouTube source"
assert 'download_url' in source, \
"_download_and_start_processing must use download_url from state_data"
assert 'download_from_url' in source, \
"_download_and_start_processing must call download_from_url for YouTube"
def test_youtube_download_branch_avoids_cache_dependency(self):
"""
Verify that the YouTube download path uses URL from state_data,
not the in-memory cache that doesn't persist across Cloud Run instances.
"""
from backend.api.routes import audio_search
import inspect
source = inspect.getsource(audio_search._download_and_start_processing)
# The fix specifically uses selected.get('url') which comes from state_data
# rather than audio_search_service cache
assert "selected.get('url')" in source or "download_url" in source, \
"YouTube download must use URL from selected result (state_data)"
# Verify it doesn't rely on cache for YouTube
# The branch is: elif source_name == 'YouTube' and download_url:
assert "YouTube" in source and "download_url" in source, \
"YouTube branch must check for download_url availability"
class TestTranscriptionTimeout:
"""
Issue 4: Jobs stuck in downloading state.
Root cause: Lyrics worker's AudioShake transcription could hang forever
without proper timeout, leaving jobs stuck.
These tests verify timeout handling for transcription.
"""
def test_transcription_timeout_constant_exists(self):
"""
Verify transcription timeout constant is defined in lyrics_worker.
"""
from backend.workers.lyrics_worker import TRANSCRIPTION_TIMEOUT_SECONDS
assert TRANSCRIPTION_TIMEOUT_SECONDS > 0
assert TRANSCRIPTION_TIMEOUT_SECONDS >= 300, "Timeout should be at least 5 minutes for long songs"
assert TRANSCRIPTION_TIMEOUT_SECONDS <= 1500, "Timeout shouldn't be more than 25 minutes"
def test_transcription_timeout_value(self):
"""
Verify the specific timeout value (20 minutes = 1200 seconds).
This accounts for:
- Cloud Run cold start / worker initialization (1-5 min)
- AudioShake transcription (1-2 min)
- spaCy model loading for correction (2-3 min on cold start)
- Agentic AI correction (1-3 min)
"""
from backend.workers.lyrics_worker import TRANSCRIPTION_TIMEOUT_SECONDS
assert TRANSCRIPTION_TIMEOUT_SECONDS == 1200, "Transcription timeout should be 20 minutes (1200 seconds)"
@pytest.mark.asyncio
async def test_asyncio_wait_for_raises_timeout_error(self):
"""
Verify asyncio.wait_for properly raises TimeoutError.
This is a sanity check for the timeout mechanism we use.
"""
async def slow_operation():
await asyncio.sleep(10)
return "completed"
with pytest.raises(asyncio.TimeoutError):
await asyncio.wait_for(slow_operation(), timeout=0.1)
@pytest.mark.asyncio
async def test_lyrics_worker_timeout_converts_to_descriptive_error(self):
"""
Verify that timeout is converted to a descriptive exception message.
Tests the actual error conversion logic pattern used in lyrics_worker.
"""
from backend.workers.lyrics_worker import TRANSCRIPTION_TIMEOUT_SECONDS
# This simulates what happens in lyrics_worker when timeout occurs
error_message = None
try:
# Simulate the timeout handling pattern from lyrics_worker
raise asyncio.TimeoutError()
except asyncio.TimeoutError:
error_message = f"Transcription timed out after {TRANSCRIPTION_TIMEOUT_SECONDS} seconds"
assert error_message is not None
assert "timed out" in error_message.lower()
assert "1200" in error_message
def test_lyrics_worker_exception_marks_job_failed(self):
"""
Any exception in lyrics worker should mark job as failed.
"""
from backend.models.job import JobStatus
# Simulate the exception handling in lyrics_worker
job_status = JobStatus.DOWNLOADING
error_occurred = True
if error_occurred:
# This is what happens in the except block
job_status = JobStatus.FAILED
error_message = "Lyrics transcription failed: Transcription timed out after 1200 seconds"
assert job_status == JobStatus.FAILED
assert "timed out" in error_message.lower()
class TestJobOwnershipFiltering:
"""
Additional tests for job ownership and filtering.
These verify that jobs are properly associated with users
and can be filtered by user_email.
"""
def test_job_model_has_user_email_field(self):
"""Job model must have user_email field."""
from backend.models.job import Job, JobStatus
job = Job(
job_id="test-123",
artist="Test",
title="Test",
status=JobStatus.PENDING,
created_at=datetime.now(timezone.utc),
updated_at=datetime.now(timezone.utc),
user_email="user@example.com",
)
assert hasattr(job, 'user_email')
assert job.user_email == "user@example.com"
def test_job_create_model_has_user_email_field(self):
"""JobCreate model must have user_email field."""
from backend.models.job import JobCreate
job_create = JobCreate(
artist="Test",
title="Test",
user_email="user@example.com",
)
assert hasattr(job_create, 'user_email')
assert job_create.user_email == "user@example.com"
def test_job_create_user_email_is_optional(self):
"""JobCreate user_email should be optional for backward compatibility."""
from backend.models.job import JobCreate
job_create = JobCreate(
artist="Test",
title="Test",
)
assert job_create.user_email is None
def test_jobs_can_be_filtered_by_user_email(self):
"""Jobs should be filterable by user_email."""
from backend.models.job import Job, JobStatus
jobs = [
Job(
job_id="job-1",
artist="Test",
title="Test 1",
status=JobStatus.COMPLETE,
created_at=datetime.now(timezone.utc),
updated_at=datetime.now(timezone.utc),
user_email="user1@example.com",
),
Job(
job_id="job-2",
artist="Test",
title="Test 2",
status=JobStatus.COMPLETE,
created_at=datetime.now(timezone.utc),
updated_at=datetime.now(timezone.utc),
user_email="user2@example.com",
),
Job(
job_id="job-3",
artist="Test",
title="Test 3",
status=JobStatus.COMPLETE,
created_at=datetime.now(timezone.utc),
updated_at=datetime.now(timezone.utc),
user_email="user1@example.com",
),
]
user1_jobs = [j for j in jobs if j.user_email == "user1@example.com"]
assert len(user1_jobs) == 2
assert all(j.user_email == "user1@example.com" for j in user1_jobs)
+3 -18
View File
@@ -54,16 +54,10 @@ def client(mock_job_manager, mock_worker_service):
"""Create TestClient with mocked dependencies."""
mock_creds = MagicMock()
mock_creds.universe_domain = 'googleapis.com'
# Create a JobManager class that returns our mock instance
def mock_job_manager_factory(*args, **kwargs):
return mock_job_manager
# Patch at the module level where jobs.py imports them
# Also patch JobManager class used in dependencies.py for auth checks
with patch('backend.api.routes.jobs.job_manager', mock_job_manager), \
patch('backend.api.routes.jobs.worker_service', mock_worker_service), \
patch('backend.services.job_manager.JobManager', mock_job_manager_factory), \
patch('backend.services.firestore_service.firestore'), \
patch('backend.services.storage_service.storage'), \
patch('google.auth.default', return_value=(mock_creds, 'test-project')):
@@ -93,13 +87,9 @@ class TestGetJob:
mock_job_manager.get_job.return_value = None
mock_creds = MagicMock()
mock_creds.universe_domain = 'googleapis.com'
def mock_job_manager_factory(*args, **kwargs):
return mock_job_manager
with patch('backend.api.routes.jobs.job_manager', mock_job_manager), \
patch('backend.api.routes.jobs.worker_service', mock_worker_service), \
patch('backend.services.job_manager.JobManager', mock_job_manager_factory), \
patch('backend.services.firestore_service.firestore'), \
patch('backend.services.storage_service.storage'), \
patch('google.auth.default', return_value=(mock_creds, 'test-project')):
@@ -183,17 +173,12 @@ class TestDeleteJob:
def test_delete_nonexistent_job(self, mock_worker_service, auth_headers):
"""Test deleting non-existent job."""
mock_job_manager = MagicMock()
mock_job_manager.get_job.return_value = None # Job doesn't exist
mock_job_manager.delete_job.return_value = False
mock_creds = MagicMock()
mock_creds.universe_domain = 'googleapis.com'
def mock_job_manager_factory(*args, **kwargs):
return mock_job_manager
with patch('backend.api.routes.jobs.job_manager', mock_job_manager), \
patch('backend.api.routes.jobs.worker_service', mock_worker_service), \
patch('backend.services.job_manager.JobManager', mock_job_manager_factory), \
patch('backend.services.firestore_service.firestore'), \
patch('backend.services.storage_service.storage'), \
patch('google.auth.default', return_value=(mock_creds, 'test-project')):
@@ -1,423 +0,0 @@
"""
Tests for LocalEncodingService.
Tests cover:
- Service initialization
- Hardware acceleration detection
- FFmpeg command execution
- Individual encoding methods
- Full encoding pipeline
- Dry run mode
"""
import os
import tempfile
import pytest
from unittest.mock import MagicMock, patch, call
from backend.services.local_encoding_service import (
LocalEncodingService,
EncodingConfig,
EncodingResult,
get_local_encoding_service,
)
class TestLocalEncodingServiceInit:
"""Test service initialization."""
def test_init_default_values(self):
"""Test default initialization."""
service = LocalEncodingService()
assert service.dry_run is False
assert "ffmpeg" in service._ffmpeg_base_command
def test_init_with_dry_run(self):
"""Test initialization with dry run mode."""
service = LocalEncodingService(dry_run=True)
assert service.dry_run is True
def test_init_with_debug_logging(self):
"""Test initialization with debug logging level."""
import logging
service = LocalEncodingService(log_level=logging.DEBUG)
assert "-loglevel verbose" in service._ffmpeg_base_command
def test_init_with_info_logging(self):
"""Test initialization with info logging level."""
import logging
service = LocalEncodingService(log_level=logging.INFO)
assert "-loglevel fatal" in service._ffmpeg_base_command
class TestLocalEncodingServiceHWAccel:
"""Test hardware acceleration detection."""
@patch("subprocess.run")
def test_detect_nvenc_available(self, mock_run):
"""Test NVENC detection when available."""
mock_run.return_value = MagicMock(returncode=0)
service = LocalEncodingService()
# Force detection
service._detect_and_set_hwaccel()
assert service._hwaccel_available is True
assert service._video_encoder == "h264_nvenc"
assert service._scale_filter == "scale_cuda"
@patch("subprocess.run")
def test_detect_no_hwaccel(self, mock_run):
"""Test fallback when no hardware acceleration available."""
import subprocess
mock_run.side_effect = subprocess.CalledProcessError(1, "test")
service = LocalEncodingService()
# Force detection
service._detect_and_set_hwaccel()
assert service._hwaccel_available is False
assert service._video_encoder == "libx264"
assert service._scale_filter == "scale"
def test_nvenc_quality_settings(self):
"""Test NVENC quality settings for different presets."""
service = LocalEncodingService()
service._hwaccel_available = True
lossless = service._get_nvenc_quality_settings("lossless")
assert "cq 0" in lossless
medium = service._get_nvenc_quality_settings("medium")
assert "p4" in medium
def test_nvenc_quality_settings_disabled(self):
"""Test NVENC quality settings when hwaccel is disabled."""
service = LocalEncodingService()
service._hwaccel_available = False
settings = service._get_nvenc_quality_settings("lossless")
assert settings == ""
class TestLocalEncodingServiceExecuteCommand:
"""Test command execution."""
@patch("subprocess.run")
def test_execute_command_success(self, mock_run):
"""Test successful command execution."""
mock_run.return_value = MagicMock(returncode=0)
service = LocalEncodingService()
result = service._execute_command("echo test", "Test command")
assert result is True
mock_run.assert_called_once()
@patch("subprocess.run")
def test_execute_command_failure(self, mock_run):
"""Test command execution failure."""
import subprocess
mock_run.side_effect = subprocess.CalledProcessError(
1, "test", stderr="Error message"
)
service = LocalEncodingService()
result = service._execute_command("echo test", "Test command")
assert result is False
@patch("subprocess.run")
def test_execute_command_timeout(self, mock_run):
"""Test command execution timeout."""
import subprocess
mock_run.side_effect = subprocess.TimeoutExpired("test", 30)
service = LocalEncodingService()
result = service._execute_command("echo test", "Test command", timeout=30)
assert result is False
def test_execute_command_dry_run(self):
"""Test command execution in dry run mode."""
service = LocalEncodingService(dry_run=True)
result = service._execute_command("echo test", "Test command")
assert result is True
# No actual subprocess should be called in dry run mode
class TestLocalEncodingServiceEncodingMethods:
"""Test individual encoding methods."""
@patch.object(LocalEncodingService, "_execute_command")
def test_remux_with_instrumental(self, mock_execute):
"""Test remuxing with instrumental audio."""
mock_execute.return_value = True
service = LocalEncodingService()
result = service.remux_with_instrumental(
"/input/video.mov",
"/input/audio.flac",
"/output/video.mp4"
)
assert result is True
mock_execute.assert_called_once()
call_args = mock_execute.call_args[0][0]
assert "/input/video.mov" in call_args
assert "/input/audio.flac" in call_args
assert "-map 0:v -map 1:a" in call_args
@patch.object(LocalEncodingService, "_execute_command_with_fallback")
def test_convert_mov_to_mp4(self, mock_execute):
"""Test MOV to MP4 conversion."""
mock_execute.return_value = True
service = LocalEncodingService()
result = service.convert_mov_to_mp4(
"/input/video.mov",
"/output/video.mp4"
)
assert result is True
mock_execute.assert_called_once()
@patch.object(LocalEncodingService, "_execute_command_with_fallback")
def test_encode_lossless_mp4_without_end(self, mock_execute):
"""Test lossless 4K MP4 encoding without end credits."""
mock_execute.return_value = True
service = LocalEncodingService()
result = service.encode_lossless_mp4(
"/input/title.mov",
"/input/karaoke.mp4",
"/output/lossless.mp4"
)
assert result is True
mock_execute.assert_called_once()
call_args = mock_execute.call_args
assert "concat=n=2" in call_args[0][0] # GPU command
@patch.object(LocalEncodingService, "_execute_command_with_fallback")
def test_encode_lossless_mp4_with_end(self, mock_execute):
"""Test lossless 4K MP4 encoding with end credits."""
mock_execute.return_value = True
with tempfile.TemporaryDirectory() as tmpdir:
end_file = os.path.join(tmpdir, "end.mov")
with open(end_file, "w") as f:
f.write("fake video")
service = LocalEncodingService()
result = service.encode_lossless_mp4(
"/input/title.mov",
"/input/karaoke.mp4",
"/output/lossless.mp4",
end_video=end_file
)
assert result is True
call_args = mock_execute.call_args
assert "concat=n=3" in call_args[0][0] # 3 videos
@patch.object(LocalEncodingService, "_execute_command")
def test_encode_lossy_mp4(self, mock_execute):
"""Test lossy 4K MP4 encoding."""
mock_execute.return_value = True
service = LocalEncodingService()
result = service.encode_lossy_mp4(
"/input/lossless.mp4",
"/output/lossy.mp4"
)
assert result is True
call_args = mock_execute.call_args[0][0]
assert "-c:v copy" in call_args
assert "aac" in call_args.lower()
@patch.object(LocalEncodingService, "_execute_command")
def test_encode_lossless_mkv(self, mock_execute):
"""Test MKV encoding with FLAC audio."""
mock_execute.return_value = True
service = LocalEncodingService()
result = service.encode_lossless_mkv(
"/input/lossless.mp4",
"/output/video.mkv"
)
assert result is True
call_args = mock_execute.call_args[0][0]
assert "-c:v copy" in call_args
assert "-c:a flac" in call_args
@patch.object(LocalEncodingService, "_execute_command_with_fallback")
def test_encode_720p(self, mock_execute):
"""Test 720p encoding."""
mock_execute.return_value = True
service = LocalEncodingService()
result = service.encode_720p(
"/input/lossless.mp4",
"/output/720p.mp4"
)
assert result is True
call_args = mock_execute.call_args
# Should contain scale filter
assert "1280:720" in call_args[0][0] or "1280:720" in call_args[0][1]
class TestLocalEncodingServiceFullPipeline:
"""Test full encoding pipeline."""
@patch.object(LocalEncodingService, "remux_with_instrumental")
@patch.object(LocalEncodingService, "convert_mov_to_mp4")
@patch.object(LocalEncodingService, "encode_lossless_mp4")
@patch.object(LocalEncodingService, "encode_lossy_mp4")
@patch.object(LocalEncodingService, "encode_lossless_mkv")
@patch.object(LocalEncodingService, "encode_720p")
def test_encode_all_formats_success(
self, mock_720p, mock_mkv, mock_lossy, mock_lossless, mock_convert, mock_remux
):
"""Test successful full encoding pipeline."""
mock_remux.return_value = True
mock_convert.return_value = True
mock_lossless.return_value = True
mock_lossy.return_value = True
mock_mkv.return_value = True
mock_720p.return_value = True
service = LocalEncodingService()
config = EncodingConfig(
title_video="/input/title.mov",
karaoke_video="/input/karaoke.mov",
instrumental_audio="/input/instrumental.flac",
output_karaoke_mp4="/output/karaoke.mp4",
output_with_vocals_mp4="/output/with_vocals.mp4",
output_lossless_4k_mp4="/output/lossless_4k.mp4",
output_lossy_4k_mp4="/output/lossy_4k.mp4",
output_lossless_mkv="/output/lossless.mkv",
output_720p_mp4="/output/720p.mp4",
)
result = service.encode_all_formats(config)
assert result.success is True
assert "karaoke_mp4" in result.output_files
assert "lossless_4k_mp4" in result.output_files
assert "720p_mp4" in result.output_files
@patch.object(LocalEncodingService, "remux_with_instrumental")
def test_encode_all_formats_failure_early(self, mock_remux):
"""Test encoding pipeline failure at early step."""
mock_remux.return_value = False
service = LocalEncodingService()
config = EncodingConfig(
title_video="/input/title.mov",
karaoke_video="/input/karaoke.mov",
instrumental_audio="/input/instrumental.flac",
output_karaoke_mp4="/output/karaoke.mp4",
output_lossless_4k_mp4="/output/lossless_4k.mp4",
)
result = service.encode_all_formats(config)
assert result.success is False
assert "Failed to remux" in result.error
def test_encode_all_formats_dry_run(self):
"""Test encoding pipeline in dry run mode."""
service = LocalEncodingService(dry_run=True)
config = EncodingConfig(
title_video="/input/title.mov",
karaoke_video="/input/karaoke.mp4", # Already MP4
instrumental_audio="/input/instrumental.flac",
output_karaoke_mp4="/output/karaoke.mp4",
output_lossless_4k_mp4="/output/lossless_4k.mp4",
output_lossy_4k_mp4="/output/lossy_4k.mp4",
output_lossless_mkv="/output/lossless.mkv",
output_720p_mp4="/output/720p.mp4",
)
result = service.encode_all_formats(config)
# In dry run mode, all operations should "succeed"
assert result.success is True
class TestEncodingConfig:
"""Test EncodingConfig dataclass."""
def test_config_required_fields(self):
"""Test that required fields must be provided."""
config = EncodingConfig(
title_video="/path/title.mov",
karaoke_video="/path/karaoke.mov",
instrumental_audio="/path/audio.flac",
)
assert config.title_video == "/path/title.mov"
assert config.end_video is None # Optional field
def test_config_all_fields(self):
"""Test config with all fields."""
config = EncodingConfig(
title_video="/path/title.mov",
karaoke_video="/path/karaoke.mov",
instrumental_audio="/path/audio.flac",
end_video="/path/end.mov",
output_karaoke_mp4="/output/karaoke.mp4",
output_720p_mp4="/output/720p.mp4",
)
assert config.end_video == "/path/end.mov"
assert config.output_karaoke_mp4 == "/output/karaoke.mp4"
class TestEncodingResult:
"""Test EncodingResult dataclass."""
def test_result_success(self):
"""Test successful result."""
result = EncodingResult(
success=True,
output_files={"key": "/path/file.mp4"}
)
assert result.success is True
assert result.error is None
def test_result_failure(self):
"""Test failure result."""
result = EncodingResult(
success=False,
output_files={},
error="Something went wrong"
)
assert result.success is False
assert result.error == "Something went wrong"
class TestGetLocalEncodingService:
"""Test factory function."""
def test_get_service_creates_instance(self):
"""Test that factory function creates a new instance."""
import backend.services.local_encoding_service as module
module._local_encoding_service = None
service = get_local_encoding_service()
assert service is not None
assert isinstance(service, LocalEncodingService)
def test_get_service_with_dry_run(self):
"""Test factory function with dry run option."""
import backend.services.local_encoding_service as module
module._local_encoding_service = None
service = get_local_encoding_service(dry_run=True)
assert service.dry_run is True
-382
View File
@@ -1,382 +0,0 @@
"""
Tests for PackagingService.
Tests cover:
- Service initialization
- CDG package creation
- TXT package creation
- Dry run mode
- Error handling
"""
import os
import zipfile
import tempfile
import pytest
from unittest.mock import MagicMock, patch
from backend.services.packaging_service import (
PackagingService,
get_packaging_service,
)
class TestPackagingServiceInit:
"""Test service initialization."""
def test_init_default_values(self):
"""Test default initialization."""
service = PackagingService()
assert service.cdg_styles is None
assert service.dry_run is False
assert service.non_interactive is False
def test_init_with_cdg_styles(self):
"""Test initialization with CDG styles."""
styles = {"font_size": 24, "bg_color": "black"}
service = PackagingService(cdg_styles=styles)
assert service.cdg_styles == styles
def test_init_with_dry_run(self):
"""Test initialization with dry run mode."""
service = PackagingService(dry_run=True)
assert service.dry_run is True
def test_init_with_non_interactive(self):
"""Test initialization with non-interactive mode."""
service = PackagingService(non_interactive=True)
assert service.non_interactive is True
class TestPackagingServiceCreateZipFromFiles:
"""Test internal ZIP creation."""
def test_create_zip_from_files(self):
"""Test creating a ZIP file from multiple files."""
with tempfile.TemporaryDirectory() as tmpdir:
# Create test files
file1 = os.path.join(tmpdir, "test1.txt")
file2 = os.path.join(tmpdir, "test2.txt")
zip_path = os.path.join(tmpdir, "output.zip")
with open(file1, "w") as f:
f.write("content1")
with open(file2, "w") as f:
f.write("content2")
service = PackagingService()
service._create_zip_from_files(
zip_path,
[(file1, "test1.txt"), (file2, "test2.txt")]
)
assert os.path.isfile(zip_path)
with zipfile.ZipFile(zip_path, "r") as zf:
names = zf.namelist()
assert "test1.txt" in names
assert "test2.txt" in names
class TestPackagingServiceCDGPackage:
"""Test CDG package creation."""
def test_create_cdg_package_missing_lrc_file(self):
"""Test that missing LRC file raises FileNotFoundError."""
service = PackagingService()
with pytest.raises(FileNotFoundError) as exc_info:
service.create_cdg_package(
lrc_file="/nonexistent/file.lrc",
audio_file="/some/audio.flac",
output_zip_path="/output/test.zip",
artist="Test Artist",
title="Test Title",
)
assert "LRC file not found" in str(exc_info.value)
def test_create_cdg_package_missing_audio_file(self):
"""Test that missing audio file raises FileNotFoundError."""
with tempfile.TemporaryDirectory() as tmpdir:
lrc_file = os.path.join(tmpdir, "test.lrc")
with open(lrc_file, "w") as f:
f.write("[00:00.00]Test lyrics")
service = PackagingService()
with pytest.raises(FileNotFoundError) as exc_info:
service.create_cdg_package(
lrc_file=lrc_file,
audio_file="/nonexistent/audio.flac",
output_zip_path="/output/test.zip",
artist="Test Artist",
title="Test Title",
)
assert "Audio file not found" in str(exc_info.value)
def test_create_cdg_package_no_styles_raises(self):
"""Test that CDG generation without styles raises ValueError."""
with tempfile.TemporaryDirectory() as tmpdir:
lrc_file = os.path.join(tmpdir, "test.lrc")
audio_file = os.path.join(tmpdir, "test.flac")
zip_path = os.path.join(tmpdir, "output.zip")
with open(lrc_file, "w") as f:
f.write("[00:00.00]Test lyrics")
with open(audio_file, "w") as f:
f.write("fake audio")
# Service without CDG styles
service = PackagingService(cdg_styles=None)
with pytest.raises(ValueError) as exc_info:
service.create_cdg_package(
lrc_file=lrc_file,
audio_file=audio_file,
output_zip_path=zip_path,
artist="Test Artist",
title="Test Title",
)
assert "CDG styles configuration is required" in str(exc_info.value)
def test_create_cdg_package_dry_run(self):
"""Test CDG package creation in dry run mode."""
with tempfile.TemporaryDirectory() as tmpdir:
lrc_file = os.path.join(tmpdir, "test.lrc")
audio_file = os.path.join(tmpdir, "test.flac")
zip_path = os.path.join(tmpdir, "output.zip")
with open(lrc_file, "w") as f:
f.write("[00:00.00]Test lyrics")
with open(audio_file, "w") as f:
f.write("fake audio")
service = PackagingService(dry_run=True)
result = service.create_cdg_package(
lrc_file=lrc_file,
audio_file=audio_file,
output_zip_path=zip_path,
artist="Test Artist",
title="Test Title",
)
# In dry run, ZIP should not be created
assert not os.path.isfile(zip_path)
assert result[0] == zip_path
def test_create_cdg_package_existing_files(self):
"""Test CDG package creation with existing MP3 and CDG files."""
with tempfile.TemporaryDirectory() as tmpdir:
lrc_file = os.path.join(tmpdir, "test.lrc")
audio_file = os.path.join(tmpdir, "test.flac")
mp3_file = os.path.join(tmpdir, "test.mp3")
cdg_file = os.path.join(tmpdir, "test.cdg")
zip_path = os.path.join(tmpdir, "output.zip")
# Create all files
with open(lrc_file, "w") as f:
f.write("[00:00.00]Test lyrics")
with open(audio_file, "w") as f:
f.write("fake audio")
with open(mp3_file, "w") as f:
f.write("fake mp3")
with open(cdg_file, "w") as f:
f.write("fake cdg")
service = PackagingService()
result = service.create_cdg_package(
lrc_file=lrc_file,
audio_file=audio_file,
output_zip_path=zip_path,
artist="Test Artist",
title="Test Title",
output_mp3_path=mp3_file,
output_cdg_path=cdg_file,
)
# ZIP should be created from existing files
assert os.path.isfile(zip_path)
assert result[0] == zip_path
assert result[1] == mp3_file
assert result[2] == cdg_file
@patch("lyrics_transcriber.output.cdg.CDGGenerator")
def test_create_cdg_package_with_generator(self, mock_cdg_generator_class):
"""Test CDG package creation using CDGGenerator."""
with tempfile.TemporaryDirectory() as tmpdir:
lrc_file = os.path.join(tmpdir, "test.lrc")
audio_file = os.path.join(tmpdir, "test.flac")
zip_path = os.path.join(tmpdir, "output.zip")
generated_zip = os.path.join(tmpdir, "generated.zip")
with open(lrc_file, "w") as f:
f.write("[00:00.00]Test lyrics")
with open(audio_file, "w") as f:
f.write("fake audio")
# Create the zip file that would be generated
with zipfile.ZipFile(generated_zip, "w") as zf:
zf.writestr("test.mp3", "fake mp3")
zf.writestr("test.cdg", "fake cdg")
mock_generator = MagicMock()
mock_generator.generate_cdg_from_lrc.return_value = (
"test.cdg", "test.mp3", generated_zip
)
mock_cdg_generator_class.return_value = mock_generator
styles = {"font_size": 24}
service = PackagingService(cdg_styles=styles)
result = service.create_cdg_package(
lrc_file=lrc_file,
audio_file=audio_file,
output_zip_path=zip_path,
artist="Test Artist",
title="Test Title",
)
mock_generator.generate_cdg_from_lrc.assert_called_once_with(
lrc_file=lrc_file,
audio_file=audio_file,
title="Test Title",
artist="Test Artist",
cdg_styles=styles,
)
assert os.path.isfile(zip_path)
class TestPackagingServiceTXTPackage:
"""Test TXT package creation."""
def test_create_txt_package_missing_lrc_file(self):
"""Test that missing LRC file raises FileNotFoundError."""
service = PackagingService()
with pytest.raises(FileNotFoundError) as exc_info:
service.create_txt_package(
lrc_file="/nonexistent/file.lrc",
mp3_file="/some/audio.mp3",
output_zip_path="/output/test.zip",
)
assert "LRC file not found" in str(exc_info.value)
def test_create_txt_package_missing_mp3_file(self):
"""Test that missing MP3 file raises FileNotFoundError."""
with tempfile.TemporaryDirectory() as tmpdir:
lrc_file = os.path.join(tmpdir, "test.lrc")
with open(lrc_file, "w") as f:
f.write("[00:00.00]Test lyrics")
service = PackagingService()
with pytest.raises(FileNotFoundError) as exc_info:
service.create_txt_package(
lrc_file=lrc_file,
mp3_file="/nonexistent/audio.mp3",
output_zip_path="/output/test.zip",
)
assert "MP3 file not found" in str(exc_info.value)
def test_create_txt_package_dry_run(self):
"""Test TXT package creation in dry run mode."""
with tempfile.TemporaryDirectory() as tmpdir:
lrc_file = os.path.join(tmpdir, "test.lrc")
mp3_file = os.path.join(tmpdir, "test.mp3")
zip_path = os.path.join(tmpdir, "output.zip")
with open(lrc_file, "w") as f:
f.write("[00:00.00]Test lyrics")
with open(mp3_file, "w") as f:
f.write("fake mp3")
service = PackagingService(dry_run=True)
result = service.create_txt_package(
lrc_file=lrc_file,
mp3_file=mp3_file,
output_zip_path=zip_path,
)
# In dry run, ZIP should not be created
assert not os.path.isfile(zip_path)
assert result[0] == zip_path
@patch("lyrics_converter.LyricsConverter")
def test_create_txt_package_success(self, mock_converter_class):
"""Test successful TXT package creation."""
with tempfile.TemporaryDirectory() as tmpdir:
lrc_file = os.path.join(tmpdir, "test.lrc")
mp3_file = os.path.join(tmpdir, "test.mp3")
zip_path = os.path.join(tmpdir, "output.zip")
txt_path = os.path.join(tmpdir, "output.txt")
with open(lrc_file, "w") as f:
f.write("[00:00.00]Test lyrics")
with open(mp3_file, "w") as f:
f.write("fake mp3")
mock_converter = MagicMock()
mock_converter.convert_file.return_value = "Converted lyrics text"
mock_converter_class.return_value = mock_converter
service = PackagingService()
result = service.create_txt_package(
lrc_file=lrc_file,
mp3_file=mp3_file,
output_zip_path=zip_path,
output_txt_path=txt_path,
)
mock_converter_class.assert_called_once_with(
output_format="txt",
filepath=lrc_file
)
mock_converter.convert_file.assert_called_once()
assert os.path.isfile(zip_path)
assert os.path.isfile(txt_path)
assert result[0] == zip_path
assert result[1] == txt_path
# Verify ZIP contents
with zipfile.ZipFile(zip_path, "r") as zf:
names = zf.namelist()
assert "test.mp3" in names
assert "output.txt" in names
class TestGetPackagingService:
"""Test factory function."""
def test_get_service_creates_instance(self):
"""Test that factory function creates a new instance."""
import backend.services.packaging_service as module
module._packaging_service = None
service = get_packaging_service()
assert service is not None
assert isinstance(service, PackagingService)
def test_get_service_with_cdg_styles(self):
"""Test factory function with CDG styles."""
import backend.services.packaging_service as module
module._packaging_service = None
styles = {"font_size": 24}
service = get_packaging_service(cdg_styles=styles)
assert service.cdg_styles == styles
def test_get_service_with_options(self):
"""Test factory function with additional options."""
import backend.services.packaging_service as module
module._packaging_service = None
service = get_packaging_service(dry_run=True, non_interactive=True)
assert service.dry_run is True
assert service.non_interactive is True
+3 -3
View File
@@ -99,7 +99,7 @@ class TestStylesConfigRequirements:
"karaoke": {
"background_color": "#000000",
"font_path": "", # MUST be string, NOT None
"font": "Noto Sans",
"font": "Arial",
"ass_name": "Default", # REQUIRED
"primary_color": "112, 112, 247, 255",
"secondary_color": "255, 255, 255, 255",
@@ -241,7 +241,7 @@ class TestPreviewStyleLoading:
"background_image": "/original/path/background.png",
"font_path": "/original/path/font.ttf",
"background_color": "#000000",
"font": "Noto Sans",
"font": "Arial",
"ass_name": "Default",
}
}
@@ -308,7 +308,7 @@ class TestPreviewStyleLoading:
# Should have karaoke section with minimal/default values
assert "karaoke" in result_styles
assert result_styles["karaoke"]["background_color"] == "#000000"
assert result_styles["karaoke"]["font"] == "Noto Sans"
assert result_styles["karaoke"]["font"] == "Arial"
# Minimal styles have background_image as None (default)
assert result_styles["karaoke"].get("background_image") is None
@@ -1,742 +0,0 @@
"""
Tests for Video Worker Orchestrator.
Tests cover:
- OrchestratorConfig and OrchestratorResult dataclasses
- VideoWorkerOrchestrator initialization
- Individual stage methods
- Full pipeline execution
- Error handling and recovery
"""
import os
import tempfile
import pytest
from unittest.mock import MagicMock, patch, AsyncMock
from dataclasses import asdict
from backend.workers.video_worker_orchestrator import (
OrchestratorConfig,
OrchestratorResult,
VideoWorkerOrchestrator,
create_orchestrator_config_from_job,
)
class TestOrchestratorConfig:
"""Test OrchestratorConfig dataclass."""
def test_required_fields(self):
"""Test that required fields must be provided."""
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",
)
assert config.job_id == "test-job"
assert config.artist == "Test Artist"
assert config.encoding_backend == "auto"
def test_default_values(self):
"""Test default values for optional fields."""
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",
)
assert config.enable_cdg is False
assert config.enable_txt is False
assert config.enable_youtube_upload is False
assert config.dry_run is False
assert config.non_interactive is True
assert config.end_video_path is None
def test_all_fields(self):
"""Test all fields including optional ones."""
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",
end_video_path="/path/end.mov",
enable_cdg=True,
enable_txt=True,
enable_youtube_upload=True,
brand_prefix="TEST",
discord_webhook_url="https://discord.com/api/webhooks/123/abc",
encoding_backend="gce",
)
assert config.enable_cdg is True
assert config.encoding_backend == "gce"
assert config.discord_webhook_url is not None
class TestOrchestratorResult:
"""Test OrchestratorResult dataclass."""
def test_success_result(self):
"""Test successful result."""
result = OrchestratorResult(
success=True,
final_video="/output/video.mp4",
brand_code="TEST-1234",
youtube_url="https://youtube.com/watch?v=test",
)
assert result.success is True
assert result.error_message is None
assert result.brand_code == "TEST-1234"
def test_failure_result(self):
"""Test failure result."""
result = OrchestratorResult(
success=False,
error_message="Encoding failed",
)
assert result.success is False
assert result.error_message == "Encoding failed"
assert result.final_video is None
def test_all_output_files(self):
"""Test all output file fields."""
result = OrchestratorResult(
success=True,
final_video="/output/lossless.mp4",
final_video_mkv="/output/lossless.mkv",
final_video_lossy="/output/lossy.mp4",
final_video_720p="/output/720p.mp4",
final_karaoke_cdg_zip="/output/cdg.zip",
final_karaoke_txt_zip="/output/txt.zip",
)
assert result.final_video == "/output/lossless.mp4"
assert result.final_video_mkv == "/output/lossless.mkv"
class TestVideoWorkerOrchestratorInit:
"""Test VideoWorkerOrchestrator initialization."""
def test_init_with_config(self):
"""Test initialization with config."""
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",
)
orchestrator = VideoWorkerOrchestrator(config)
assert orchestrator.config == config
assert orchestrator.result.success is False
def test_init_with_job_manager(self):
"""Test initialization with job manager."""
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",
)
job_manager = MagicMock()
orchestrator = VideoWorkerOrchestrator(config, job_manager=job_manager)
assert orchestrator.job_manager == job_manager
class TestVideoWorkerOrchestratorServices:
"""Test service lazy-loading."""
def test_get_encoding_backend(self):
"""Test encoding backend lazy loading."""
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",
encoding_backend="local",
)
orchestrator = VideoWorkerOrchestrator(config)
with patch("backend.services.encoding_interface.get_encoding_backend") as mock_get:
mock_backend = MagicMock()
mock_backend.name = "local"
mock_get.return_value = mock_backend
backend = orchestrator._get_encoding_backend()
assert backend == mock_backend
mock_get.assert_called_once()
def test_get_packaging_service(self):
"""Test packaging service lazy loading."""
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",
cdg_styles={"background_color": "black"},
)
orchestrator = VideoWorkerOrchestrator(config)
with patch("backend.services.packaging_service.PackagingService") as MockService:
mock_service = MagicMock()
MockService.return_value = mock_service
service = orchestrator._get_packaging_service()
assert service == mock_service
MockService.assert_called_once()
def test_get_youtube_service(self):
"""Test YouTube service lazy loading."""
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",
youtube_credentials={"token": "test"},
)
orchestrator = VideoWorkerOrchestrator(config)
with patch("backend.services.youtube_upload_service.YouTubeUploadService") as MockService:
mock_service = MagicMock()
MockService.return_value = mock_service
service = orchestrator._get_youtube_service()
assert service == mock_service
MockService.assert_called_once()
def test_get_discord_service(self):
"""Test Discord service lazy loading."""
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",
discord_webhook_url="https://discord.com/api/webhooks/123/abc",
)
orchestrator = VideoWorkerOrchestrator(config)
with patch("backend.services.discord_service.DiscordNotificationService") as MockService:
mock_service = MagicMock()
MockService.return_value = mock_service
service = orchestrator._get_discord_service()
assert service == mock_service
MockService.assert_called_once()
class TestVideoWorkerOrchestratorPackaging:
"""Test packaging stage."""
@pytest.mark.asyncio
async def test_run_packaging_no_lrc(self):
"""Test packaging stage with no LRC file."""
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",
enable_cdg=True,
lrc_file_path=None,
)
orchestrator = VideoWorkerOrchestrator(config)
# Should not raise, just skip
await orchestrator._run_packaging()
assert orchestrator.result.final_karaoke_cdg_zip is None
@pytest.mark.asyncio
async def test_run_packaging_cdg(self):
"""Test CDG packaging."""
with tempfile.TemporaryDirectory() as temp_dir:
lrc_file = os.path.join(temp_dir, "test.lrc")
audio_file = os.path.join(temp_dir, "test.flac")
# Create dummy files
with open(lrc_file, "w") as f:
f.write("[00:00.00]Test lyrics")
with open(audio_file, "w") as f:
f.write("dummy audio")
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=audio_file,
lrc_file_path=lrc_file,
output_dir=temp_dir,
enable_cdg=True,
cdg_styles={"background_color": "black"},
)
orchestrator = VideoWorkerOrchestrator(config)
with patch.object(orchestrator, "_get_packaging_service") as mock_get:
mock_service = MagicMock()
mock_service.create_cdg_package.return_value = (
f"{temp_dir}/cdg.zip",
f"{temp_dir}/test.mp3",
f"{temp_dir}/test.cdg",
)
mock_get.return_value = mock_service
await orchestrator._run_packaging()
mock_service.create_cdg_package.assert_called_once()
assert orchestrator.result.final_karaoke_cdg_zip == f"{temp_dir}/cdg.zip"
class TestVideoWorkerOrchestratorEncoding:
"""Test encoding stage."""
@pytest.mark.asyncio
async def test_run_encoding_success(self):
"""Test successful encoding."""
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",
)
orchestrator = VideoWorkerOrchestrator(config)
with patch.object(orchestrator, "_get_encoding_backend") as mock_get:
from backend.services.encoding_interface import EncodingOutput
mock_backend = MagicMock()
mock_backend.name = "local"
mock_backend.encode = AsyncMock(return_value=EncodingOutput(
success=True,
lossless_4k_mp4_path="/output/lossless.mp4",
lossy_4k_mp4_path="/output/lossy.mp4",
lossy_720p_mp4_path="/output/720p.mp4",
lossless_mkv_path="/output/lossless.mkv",
encoding_time_seconds=120.5,
encoding_backend="local",
))
mock_get.return_value = mock_backend
await orchestrator._run_encoding()
mock_backend.encode.assert_called_once()
assert orchestrator.result.final_video == "/output/lossless.mp4"
assert orchestrator.result.final_video_720p == "/output/720p.mp4"
assert orchestrator.result.encoding_time_seconds == 120.5
def test_encoding_input_gcs_paths_pattern(self):
"""Test that EncodingInput.options contains proper GCS paths structure.
This test verifies the GCS path construction pattern that GCE encoding
requires. It tests the structure without running _run_encoding().
This would have caught: 'GCE encoding requires input_gcs_path and
output_gcs_path in options' error when the orchestrator didn't pass
the required paths for GCE encoding.
"""
from backend.services.encoding_interface import EncodingInput
# Test that EncodingInput can hold GCS paths in options
# This mirrors what the orchestrator should build
job_id = "test-job-123"
bucket = "test-bucket"
input_gcs_path = f"gs://{bucket}/jobs/{job_id}/"
output_gcs_path = f"gs://{bucket}/jobs/{job_id}/finals/"
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",
brand_code="TEST-001",
output_dir="/output",
options={
"input_gcs_path": input_gcs_path,
"output_gcs_path": output_gcs_path,
},
)
# Verify the structure that GCEEncodingBackend expects
assert "input_gcs_path" in encoding_input.options, \
"EncodingInput.options must include input_gcs_path for GCE encoding"
assert "output_gcs_path" in encoding_input.options, \
"EncodingInput.options must include output_gcs_path for GCE encoding"
# Verify path format
assert encoding_input.options["input_gcs_path"].startswith("gs://")
assert encoding_input.options["output_gcs_path"].startswith("gs://")
assert job_id in encoding_input.options["input_gcs_path"]
assert job_id in encoding_input.options["output_gcs_path"]
@pytest.mark.asyncio
async def test_run_encoding_failure(self):
"""Test encoding failure."""
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",
)
orchestrator = VideoWorkerOrchestrator(config)
with patch.object(orchestrator, "_get_encoding_backend") as mock_get:
from backend.services.encoding_interface import EncodingOutput
mock_backend = MagicMock()
mock_backend.name = "local"
mock_backend.encode = AsyncMock(return_value=EncodingOutput(
success=False,
error_message="FFmpeg failed",
encoding_backend="local",
))
mock_get.return_value = mock_backend
with pytest.raises(Exception) as exc_info:
await orchestrator._run_encoding()
assert "Encoding failed" in str(exc_info.value)
class TestVideoWorkerOrchestratorOrganization:
"""Test organization stage."""
@pytest.mark.asyncio
async def test_run_organization_keep_brand_code(self):
"""Test organization with existing brand code."""
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",
keep_brand_code="NOMAD-9999",
)
orchestrator = VideoWorkerOrchestrator(config)
await orchestrator._run_organization()
assert orchestrator.result.brand_code == "NOMAD-9999"
@pytest.mark.asyncio
async def test_run_organization_generate_brand_code(self):
"""Test brand code generation from Dropbox."""
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",
dropbox_path="/Karaoke/Tracks",
brand_prefix="TEST",
)
orchestrator = VideoWorkerOrchestrator(config)
with patch("backend.services.dropbox_service.get_dropbox_service") as mock_get:
mock_dropbox = MagicMock()
mock_dropbox.is_configured = True
mock_dropbox.get_next_brand_code.return_value = "TEST-0001"
mock_get.return_value = mock_dropbox
await orchestrator._run_organization()
assert orchestrator.result.brand_code == "TEST-0001"
class TestVideoWorkerOrchestratorDistribution:
"""Test distribution stage."""
@pytest.mark.asyncio
async def test_upload_to_youtube(self):
"""Test YouTube upload."""
with tempfile.TemporaryDirectory() as temp_dir:
video_file = os.path.join(temp_dir, "test.mp4")
with open(video_file, "w") as f:
f.write("dummy video")
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",
enable_youtube_upload=True,
youtube_credentials={"token": "test"},
)
orchestrator = VideoWorkerOrchestrator(config)
orchestrator.result.final_video_lossy = video_file
with patch.object(orchestrator, "_get_youtube_service") as mock_get:
mock_service = MagicMock()
mock_service.upload_video.return_value = (
"video123",
"https://youtube.com/watch?v=video123"
)
mock_get.return_value = mock_service
await orchestrator._upload_to_youtube()
mock_service.upload_video.assert_called_once()
assert orchestrator.result.youtube_url == "https://youtube.com/watch?v=video123"
@pytest.mark.asyncio
async def test_upload_to_dropbox(self):
"""Test Dropbox upload."""
with tempfile.TemporaryDirectory() as temp_dir:
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=temp_dir,
dropbox_path="/Karaoke/Tracks",
brand_prefix="TEST",
)
orchestrator = VideoWorkerOrchestrator(config)
orchestrator.result.brand_code = "TEST-0001"
with patch("backend.services.dropbox_service.get_dropbox_service") as mock_get:
mock_dropbox = MagicMock()
mock_dropbox.is_configured = True
mock_dropbox.create_shared_link.return_value = "https://dropbox.com/link"
mock_get.return_value = mock_dropbox
await orchestrator._upload_to_dropbox()
mock_dropbox.upload_folder.assert_called_once()
assert orchestrator.result.dropbox_link == "https://dropbox.com/link"
class TestVideoWorkerOrchestratorNotifications:
"""Test notifications stage."""
@pytest.mark.asyncio
async def test_run_notifications_with_youtube_url(self):
"""Test Discord notification with YouTube URL."""
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",
discord_webhook_url="https://discord.com/api/webhooks/123/abc",
)
orchestrator = VideoWorkerOrchestrator(config)
orchestrator.result.youtube_url = "https://youtube.com/watch?v=test"
with patch.object(orchestrator, "_get_discord_service") as mock_get:
mock_service = MagicMock()
mock_service.post_video_notification.return_value = True
mock_get.return_value = mock_service
await orchestrator._run_notifications()
mock_service.post_video_notification.assert_called_once_with(
"https://youtube.com/watch?v=test"
)
@pytest.mark.asyncio
async def test_run_notifications_no_youtube_url(self):
"""Test notification skipped without YouTube URL."""
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",
discord_webhook_url="https://discord.com/api/webhooks/123/abc",
)
orchestrator = VideoWorkerOrchestrator(config)
# No youtube_url set
with patch.object(orchestrator, "_get_discord_service") as mock_get:
mock_service = MagicMock()
mock_get.return_value = mock_service
await orchestrator._run_notifications()
mock_service.post_video_notification.assert_not_called()
class TestVideoWorkerOrchestratorFullPipeline:
"""Test full pipeline execution."""
@pytest.mark.asyncio
async def test_run_full_pipeline_success(self):
"""Test successful full pipeline."""
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",
enable_cdg=True, # Enable to trigger packaging stage
)
orchestrator = VideoWorkerOrchestrator(config)
# Mock all stages
with patch.object(orchestrator, "_run_packaging", new_callable=AsyncMock) as mock_packaging, \
patch.object(orchestrator, "_run_encoding", new_callable=AsyncMock) as mock_encoding, \
patch.object(orchestrator, "_run_organization", new_callable=AsyncMock) as mock_org, \
patch.object(orchestrator, "_run_distribution", new_callable=AsyncMock) as mock_dist, \
patch.object(orchestrator, "_run_notifications", new_callable=AsyncMock) as mock_notify:
result = await orchestrator.run()
assert result.success is True
mock_packaging.assert_called_once()
mock_encoding.assert_called_once()
mock_org.assert_called_once()
mock_dist.assert_called_once()
mock_notify.assert_called_once()
@pytest.mark.asyncio
async def test_run_pipeline_skips_packaging_when_disabled(self):
"""Test pipeline skips packaging when CDG/TXT disabled."""
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",
enable_cdg=False,
enable_txt=False,
)
orchestrator = VideoWorkerOrchestrator(config)
# Mock all stages
with patch.object(orchestrator, "_run_packaging", new_callable=AsyncMock) as mock_packaging, \
patch.object(orchestrator, "_run_encoding", new_callable=AsyncMock) as mock_encoding, \
patch.object(orchestrator, "_run_organization", new_callable=AsyncMock), \
patch.object(orchestrator, "_run_distribution", new_callable=AsyncMock), \
patch.object(orchestrator, "_run_notifications", new_callable=AsyncMock):
result = await orchestrator.run()
assert result.success is True
mock_packaging.assert_not_called()
mock_encoding.assert_called_once()
@pytest.mark.asyncio
async def test_run_full_pipeline_encoding_failure(self):
"""Test pipeline failure during encoding."""
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",
)
orchestrator = VideoWorkerOrchestrator(config)
with patch.object(orchestrator, "_run_packaging", new_callable=AsyncMock), \
patch.object(orchestrator, "_run_encoding", new_callable=AsyncMock) as mock_encoding, \
patch.object(orchestrator, "_run_organization", new_callable=AsyncMock) as mock_org:
mock_encoding.side_effect = Exception("Encoding failed")
result = await orchestrator.run()
assert result.success is False
assert "Encoding failed" in result.error_message
mock_org.assert_not_called()
class TestCreateOrchestratorConfigFromJob:
"""Test helper function for creating config from job."""
def test_create_config_from_job(self):
"""Test creating config from a job object."""
job = MagicMock()
job.job_id = "test-123"
job.artist = "Test Artist"
job.title = "Test Title"
job.state_data = {"instrumental_selection": "clean"}
job.enable_cdg = True
job.enable_txt = False
job.enable_youtube_upload = True
job.brand_prefix = "NOMAD"
job.discord_webhook_url = "https://discord.com/api/webhooks/123/abc"
job.youtube_description_template = "Test description"
job.dropbox_path = "/Karaoke"
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",
youtube_credentials={"token": "test"},
cdg_styles={"background": "black"},
)
assert config.job_id == "test-123"
assert config.artist == "Test Artist"
assert config.title == "Test Title"
assert config.enable_cdg is True
assert config.enable_youtube_upload is True
assert config.title_video_path == "/tmp/test/Test Artist - Test Title (Title).mov"
assert config.instrumental_audio_path == "/tmp/test/Test Artist - Test Title (Instrumental Clean).flac"
def test_create_config_from_job_with_existing_instrumental(self):
"""Test config with user-provided instrumental."""
job = MagicMock()
job.job_id = "test-123"
job.artist = "Test Artist"
job.title = "Test Title"
job.state_data = {"instrumental_selection": "custom"}
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 = "gs://bucket/instrumental.mp3"
config = create_orchestrator_config_from_job(
job=job,
temp_dir="/tmp/test",
)
assert config.instrumental_audio_path == "/tmp/test/Test Artist - Test Title (Instrumental User).mp3"
+2 -139
View File
@@ -970,147 +970,10 @@ class TestBackingVocalsAnalysis:
def test_analysis_service_can_be_instantiated(self):
"""Test that AudioAnalysisService can be instantiated."""
from backend.services.audio_analysis_service import AudioAnalysisService
mock_storage = MagicMock()
service = AudioAnalysisService(storage_service=mock_storage)
assert service is not None
assert service.storage_service == mock_storage
class TestModelNamesStorage:
"""Tests for model names storage in audio_worker.
These tests verify that model names are stored in job state_data
for use by video_worker in distribution directory preparation.
"""
def test_effective_model_names_defaults(self):
"""Test that default model names are used when not specified on job."""
from backend.workers.audio_worker import (
DEFAULT_CLEAN_MODEL,
DEFAULT_BACKING_MODELS,
DEFAULT_OTHER_MODELS,
)
# Simulate the logic from process_audio_separation
job_clean_model = None
job_backing_models = None
job_other_models = None
effective_model_names = {
'clean_instrumental_model': job_clean_model or DEFAULT_CLEAN_MODEL,
'backing_vocals_models': job_backing_models or DEFAULT_BACKING_MODELS,
'other_stems_models': job_other_models or DEFAULT_OTHER_MODELS,
}
assert effective_model_names['clean_instrumental_model'] == DEFAULT_CLEAN_MODEL
assert effective_model_names['backing_vocals_models'] == DEFAULT_BACKING_MODELS
assert effective_model_names['other_stems_models'] == DEFAULT_OTHER_MODELS
def test_effective_model_names_custom(self):
"""Test that custom model names override defaults."""
from backend.workers.audio_worker import (
DEFAULT_CLEAN_MODEL,
DEFAULT_BACKING_MODELS,
DEFAULT_OTHER_MODELS,
)
custom_clean = "custom_clean_model.ckpt"
custom_backing = ["custom_backing.ckpt"]
custom_other = ["custom_demucs.yaml"]
# Simulate the logic from process_audio_separation
effective_model_names = {
'clean_instrumental_model': custom_clean or DEFAULT_CLEAN_MODEL,
'backing_vocals_models': custom_backing or DEFAULT_BACKING_MODELS,
'other_stems_models': custom_other or DEFAULT_OTHER_MODELS,
}
assert effective_model_names['clean_instrumental_model'] == custom_clean
assert effective_model_names['backing_vocals_models'] == custom_backing
assert effective_model_names['other_stems_models'] == custom_other
class TestDistributionDirectoryPreparation:
"""Tests for _prepare_distribution_directory in video_worker.
These tests verify that the distribution directory is prepared with:
- stems/ subfolder containing all audio stems with model names
- lyrics/ subfolder containing intermediate lyrics files
- Properly named instrumentals at root level
"""
def test_distribution_directory_creates_stems_folder(self, tmp_path):
"""Test that stems directory is created."""
stems_dir = tmp_path / "stems"
stems_dir.mkdir()
assert stems_dir.exists()
assert stems_dir.is_dir()
def test_distribution_directory_creates_lyrics_folder(self, tmp_path):
"""Test that lyrics directory is created."""
lyrics_dir = tmp_path / "lyrics"
lyrics_dir.mkdir()
assert lyrics_dir.exists()
assert lyrics_dir.is_dir()
def test_instrumental_naming_with_model(self):
"""Test that instrumental files are named with model names."""
base_name = "Artist - Song"
clean_model = "model_bs_roformer_ep_317_sdr_12.9755.ckpt"
backing_model = "mel_band_roformer_karaoke_aufr33_viperx_sdr_10.1956.ckpt"
clean_instrumental_name = f"{base_name} (Instrumental {clean_model}).flac"
backing_instrumental_name = f"{base_name} (Instrumental +BV {backing_model}).flac"
# Verify expected format
assert "model_bs_roformer" in clean_instrumental_name
assert "+BV" in backing_instrumental_name
assert backing_model in backing_instrumental_name
def test_stem_naming_convention(self):
"""Test that stems are named with proper model suffixes."""
base_name = "Artist - Song"
clean_model = "model_bs_roformer_ep_317_sdr_12.9755.ckpt"
backing_model = "mel_band_roformer_karaoke_aufr33_viperx_sdr_10.1956.ckpt"
other_model = "htdemucs_6s.yaml"
# Expected stem filenames
expected_stems = {
'vocals_clean': f"{base_name} (Vocals {clean_model}).flac",
'lead_vocals': f"{base_name} (Lead Vocals {backing_model}).flac",
'backing_vocals': f"{base_name} (Backing Vocals {backing_model}).flac",
'bass': f"{base_name} (Bass {other_model}).flac",
'drums': f"{base_name} (Drums {other_model}).flac",
}
# Verify naming convention
for _key, name in expected_stems.items():
assert ".flac" in name
assert base_name in name
def test_simplified_instrumental_cleanup(self, tmp_path):
"""Test that simplified instrumental names are cleaned up."""
base_name = "Artist - Song"
# Create simplified-named files (as created by _setup_working_directory)
simplified_clean = tmp_path / f"{base_name} (Instrumental Clean).flac"
simplified_backing = tmp_path / f"{base_name} (Instrumental Backing).flac"
simplified_clean.write_text("fake")
simplified_backing.write_text("fake")
# Verify they exist
assert simplified_clean.exists()
assert simplified_backing.exists()
# Simulate cleanup
simplified_clean.unlink()
simplified_backing.unlink()
# Verify they're removed
assert not simplified_clean.exists()
assert not simplified_backing.exists()
@@ -1,568 +0,0 @@
"""
Tests for YouTubeUploadService.
Tests cover:
- Authentication with pre-stored credentials
- Authentication with client secrets file
- Duplicate video detection (exact and fuzzy matching)
- Video deletion
- Video upload with metadata and thumbnail
- Title truncation
- Dry run mode
"""
import os
import pytest
from unittest.mock import MagicMock, patch, mock_open
from backend.services.youtube_upload_service import YouTubeUploadService, get_youtube_upload_service
class TestYouTubeUploadServiceInit:
"""Test service initialization."""
def test_init_with_credentials(self):
"""Test initialization with pre-stored credentials."""
creds = {
"token": "test_token",
"refresh_token": "test_refresh",
"token_uri": "https://oauth2.googleapis.com/token",
"client_id": "test_client_id",
"client_secret": "test_secret",
}
service = YouTubeUploadService(
credentials=creds,
non_interactive=True
)
assert service.credentials == creds
assert service.non_interactive is True
def test_init_with_client_secrets(self):
"""Test initialization with client secrets file."""
service = YouTubeUploadService(
client_secrets_file="/path/to/secrets.json"
)
assert service.client_secrets_file == "/path/to/secrets.json"
assert service.non_interactive is False
def test_init_default_values(self):
"""Test default values on initialization."""
service = YouTubeUploadService()
assert service.credentials is None
assert service.client_secrets_file is None
assert service.non_interactive is False
assert service.server_side_mode is False
assert service.dry_run is False
class TestYouTubeUploadServiceAuthentication:
"""Test authentication methods."""
@patch("googleapiclient.discovery.build")
@patch("google.oauth2.credentials.Credentials")
@patch("google.auth.transport.requests.Request")
def test_authenticate_with_prestored_credentials(
self, mock_request, mock_credentials_class, mock_build
):
"""Test authentication using pre-stored credentials."""
# Setup mocks
mock_creds = MagicMock()
mock_creds.expired = False
mock_credentials_class.return_value = mock_creds
mock_youtube = MagicMock()
mock_build.return_value = mock_youtube
creds = {
"token": "test_token",
"refresh_token": "test_refresh",
"token_uri": "https://oauth2.googleapis.com/token",
"client_id": "test_client_id",
"client_secret": "test_secret",
"scopes": ["https://www.googleapis.com/auth/youtube"],
}
service = YouTubeUploadService(credentials=creds, non_interactive=True)
# Access youtube_service to trigger authentication
result = service.youtube_service
assert result == mock_youtube
mock_credentials_class.assert_called_once()
mock_build.assert_called_once_with('youtube', 'v3', credentials=mock_creds)
@patch("googleapiclient.discovery.build")
@patch("google.oauth2.credentials.Credentials")
@patch("google.auth.transport.requests.Request")
def test_authenticate_refreshes_expired_token(
self, mock_request, mock_credentials_class, mock_build
):
"""Test that expired tokens are refreshed."""
mock_creds = MagicMock()
mock_creds.expired = True
mock_creds.refresh_token = "test_refresh"
mock_credentials_class.return_value = mock_creds
creds = {
"token": "expired_token",
"refresh_token": "test_refresh",
"token_uri": "https://oauth2.googleapis.com/token",
"client_id": "test_client_id",
"client_secret": "test_secret",
}
service = YouTubeUploadService(credentials=creds, non_interactive=True)
service.youtube_service
mock_creds.refresh.assert_called_once()
def test_authenticate_non_interactive_no_credentials_raises(self):
"""Test that non-interactive mode without credentials raises error."""
service = YouTubeUploadService(non_interactive=True)
with pytest.raises(Exception) as exc_info:
service._authenticate()
assert "non-interactive mode" in str(exc_info.value).lower()
class TestYouTubeUploadServiceChannelId:
"""Test channel ID retrieval."""
@patch("googleapiclient.discovery.build")
@patch("google.oauth2.credentials.Credentials")
@patch("google.auth.transport.requests.Request")
def test_get_channel_id_success(
self, mock_request, mock_credentials_class, mock_build
):
"""Test successful channel ID retrieval."""
mock_creds = MagicMock()
mock_creds.expired = False
mock_credentials_class.return_value = mock_creds
mock_youtube = MagicMock()
mock_channels = MagicMock()
mock_list = MagicMock()
mock_list.execute.return_value = {
"items": [{"id": "UC123456"}]
}
mock_channels.list.return_value = mock_list
mock_youtube.channels.return_value = mock_channels
mock_build.return_value = mock_youtube
creds = {"token": "test", "refresh_token": "test", "token_uri": "uri",
"client_id": "id", "client_secret": "secret"}
service = YouTubeUploadService(credentials=creds, non_interactive=True)
channel_id = service.get_channel_id()
assert channel_id == "UC123456"
@patch("googleapiclient.discovery.build")
@patch("google.oauth2.credentials.Credentials")
@patch("google.auth.transport.requests.Request")
def test_get_channel_id_no_items(
self, mock_request, mock_credentials_class, mock_build
):
"""Test channel ID returns None when no items found."""
mock_creds = MagicMock()
mock_creds.expired = False
mock_credentials_class.return_value = mock_creds
mock_youtube = MagicMock()
mock_channels = MagicMock()
mock_list = MagicMock()
mock_list.execute.return_value = {"items": []}
mock_channels.list.return_value = mock_list
mock_youtube.channels.return_value = mock_channels
mock_build.return_value = mock_youtube
creds = {"token": "test", "refresh_token": "test", "token_uri": "uri",
"client_id": "id", "client_secret": "secret"}
service = YouTubeUploadService(credentials=creds, non_interactive=True)
channel_id = service.get_channel_id()
assert channel_id is None
class TestYouTubeUploadServiceDuplicateCheck:
"""Test duplicate video detection."""
@patch("googleapiclient.discovery.build")
@patch("google.oauth2.credentials.Credentials")
@patch("google.auth.transport.requests.Request")
def test_check_duplicate_exact_match_found(
self, mock_request, mock_credentials_class, mock_build
):
"""Test duplicate detection with exact match in server mode."""
mock_creds = MagicMock()
mock_creds.expired = False
mock_credentials_class.return_value = mock_creds
mock_youtube = MagicMock()
# Mock channels().list() for get_channel_id
mock_channels = MagicMock()
mock_channels_list = MagicMock()
mock_channels_list.execute.return_value = {"items": [{"id": "UC123456"}]}
mock_channels.list.return_value = mock_channels_list
mock_youtube.channels.return_value = mock_channels
# Mock search().list() for duplicate check
mock_search = MagicMock()
mock_search_list = MagicMock()
mock_search_list.execute.return_value = {
"items": [{
"id": {"videoId": "VIDEO123"},
"snippet": {
"channelId": "UC123456",
"title": "Test Artist - Test Song (Karaoke)"
}
}]
}
mock_search.list.return_value = mock_search_list
mock_youtube.search.return_value = mock_search
mock_build.return_value = mock_youtube
creds = {"token": "test", "refresh_token": "test", "token_uri": "uri",
"client_id": "id", "client_secret": "secret"}
service = YouTubeUploadService(
credentials=creds,
non_interactive=True,
server_side_mode=True
)
exists, video_id, video_url = service.check_duplicate(
"Test Artist - Test Song (Karaoke)"
)
assert exists is True
assert video_id == "VIDEO123"
assert "VIDEO123" in video_url
@patch("googleapiclient.discovery.build")
@patch("google.oauth2.credentials.Credentials")
@patch("google.auth.transport.requests.Request")
def test_check_duplicate_no_match(
self, mock_request, mock_credentials_class, mock_build
):
"""Test duplicate detection when no match found."""
mock_creds = MagicMock()
mock_creds.expired = False
mock_credentials_class.return_value = mock_creds
mock_youtube = MagicMock()
mock_channels = MagicMock()
mock_channels_list = MagicMock()
mock_channels_list.execute.return_value = {"items": [{"id": "UC123456"}]}
mock_channels.list.return_value = mock_channels_list
mock_youtube.channels.return_value = mock_channels
mock_search = MagicMock()
mock_search_list = MagicMock()
mock_search_list.execute.return_value = {"items": []}
mock_search.list.return_value = mock_search_list
mock_youtube.search.return_value = mock_search
mock_build.return_value = mock_youtube
creds = {"token": "test", "refresh_token": "test", "token_uri": "uri",
"client_id": "id", "client_secret": "secret"}
service = YouTubeUploadService(credentials=creds, non_interactive=True)
exists, video_id, video_url = service.check_duplicate("Some Title")
assert exists is False
assert video_id is None
assert video_url is None
@patch("googleapiclient.discovery.build")
@patch("google.oauth2.credentials.Credentials")
@patch("google.auth.transport.requests.Request")
def test_check_duplicate_skips_other_channels(
self, mock_request, mock_credentials_class, mock_build
):
"""Test that videos from other channels are skipped."""
mock_creds = MagicMock()
mock_creds.expired = False
mock_credentials_class.return_value = mock_creds
mock_youtube = MagicMock()
mock_channels = MagicMock()
mock_channels_list = MagicMock()
mock_channels_list.execute.return_value = {"items": [{"id": "UC123456"}]}
mock_channels.list.return_value = mock_channels_list
mock_youtube.channels.return_value = mock_channels
# Return video from different channel
mock_search = MagicMock()
mock_search_list = MagicMock()
mock_search_list.execute.return_value = {
"items": [{
"id": {"videoId": "VIDEO123"},
"snippet": {
"channelId": "UC_DIFFERENT", # Different channel
"title": "Test Title"
}
}]
}
mock_search.list.return_value = mock_search_list
mock_youtube.search.return_value = mock_search
mock_build.return_value = mock_youtube
creds = {"token": "test", "refresh_token": "test", "token_uri": "uri",
"client_id": "id", "client_secret": "secret"}
service = YouTubeUploadService(credentials=creds, non_interactive=True)
exists, video_id, video_url = service.check_duplicate("Test Title")
assert exists is False
class TestYouTubeUploadServiceDelete:
"""Test video deletion."""
@patch("googleapiclient.discovery.build")
@patch("google.oauth2.credentials.Credentials")
@patch("google.auth.transport.requests.Request")
def test_delete_video_success(
self, mock_request, mock_credentials_class, mock_build
):
"""Test successful video deletion."""
mock_creds = MagicMock()
mock_creds.expired = False
mock_credentials_class.return_value = mock_creds
mock_youtube = MagicMock()
mock_videos = MagicMock()
mock_delete = MagicMock()
mock_delete.execute.return_value = None
mock_videos.delete.return_value = mock_delete
mock_youtube.videos.return_value = mock_videos
mock_build.return_value = mock_youtube
creds = {"token": "test", "refresh_token": "test", "token_uri": "uri",
"client_id": "id", "client_secret": "secret"}
service = YouTubeUploadService(credentials=creds, non_interactive=True)
result = service.delete_video("VIDEO123")
assert result is True
mock_videos.delete.assert_called_once_with(id="VIDEO123")
@patch("googleapiclient.discovery.build")
@patch("google.oauth2.credentials.Credentials")
@patch("google.auth.transport.requests.Request")
def test_delete_video_failure(
self, mock_request, mock_credentials_class, mock_build
):
"""Test video deletion failure handling."""
mock_creds = MagicMock()
mock_creds.expired = False
mock_credentials_class.return_value = mock_creds
mock_youtube = MagicMock()
mock_videos = MagicMock()
mock_delete = MagicMock()
mock_delete.execute.side_effect = Exception("API Error")
mock_videos.delete.return_value = mock_delete
mock_youtube.videos.return_value = mock_videos
mock_build.return_value = mock_youtube
creds = {"token": "test", "refresh_token": "test", "token_uri": "uri",
"client_id": "id", "client_secret": "secret"}
service = YouTubeUploadService(credentials=creds, non_interactive=True)
result = service.delete_video("VIDEO123")
assert result is False
def test_delete_video_dry_run(self):
"""Test video deletion in dry run mode."""
service = YouTubeUploadService(dry_run=True)
result = service.delete_video("VIDEO123")
assert result is True
class TestYouTubeUploadServiceTitleTruncation:
"""Test title truncation."""
def test_truncate_title_short_title(self):
"""Test that short titles are not truncated."""
title = "Short Title"
result = YouTubeUploadService.truncate_title(title)
assert result == title
def test_truncate_title_exact_length(self):
"""Test title at exact max length."""
title = "A" * 95
result = YouTubeUploadService.truncate_title(title, max_length=95)
assert result == title
assert len(result) == 95
def test_truncate_title_long_title(self):
"""Test that long titles are truncated at word boundary."""
title = "This is a very long title that exceeds the maximum length and needs to be truncated properly at a word boundary"
result = YouTubeUploadService.truncate_title(title, max_length=50)
assert len(result) <= 50
assert result.endswith("...")
def test_truncate_title_no_space(self):
"""Test truncation of title without spaces."""
title = "A" * 100
result = YouTubeUploadService.truncate_title(title, max_length=50)
assert len(result) <= 50
class TestYouTubeUploadServiceUpload:
"""Test video upload."""
@patch("googleapiclient.http.MediaFileUpload")
@patch("googleapiclient.discovery.build")
@patch("google.oauth2.credentials.Credentials")
@patch("google.auth.transport.requests.Request")
def test_upload_video_success(
self, mock_request, mock_credentials_class, mock_build, mock_media_upload
):
"""Test successful video upload."""
mock_creds = MagicMock()
mock_creds.expired = False
mock_credentials_class.return_value = mock_creds
mock_youtube = MagicMock()
# Mock channels for get_channel_id
mock_channels = MagicMock()
mock_channels_list = MagicMock()
mock_channels_list.execute.return_value = {"items": [{"id": "UC123456"}]}
mock_channels.list.return_value = mock_channels_list
mock_youtube.channels.return_value = mock_channels
# Mock search for duplicate check (no duplicates)
mock_search = MagicMock()
mock_search_list = MagicMock()
mock_search_list.execute.return_value = {"items": []}
mock_search.list.return_value = mock_search_list
mock_youtube.search.return_value = mock_search
# Mock video insert
mock_videos = MagicMock()
mock_insert = MagicMock()
mock_insert.execute.return_value = {"id": "NEW_VIDEO_ID"}
mock_videos.insert.return_value = mock_insert
mock_youtube.videos.return_value = mock_videos
mock_build.return_value = mock_youtube
mock_media_upload.return_value = MagicMock()
creds = {"token": "test", "refresh_token": "test", "token_uri": "uri",
"client_id": "id", "client_secret": "secret"}
service = YouTubeUploadService(credentials=creds, non_interactive=True)
video_id, video_url = service.upload_video(
video_path="/path/to/video.mkv",
title="Test Artist - Test Song (Karaoke)",
description="Test description",
tags=["karaoke", "test"]
)
assert video_id == "NEW_VIDEO_ID"
assert "NEW_VIDEO_ID" in video_url
def test_upload_video_dry_run(self):
"""Test video upload in dry run mode."""
service = YouTubeUploadService(dry_run=True)
video_id, video_url = service.upload_video(
video_path="/path/to/video.mkv",
title="Test Title",
description="Test description"
)
assert video_id == "dry_run_video_id"
assert "dry_run_video_id" in video_url
@patch("googleapiclient.http.MediaFileUpload")
@patch("googleapiclient.discovery.build")
@patch("google.oauth2.credentials.Credentials")
@patch("google.auth.transport.requests.Request")
@patch("os.path.isfile")
def test_upload_video_with_thumbnail(
self, mock_isfile, mock_request, mock_credentials_class,
mock_build, mock_media_upload
):
"""Test video upload with thumbnail."""
mock_isfile.return_value = True
mock_creds = MagicMock()
mock_creds.expired = False
mock_credentials_class.return_value = mock_creds
mock_youtube = MagicMock()
mock_channels = MagicMock()
mock_channels_list = MagicMock()
mock_channels_list.execute.return_value = {"items": [{"id": "UC123456"}]}
mock_channels.list.return_value = mock_channels_list
mock_youtube.channels.return_value = mock_channels
mock_search = MagicMock()
mock_search_list = MagicMock()
mock_search_list.execute.return_value = {"items": []}
mock_search.list.return_value = mock_search_list
mock_youtube.search.return_value = mock_search
mock_videos = MagicMock()
mock_insert = MagicMock()
mock_insert.execute.return_value = {"id": "NEW_VIDEO_ID"}
mock_videos.insert.return_value = mock_insert
mock_youtube.videos.return_value = mock_videos
# Mock thumbnail upload
mock_thumbnails = MagicMock()
mock_set = MagicMock()
mock_set.execute.return_value = None
mock_thumbnails.set.return_value = mock_set
mock_youtube.thumbnails.return_value = mock_thumbnails
mock_build.return_value = mock_youtube
mock_media_upload.return_value = MagicMock()
creds = {"token": "test", "refresh_token": "test", "token_uri": "uri",
"client_id": "id", "client_secret": "secret"}
service = YouTubeUploadService(credentials=creds, non_interactive=True)
video_id, video_url = service.upload_video(
video_path="/path/to/video.mkv",
title="Test Title",
description="Test description",
thumbnail_path="/path/to/thumbnail.jpg"
)
assert video_id == "NEW_VIDEO_ID"
mock_thumbnails.set.assert_called_once()
class TestGetYouTubeUploadService:
"""Test factory function."""
def test_get_service_creates_instance(self):
"""Test that factory function creates a new instance."""
# Reset global
import backend.services.youtube_upload_service as module
module._youtube_upload_service = None
service = get_youtube_upload_service(
credentials={"token": "test"},
non_interactive=True
)
assert service is not None
assert isinstance(service, YouTubeUploadService)
def test_get_service_with_client_secrets(self):
"""Test factory function with client secrets file."""
import backend.services.youtube_upload_service as module
module._youtube_upload_service = None
service = get_youtube_upload_service(
client_secrets_file="/path/to/secrets.json"
)
assert service is not None
assert service.client_secrets_file == "/path/to/secrets.json"
+13 -57
View File
@@ -36,35 +36,6 @@ from karaoke_gen.audio_processor import AudioProcessor
logger = logging.getLogger(__name__)
async def _trigger_lyrics_worker_after_url_download(job_id: str) -> None:
"""
Trigger lyrics worker after URL audio download completes.
For URL jobs, we use sequential triggering:
1. Audio worker downloads and uploads audio to GCS
2. Audio worker triggers lyrics worker (this function)
3. Both workers then proceed in parallel (audio separation + lyrics transcription)
This prevents the race condition where lyrics worker times out waiting for audio.
"""
from backend.services.worker_service import get_worker_service
try:
worker_service = get_worker_service()
await worker_service.trigger_lyrics_worker(job_id)
logger.info(f"Job {job_id}: Triggered lyrics worker after URL download")
except Exception as e:
# Log but don't fail - audio processing can still continue
# The job will eventually timeout if lyrics worker doesn't run
logger.error(f"Job {job_id}: Failed to trigger lyrics worker: {e}")
# Default model names - used by create_audio_processor and stored in state_data
DEFAULT_CLEAN_MODEL = "model_bs_roformer_ep_317_sdr_12.9755.ckpt"
DEFAULT_BACKING_MODELS = ["mel_band_roformer_karaoke_aufr33_viperx_sdr_10.1956.ckpt"]
DEFAULT_OTHER_MODELS = ["htdemucs_6s.yaml"]
# Loggers to capture for audio worker
AUDIO_WORKER_LOGGERS = [
"karaoke_gen.audio_processor",
@@ -210,10 +181,10 @@ def create_audio_processor(
audio_logger = logging.getLogger("karaoke_gen.audio_processor")
audio_logger.setLevel(logging.INFO)
# Model configurations - use provided values or defaults from module constants
effective_clean_model = clean_instrumental_model or DEFAULT_CLEAN_MODEL
effective_backing_models = backing_vocals_models or DEFAULT_BACKING_MODELS
effective_other_models = other_stems_models or DEFAULT_OTHER_MODELS # For 6-stem separation (bass, drums, etc.)
# Model configurations - use provided values or CLI defaults
effective_clean_model = clean_instrumental_model or "model_bs_roformer_ep_317_sdr_12.9755.ckpt"
effective_backing_models = backing_vocals_models or ["mel_band_roformer_karaoke_aufr33_viperx_sdr_10.1956.ckpt"]
effective_other_models = other_stems_models or ["htdemucs_6s.yaml"] # For 6-stem separation (bass, drums, etc.)
# FFmpeg command for combining audio files (must be a string, not a list)
ffmpeg_base_command = "ffmpeg -hide_banner -loglevel error -nostats -y"
@@ -332,17 +303,7 @@ async def process_audio_separation(job_id: str) -> bool:
backing_vocals_models=job.backing_vocals_models,
other_stems_models=job.other_stems_models
)
# Store effective model names in state_data for video_worker to use in file naming
# This ensures output filenames match local CLI behavior (e.g., "Instrumental model_bs_roformer_ep_317_sdr_12.9755.ckpt")
effective_model_names = {
'clean_instrumental_model': job.clean_instrumental_model or DEFAULT_CLEAN_MODEL,
'backing_vocals_models': job.backing_vocals_models or DEFAULT_BACKING_MODELS,
'other_stems_models': job.other_stems_models or DEFAULT_OTHER_MODELS,
}
job_manager.update_state_data(job_id, 'model_names', effective_model_names)
job_log.info(f"Stored effective model names: clean={effective_model_names['clean_instrumental_model']}")
# Format artist-title for file naming (matches CLI behavior)
artist_title = f"{job.artist} - {job.title}"
@@ -468,34 +429,29 @@ async def download_audio(
# Case 3: Fresh URL that needs downloading
if job.url:
logger.info(f"Job {job_id}: Downloading from URL: {job.url}")
# Use provided job_manager or create new one
jm = job_manager_instance or JobManager()
local_path = await download_from_url(
job.url,
temp_dir,
job.artist,
job.url,
temp_dir,
job.artist,
job.title,
job_manager=jm,
job_id=job_id
)
if local_path and os.path.exists(local_path):
# Upload to GCS and update job
gcs_path = f"jobs/{job_id}/input/{os.path.basename(local_path)}"
url = storage.upload_file(local_path, gcs_path)
# Update job with GCS path for lyrics worker
jm.update_job(job_id, {'input_media_gcs_path': gcs_path})
jm.update_file_url(job_id, 'input', 'audio', url)
logger.info(f"Job {job_id}: Downloaded and uploaded audio to GCS: {gcs_path}")
# For URL jobs, trigger lyrics worker now that audio is available
# This is the sequential trigger pattern - audio first, then lyrics
await _trigger_lyrics_worker_after_url_download(job_id)
return local_path
else:
logger.error(f"Job {job_id}: Failed to download from URL: {job.url}")
+19 -152
View File
@@ -32,7 +32,6 @@ from backend.models.job import JobStatus
from karaoke_gen.utils import sanitize_filename
from backend.services.job_manager import JobManager
from backend.services.storage_service import StorageService
from backend.services.lyrics_cache_service import LyricsCacheService
from backend.workers.worker_logging import create_job_logger, setup_job_logging, job_logging_context
from backend.workers.style_helper import load_style_config
from backend.services.tracing import job_span, add_span_event, add_span_attribute
@@ -40,43 +39,10 @@ from backend.services.metrics import metrics
# Import from karaoke_gen package
from karaoke_gen.lyrics_processor import LyricsProcessor
from backend.config import get_settings
logger = logging.getLogger(__name__)
# Timeout for entire transcription process including agentic AI correction (20 minutes)
# This needs to account for:
# - Cloud Run cold start / worker initialization (1-5 min)
# - AudioShake transcription (1-2 min)
# - spaCy model loading for correction (2-3 min on cold start)
# - Agentic AI correction (1-3 min)
TRANSCRIPTION_TIMEOUT_SECONDS = 1200
# Default agentic correction timeout (3 minutes)
# Configurable via AGENTIC_CORRECTION_TIMEOUT_SECONDS environment variable
# If agentic AI takes longer than this, abort and use uncorrected transcription
# Human review will correct any issues
DEFAULT_AGENTIC_TIMEOUT_SECONDS = 180
def _configure_agentic_ai():
"""Configure environment variables for agentic AI correction.
The lyrics_transcriber library reads these directly from environment.
This ensures the settings from backend config are available.
"""
settings = get_settings()
# Enable agentic AI if configured
if settings.use_agentic_ai:
os.environ["USE_AGENTIC_AI"] = "1"
os.environ["AGENTIC_AI_MODEL"] = settings.agentic_ai_model
logger.info(f"Agentic AI enabled with model: {settings.agentic_ai_model}")
else:
os.environ["USE_AGENTIC_AI"] = "0"
logger.info("Agentic AI disabled")
# Loggers to capture for lyrics worker (top-level package loggers only)
# Note: We only capture at top-level package loggers to avoid duplicate log entries.
@@ -153,10 +119,7 @@ async def process_lyrics_transcription(job_id: str) -> bool:
start_time = time.time()
job_manager = JobManager()
storage = StorageService()
# Configure agentic AI before any lyrics processing
_configure_agentic_ai()
# Create job logger for remote debugging FIRST
job_log = create_job_logger(job_id, "lyrics")
@@ -230,40 +193,7 @@ async def process_lyrics_transcription(job_id: str) -> bool:
raise Exception("Failed to download audio file")
job_log.info(f"Audio downloaded: {os.path.basename(audio_path)}")
download_span.set_attribute("audio_file", os.path.basename(audio_path))
# Set up LyricsTranscriber cache directory and sync from GCS
# This allows reusing cached AudioShake/lyrics API responses across Cloud Run instances
cache_dir = os.path.join(temp_dir, "lyrics-cache")
os.makedirs(cache_dir, exist_ok=True)
os.environ["LYRICS_TRANSCRIBER_CACHE_DIR"] = cache_dir
job_log.info(f"LyricsTranscriber cache dir: {cache_dir}")
# Sync cache from GCS (download any existing cached API responses)
# Note: Cache sync is best-effort - failures should not fail the job
cache_service = LyricsCacheService(storage)
audio_hash = None
lyrics_hash = None
with job_span("sync-cache-from-gcs", job_id):
try:
# Compute cache keys
audio_hash = cache_service.compute_audio_hash(audio_path)
# Use lyrics_artist/lyrics_title for lyrics hash (these are what LyricsTranscriber uses)
lyrics_search_artist = getattr(job, 'lyrics_artist', None) or job.artist
lyrics_search_title = getattr(job, 'lyrics_title', None) or job.title
lyrics_hash = cache_service.compute_lyrics_hash(lyrics_search_artist, lyrics_search_title)
job_log.info(f"Cache keys: audio_hash={audio_hash[:8]}..., lyrics_hash={lyrics_hash[:8]}...")
add_span_attribute("audio_hash", audio_hash[:8])
add_span_attribute("lyrics_hash", lyrics_hash[:8])
# Download relevant cache files from GCS
cache_stats = cache_service.sync_cache_from_gcs(cache_dir, audio_hash, lyrics_hash)
job_log.info(f"Cache sync from GCS: {cache_stats['downloaded']} downloaded, {cache_stats['not_found']} not found")
add_span_attribute("cache_hits", cache_stats["downloaded"])
except Exception as e:
job_log.warning(f"Cache sync from GCS failed (non-fatal): {e}", exc_info=True)
add_span_attribute("cache_sync_error", str(e)[:100])
# Update progress using state_data (don't change status during parallel processing)
# The status is managed at a higher level - workers just track their progress
job_manager.update_state_data(job_id, 'lyrics_progress', {
@@ -333,73 +263,26 @@ async def process_lyrics_transcription(job_id: str) -> bool:
if lyrics_search_title != job.title:
job_log.info(f" Lyrics search title override: {lyrics_search_title}")
logger.info(f"[job:{job_id}] Calling lyrics_processor.transcribe_lyrics()")
# Run transcription + correction with timeout
# AudioShake typically takes 1-2 minutes, but can hang.
# Run transcription + correction
with job_span("audioshake-transcription", job_id) as trans_span:
trans_start = time.time()
add_span_event("transcription_started")
# Calculate deadline for agentic correction
# If agentic AI is enabled, the correction loop will check this deadline
# and abort early if exceeded, returning uncorrected transcription for human review
settings = get_settings()
agentic_deadline = None
timeout_seconds = settings.agentic_correction_timeout_seconds
if settings.use_agentic_ai:
agentic_deadline = time.time() + timeout_seconds
job_log.info(
f"Agentic AI enabled with {timeout_seconds}s timeout"
)
# Run transcription in thread pool
# When agentic AI is enabled, wrap with outer timeout as safety net
# Inner deadline check in corrector.py will break out of gap loop gracefully
# Outer timeout catches case where single LLM call hangs for too long
transcription_coro = asyncio.to_thread(
lyrics_processor.transcribe_lyrics,
input_audio_wav=audio_path,
artist=job.artist, # Original artist for file naming
title=job.title, # Original title for file naming
track_output_dir=temp_dir,
lyrics_artist=lyrics_search_artist, # Override for lyrics search
lyrics_title=lyrics_search_title, # Override for lyrics search
agentic_deadline=agentic_deadline, # Deadline for agentic timeout
)
# Run transcription in thread pool to avoid blocking the event loop
# (transcribe_lyrics is synchronous and takes 1-2 minutes)
# Note: transcribe_lyrics internally calls AudioShake and lyrics APIs
with metrics.time_external_api("audioshake", job_id):
if settings.use_agentic_ai:
# Outer timeout must be generous to allow for AudioShake time
# (can take 2-5+ minutes for long songs) PLUS agentic correction.
# The inner deadline check in corrector.py handles the 3-minute
# correction limit gracefully by returning partial results.
# This outer timeout is a safety net for completely hung LLM calls.
outer_timeout = TRANSCRIPTION_TIMEOUT_SECONDS # Same as non-agentic
try:
result = await asyncio.wait_for(
transcription_coro,
timeout=outer_timeout
)
except asyncio.TimeoutError:
# This should rarely trigger since inner deadline check breaks first
# But provides hard stop if e.g. single LLM call hangs completely
job_log.error(
f"HARD TIMEOUT: Transcription exceeded {outer_timeout}s. "
"This indicates the inner deadline check failed to trigger."
)
raise RuntimeError(
f"Lyrics transcription timed out after {outer_timeout}s"
) from None
else:
# Non-agentic mode: use general timeout (10 minutes)
try:
result = await asyncio.wait_for(
transcription_coro,
timeout=TRANSCRIPTION_TIMEOUT_SECONDS
)
except asyncio.TimeoutError:
raise Exception(f"Transcription timed out after {TRANSCRIPTION_TIMEOUT_SECONDS} seconds")
result = await asyncio.to_thread(
lyrics_processor.transcribe_lyrics,
input_audio_wav=audio_path,
artist=job.artist, # Original artist for file naming
title=job.title, # Original title for file naming
track_output_dir=temp_dir,
lyrics_artist=lyrics_search_artist, # Override for lyrics search
lyrics_title=lyrics_search_title # Override for lyrics search
)
trans_duration = time.time() - trans_start
trans_span.set_attribute("duration_seconds", trans_duration)
add_span_event("transcription_completed", {"duration_seconds": trans_duration})
@@ -414,23 +297,7 @@ async def process_lyrics_transcription(job_id: str) -> bool:
job_log.info("All lyrics data uploaded successfully")
logger.info(f"[job:{job_id}] All lyrics data uploaded successfully")
# Sync new cache files to GCS (upload any newly created cache entries)
# This persists cache across Cloud Run instances for future jobs
# Note: Cache upload is best-effort - failures should not fail the job
with job_span("sync-cache-to-gcs", job_id):
try:
if audio_hash and lyrics_hash:
upload_stats = cache_service.sync_cache_to_gcs(cache_dir, audio_hash, lyrics_hash)
job_log.info(f"Cache sync to GCS: {upload_stats['uploaded']} uploaded, {upload_stats['skipped']} already existed")
add_span_attribute("cache_uploads", upload_stats["uploaded"])
else:
job_log.warning("Skipping cache upload: missing audio_hash or lyrics_hash")
add_span_attribute("cache_upload_skipped", "missing_hashes")
except Exception as e:
job_log.warning(f"Cache upload to GCS failed (non-fatal): {e}")
add_span_attribute("cache_upload_error", str(e)[:100])
# Update progress using state_data (don't change status during parallel processing)
job_manager.update_state_data(job_id, 'lyrics_progress', {
'stage': 'lyrics_complete',
+96 -629
View File
@@ -1,21 +1,20 @@
"""
Video generation and finalization worker.
This worker has two code paths controlled by USE_NEW_ORCHESTRATOR:
This worker uses KaraokeFinalise from the karaoke_gen package to handle:
1. Video encoding (4 formats)
2. CDG/TXT package generation
3. Discord notifications
4. Brand code generation
5. All other finalisation features
1. NEW PATH (USE_NEW_ORCHESTRATOR=true):
Uses VideoWorkerOrchestrator which provides a unified pipeline for all
encoding backends (GCE or local). This ensures features like YouTube upload,
Discord notifications, and CDG/TXT packaging work regardless of encoding backend.
The worker's job is simply to:
1. Download files from GCS and set up the directory structure KaraokeFinalise expects
2. Instantiate KaraokeFinalise with parameters from the job
3. Call process()
4. Upload results back to GCS
2. LEGACY PATH (USE_NEW_ORCHESTRATOR=false):
Uses KaraokeFinalise from the karaoke_gen package. This path has divergent
behavior between GCE and local encoding - GCE encoding bypasses many features.
The orchestrator-based approach is preferred as it:
- Eliminates GCE vs local code path divergence
- Ensures all features work consistently
- Provides better testability and maintainability
This reuses 100% of the existing karaoke_gen functionality.
Observability:
- All operations wrapped in tracing spans for Cloud Trace visibility
@@ -36,7 +35,6 @@ from backend.services.job_manager import JobManager
from backend.services.storage_service import StorageService
from backend.services.rclone_service import get_rclone_service
from backend.services.youtube_service import get_youtube_service
from backend.services.encoding_service import get_encoding_service
from backend.config import get_settings
from backend.workers.style_helper import load_style_config
from backend.workers.worker_logging import create_job_logger, setup_job_logging, job_logging_context
@@ -49,12 +47,6 @@ from karaoke_gen.karaoke_finalise.karaoke_finalise import KaraokeFinalise
logger = logging.getLogger(__name__)
# Feature flag for new orchestrator-based pipeline
# Set to True to use the new unified pipeline that works with any encoding backend
# Set to False to use the legacy KaraokeFinalise-based pipeline
USE_NEW_ORCHESTRATOR = os.environ.get("USE_NEW_ORCHESTRATOR", "true").lower() == "true"
# Loggers to capture for video worker
# Include the full module path to properly capture KaraokeFinalise logs
VIDEO_WORKER_LOGGERS = [
@@ -63,363 +55,16 @@ VIDEO_WORKER_LOGGERS = [
]
async def _encode_via_gce(
job_id: str,
job,
job_manager: JobManager,
storage: StorageService,
temp_dir: str,
base_name: str,
job_log,
) -> Dict[str, Any]:
"""
Encode videos using the high-performance GCE encoding worker.
This offloads FFmpeg encoding to a dedicated C4 GCE instance with
Intel Granite Rapids 3.9 GHz CPU for 2-3x faster encoding.
Args:
job_id: Job ID
job: Job object
job_manager: Job manager instance
storage: Storage service instance
temp_dir: Temporary directory for output files
base_name: Base name for output files (e.g., "Artist - Title")
job_log: Job-specific logger
Returns:
Result dict with paths to encoded files
"""
settings = get_settings()
encoding_service = get_encoding_service()
job_log.info("Using GCE encoding worker for high-performance encoding")
logger.info(f"[job:{job_id}] Using GCE encoding worker")
# Construct GCS paths for the encoding worker
bucket_name = settings.gcs_bucket_name
input_gcs_path = f"gs://{bucket_name}/jobs/{job_id}/"
output_gcs_path = f"gs://{bucket_name}/jobs/{job_id}/encoded/"
# Determine instrumental selection for encoding config
instrumental_selection = job.state_data.get('instrumental_selection', 'clean')
existing_instrumental = getattr(job, 'existing_instrumental_gcs_path', None)
encoding_config = {
"formats": ["mp4_4k_lossless", "mp4_4k_lossy", "mp4_720p"],
"base_name": base_name,
"instrumental_selection": instrumental_selection,
"existing_instrumental": existing_instrumental,
"ffmpeg_threads": 8, # c4-standard-8 has 8 vCPUs
}
job_log.info(f"Submitting encoding job to GCE worker")
job_log.info(f" Input: {input_gcs_path}")
job_log.info(f" Output: {output_gcs_path}")
def progress_callback(progress: int):
# Update job progress (encoding is 75-95% of total)
scaled_progress = 75 + int(progress * 0.2) # Map 0-100 to 75-95
job_manager.transition_to_state(
job_id=job_id,
new_status=JobStatus.ENCODING,
progress=scaled_progress,
message=f"Encoding videos ({progress}%)"
)
try:
# Submit and wait for encoding
with job_span("gce-encoding", job_id) as encoding_span:
encode_start = time.time()
add_span_event("gce_encoding_started")
result = await encoding_service.encode_videos(
job_id=job_id,
input_gcs_path=input_gcs_path,
output_gcs_path=output_gcs_path,
encoding_config=encoding_config,
progress_callback=progress_callback,
)
encode_duration = time.time() - encode_start
encoding_span.set_attribute("duration_seconds", encode_duration)
add_span_event("gce_encoding_completed", {"duration_seconds": encode_duration})
job_log.info(f"GCE encoding complete in {encode_duration:.1f}s")
logger.info(f"[job:{job_id}] GCE encoding complete in {encode_duration:.1f}s")
# Download encoded files from GCS to temp_dir
output_files = result.get("output_files", [])
local_files = {}
for gcs_path in output_files:
filename = os.path.basename(gcs_path)
local_path = os.path.join(temp_dir, filename)
job_log.info(f"Downloading encoded file: {filename}")
storage.download_file(gcs_path, local_path)
# Map to result keys expected by _upload_results
if "4K Lossless" in filename or "4k_lossless" in filename.lower():
local_files["final_video"] = local_path
elif "4K Lossy" in filename or "4k_lossy" in filename.lower():
local_files["final_video_lossy"] = local_path
elif "720p" in filename:
local_files["final_video_720p"] = local_path
elif filename.endswith(".mkv"):
local_files["final_video_mkv"] = local_path
job_log.info(f"Downloaded {len(local_files)} encoded files")
return local_files
except Exception as e:
job_log.error(f"GCE encoding failed: {e}")
logger.error(f"[job:{job_id}] GCE encoding failed: {e}")
raise
async def generate_video_orchestrated(job_id: str) -> bool:
"""
Generate final karaoke videos using the new VideoWorkerOrchestrator.
This provides a unified pipeline that works with any encoding backend
(GCE or local), ensuring all features like YouTube upload, Discord
notifications, and CDG/TXT packaging work consistently.
Args:
job_id: Job ID to process
Returns:
True if successful, False otherwise
"""
from backend.workers.video_worker_orchestrator import (
VideoWorkerOrchestrator,
create_orchestrator_config_from_job,
)
start_time = time.time()
job_manager = JobManager()
storage = StorageService()
# Create job logger for remote debugging
job_log = create_job_logger(job_id, "video")
# Log with structured markers for easy Cloud Logging queries
logger.info(f"[job:{job_id}] WORKER_START worker=video orchestrator=true")
# Set up log capture for KaraokeFinalise (still used by some services)
log_handler = setup_job_logging(job_id, "video", *VIDEO_WORKER_LOGGERS)
job = job_manager.get_job(job_id)
if not job:
logger.error(f"[job:{job_id}] Job not found")
return False
# Validate prerequisites
if not _validate_prerequisites(job):
logger.error(f"[job:{job_id}] Prerequisites not met for video generation")
return False
# Create temporary working directory
temp_dir = tempfile.mkdtemp(prefix=f"karaoke_video_{job_id}_")
original_cwd = os.getcwd()
# Set up rclone config if needed (for legacy Dropbox upload path)
rclone_service = None
if getattr(job, 'organised_dir_rclone_root', None):
rclone_service = get_rclone_service()
if rclone_service.setup_rclone_config():
job_log.info("Rclone config loaded for Dropbox upload")
# Load YouTube credentials if needed
youtube_credentials = None
if getattr(job, 'enable_youtube_upload', False):
youtube_service = get_youtube_service()
if youtube_service.is_configured:
youtube_credentials = youtube_service.get_credentials_dict()
job_log.info("YouTube credentials loaded for video upload")
else:
job_log.warning("YouTube credentials not available - upload will be skipped")
try:
# Wrap entire worker in a tracing span
with job_span("video-worker-orchestrated", job_id, {"artist": job.artist, "title": job.title}) as root_span:
with job_logging_context(job_id):
job_log.info(f"Starting orchestrated video generation for {job.artist} - {job.title}")
logger.info(f"[job:{job_id}] Starting orchestrated video generation")
# Transition to GENERATING_VIDEO state
job_manager.transition_to_state(
job_id=job_id,
new_status=JobStatus.GENERATING_VIDEO,
progress=70,
message="Preparing files for video generation"
)
# Download and set up files
base_name = f"{job.artist} - {job.title}"
with job_span("download-files", job_id):
job_log.info("Downloading files from GCS...")
await _setup_working_directory(job_id, job, storage, temp_dir, base_name, job_log)
job_log.info("All files downloaded successfully")
# Load style config for CDG styles
style_config = await load_style_config(job, storage, temp_dir)
cdg_styles = style_config.get_cdg_styles()
# Change to working directory
os.chdir(temp_dir)
# Create orchestrator config from job
config = create_orchestrator_config_from_job(
job=job,
temp_dir=temp_dir,
youtube_credentials=youtube_credentials,
cdg_styles=cdg_styles,
)
# Run the orchestrated pipeline
orchestrator = VideoWorkerOrchestrator(
config=config,
job_manager=job_manager,
storage=storage,
job_logger=job_log,
)
with job_span("orchestrator-run", job_id):
result = await orchestrator.run()
if not result.success:
raise Exception(result.error_message or "Orchestrator failed")
# Prepare distribution directory for native uploads
with job_span("distribution", job_id):
await _handle_native_distribution(
job_id=job_id,
job=job,
job_log=job_log,
job_manager=job_manager,
temp_dir=temp_dir,
result={
'brand_code': result.brand_code,
'youtube_url': result.youtube_url,
'final_video': result.final_video,
'final_video_lossy': result.final_video_lossy,
'final_video_720p': result.final_video_720p,
'final_karaoke_cdg_zip': result.final_karaoke_cdg_zip,
'dropbox_link': result.dropbox_link,
'gdrive_files': result.gdrive_files,
},
storage=storage,
)
# Upload generated files to GCS
job_manager.transition_to_state(
job_id=job_id,
new_status=JobStatus.PACKAGING,
progress=95,
message="Uploading final files"
)
with job_span("upload-results", job_id):
await _upload_results(job_id, job_manager, storage, temp_dir, {
'final_video': result.final_video,
'final_video_mkv': result.final_video_mkv,
'final_video_lossy': result.final_video_lossy,
'final_video_720p': result.final_video_720p,
'final_karaoke_cdg_zip': result.final_karaoke_cdg_zip,
'final_karaoke_txt_zip': result.final_karaoke_txt_zip,
})
# Mark job as complete
logger.info(f"[job:{job_id}] Video generation complete")
job_manager.transition_to_state(
job_id=job_id,
new_status=JobStatus.COMPLETE,
progress=100,
message="Karaoke generation complete!"
)
# Store result metadata in job
job_manager.update_job(job_id, {
'state_data': {
**job.state_data,
'brand_code': result.brand_code,
'youtube_url': result.youtube_url,
'dropbox_link': result.dropbox_link,
'gdrive_files': result.gdrive_files,
}
})
duration = time.time() - start_time
root_span.set_attribute("duration_seconds", duration)
root_span.set_attribute("brand_code", result.brand_code or '')
logger.info(f"[job:{job_id}] WORKER_END worker=video orchestrator=true status=success duration={duration:.1f}s")
return True
except Exception as e:
duration = time.time() - start_time
logger.error(f"[job:{job_id}] WORKER_END worker=video orchestrator=true status=error duration={duration:.1f}s error={e}")
job_manager.mark_job_failed(
job_id=job_id,
error_message=f"Video generation failed: {str(e)}",
error_details={"stage": "video_generation", "error": str(e)}
)
return False
finally:
# Restore original working directory
os.chdir(original_cwd)
# Remove log handler
for logger_name in VIDEO_WORKER_LOGGERS:
try:
logging.getLogger(logger_name).removeHandler(log_handler)
except Exception:
pass
# Cleanup rclone config file
if rclone_service:
rclone_service.cleanup()
# Cleanup temporary directory
if os.path.exists(temp_dir):
shutil.rmtree(temp_dir)
logger.debug(f"Cleaned up temp directory: {temp_dir}")
async def generate_video(job_id: str) -> bool:
"""
Generate final karaoke videos.
Routes to either the new orchestrator-based pipeline or the legacy
KaraokeFinalise-based pipeline based on USE_NEW_ORCHESTRATOR flag.
Generate final karaoke videos using KaraokeFinalise.
This sets up the directory structure and calls KaraokeFinalise.process()
which handles all encoding, packaging, and notifications.
Args:
job_id: Job ID to process
Returns:
True if successful, False otherwise
"""
if USE_NEW_ORCHESTRATOR:
logger.info(f"[job:{job_id}] Using new orchestrator-based pipeline")
return await generate_video_orchestrated(job_id)
else:
logger.info(f"[job:{job_id}] Using legacy KaraokeFinalise pipeline")
return await generate_video_legacy(job_id)
async def generate_video_legacy(job_id: str) -> bool:
"""
Generate final karaoke videos using KaraokeFinalise (legacy path).
This is the original implementation that has divergent behavior between
GCE and local encoding paths. Kept for rollback purposes.
Args:
job_id: Job ID to process
Returns:
True if successful, False otherwise
"""
@@ -539,105 +184,80 @@ async def generate_video_legacy(job_id: str) -> bool:
countdown_padding_seconds = lyrics_metadata.get('countdown_padding_seconds', 3.0)
job_log.info(f"Countdown padding detected: {countdown_padding_seconds}s - instrumental will be padded if needed")
# Check if GCE encoding is enabled for high-performance encoding
encoding_service = get_encoding_service()
use_gce_encoding = encoding_service.is_enabled
if use_gce_encoding:
# ============ GCE ENCODING PATH ============
# Use dedicated C4 GCE instance for 2-3x faster FFmpeg encoding
job_log.info("GCE encoding enabled - using high-performance encoding worker")
job_log.info(f" instrumental source: {instrumental_source}")
result = await _encode_via_gce(
job_id=job_id,
job=job,
job_manager=job_manager,
storage=storage,
temp_dir=temp_dir,
base_name=base_name,
job_log=job_log,
)
# GCE encoding doesn't generate brand_code, CDG/TXT, or Discord notifications
# These will be handled by distribution if needed
job_log.info("GCE encoding complete - encoded files downloaded")
else:
# ============ STANDARD ENCODING PATH ============
# Use KaraokeFinalise for encoding (runs on Cloud Run)
# Log finalization parameters
job_log.info("Using KaraokeFinalise for encoding (standard path)")
job_log.info(f" enable_cdg: {getattr(job, 'enable_cdg', False)}")
job_log.info(f" enable_txt: {getattr(job, 'enable_txt', False)}")
job_log.info(f" brand_prefix: {getattr(job, 'brand_prefix', None)}")
job_log.info(f" discord_webhook: {'configured' if getattr(job, 'discord_webhook_url', None) else 'not configured'}")
job_log.info(f" instrumental source: {instrumental_source}")
job_log.info(f" countdown_padding_seconds: {countdown_padding_seconds}")
if existing_instrumental_path:
job_log.info(f" using user-provided instrumental (selection was: {instrumental_selection})")
# Set up YouTube description file if template is provided
youtube_desc_path = None
if youtube_credentials and getattr(job, 'youtube_description_template', None):
youtube_desc_path = os.path.join(temp_dir, "youtube_description.txt")
with open(youtube_desc_path, 'w') as f:
f.write(job.youtube_description_template)
job_log.info("YouTube description template written to temp file")
finalise = KaraokeFinalise(
logger=logger,
log_level=logging.INFO,
dry_run=False,
instrumental_format="flac",
# CDG/TXT generation
enable_cdg=getattr(job, 'enable_cdg', False),
enable_txt=getattr(job, 'enable_txt', False),
cdg_styles=cdg_styles,
# Brand code and organization (server-side mode uses rclone)
brand_prefix=getattr(job, 'brand_prefix', None),
organised_dir=None, # Not used in cloud - files stay in GCS
organised_dir_rclone_root=getattr(job, 'organised_dir_rclone_root', None),
public_share_dir=None, # Not used in cloud
# Notifications
discord_webhook_url=getattr(job, 'discord_webhook_url', None),
# YouTube upload (server-side with pre-loaded credentials)
youtube_client_secrets_file=None, # Not used with pre-stored credentials
youtube_description_file=youtube_desc_path,
user_youtube_credentials=youtube_credentials, # Pre-loaded from Secret Manager
rclone_destination=None,
email_template_file=None,
# Server-side optimizations
non_interactive=True,
server_side_mode=True,
selected_instrumental_file=instrumental_file,
# Audio synchronization - ensure instrumental matches vocal padding
countdown_padding_seconds=countdown_padding_seconds,
)
# Call process() - this does ALL the work:
# - Encodes to 4 video formats
# - Generates CDG/TXT packages if enabled
# - Posts Discord notification if configured
# - Handles brand code generation
with job_span("karaoke-finalise", job_id) as finalise_span:
finalise_start = time.time()
job_log.info("Starting KaraokeFinalise.process() - this may take 15-20 minutes...")
logger.info(f"[job:{job_id}] Starting KaraokeFinalise.process()")
add_span_event("finalise_started")
result = finalise.process()
finalise_duration = time.time() - finalise_start
finalise_span.set_attribute("duration_seconds", finalise_duration)
add_span_event("finalise_completed", {"duration_seconds": finalise_duration})
job_log.info("KaraokeFinalise.process() complete!")
if result.get('brand_code'):
job_log.info(f"Brand code: {result.get('brand_code')}")
logger.info(f"[job:{job_id}] KaraokeFinalise.process() complete in {finalise_duration:.1f}s")
logger.info(f"[job:{job_id}] Brand code: {result.get('brand_code')}")
# Log finalization parameters
job_log.info("Creating KaraokeFinalise with parameters:")
job_log.info(f" enable_cdg: {getattr(job, 'enable_cdg', False)}")
job_log.info(f" enable_txt: {getattr(job, 'enable_txt', False)}")
job_log.info(f" brand_prefix: {getattr(job, 'brand_prefix', None)}")
job_log.info(f" discord_webhook: {'configured' if getattr(job, 'discord_webhook_url', None) else 'not configured'}")
job_log.info(f" instrumental source: {instrumental_source}")
job_log.info(f" countdown_padding_seconds: {countdown_padding_seconds}")
if existing_instrumental_path:
job_log.info(f" using user-provided instrumental (selection was: {instrumental_selection})")
# Create KaraokeFinalise with ALL the parameters from the job
# This reuses all existing functionality!
# Set up YouTube description file if template is provided
youtube_desc_path = None
if youtube_credentials and getattr(job, 'youtube_description_template', None):
youtube_desc_path = os.path.join(temp_dir, "youtube_description.txt")
with open(youtube_desc_path, 'w') as f:
f.write(job.youtube_description_template)
job_log.info("YouTube description template written to temp file")
finalise = KaraokeFinalise(
logger=logger,
log_level=logging.INFO,
dry_run=False,
instrumental_format="flac",
# CDG/TXT generation
enable_cdg=getattr(job, 'enable_cdg', False),
enable_txt=getattr(job, 'enable_txt', False),
cdg_styles=cdg_styles,
# Brand code and organization (server-side mode uses rclone)
brand_prefix=getattr(job, 'brand_prefix', None),
organised_dir=None, # Not used in cloud - files stay in GCS
organised_dir_rclone_root=getattr(job, 'organised_dir_rclone_root', None),
public_share_dir=None, # Not used in cloud
# Notifications
discord_webhook_url=getattr(job, 'discord_webhook_url', None),
# YouTube upload (server-side with pre-loaded credentials)
youtube_client_secrets_file=None, # Not used with pre-stored credentials
youtube_description_file=youtube_desc_path,
user_youtube_credentials=youtube_credentials, # Pre-loaded from Secret Manager
rclone_destination=None,
email_template_file=None,
# Server-side optimizations
non_interactive=True,
server_side_mode=True,
selected_instrumental_file=instrumental_file,
# Audio synchronization - ensure instrumental matches vocal padding
countdown_padding_seconds=countdown_padding_seconds,
)
# Call process() - this does ALL the work:
# - Encodes to 4 video formats
# - Generates CDG/TXT packages if enabled
# - Posts Discord notification if configured
# - Handles brand code generation
with job_span("karaoke-finalise", job_id) as finalise_span:
finalise_start = time.time()
job_log.info("Starting KaraokeFinalise.process() - this may take 15-20 minutes...")
logger.info(f"[job:{job_id}] Starting KaraokeFinalise.process()")
add_span_event("finalise_started")
result = finalise.process()
finalise_duration = time.time() - finalise_start
finalise_span.set_attribute("duration_seconds", finalise_duration)
add_span_event("finalise_completed", {"duration_seconds": finalise_duration})
job_log.info("KaraokeFinalise.process() complete!")
if result.get('brand_code'):
job_log.info(f"Brand code: {result.get('brand_code')}")
logger.info(f"[job:{job_id}] KaraokeFinalise.process() complete in {finalise_duration:.1f}s")
logger.info(f"[job:{job_id}] Brand code: {result.get('brand_code')}")
# Native API distribution uploads (used by remote CLI instead of rclone)
with job_span("distribution", job_id):
@@ -648,7 +268,6 @@ async def generate_video_legacy(job_id: str) -> bool:
job_manager=job_manager,
temp_dir=temp_dir,
result=result,
storage=storage,
)
# Upload generated files to GCS
@@ -672,16 +291,11 @@ async def generate_video_legacy(job_id: str) -> bool:
)
# Store result metadata in job
# NOTE: Must include dropbox_link and gdrive_files from result, since
# _handle_native_distribution already saved them but job.state_data
# is stale (fetched before distribution ran)
job_manager.update_job(job_id, {
'state_data': {
**job.state_data,
'brand_code': result.get('brand_code'),
'youtube_url': result.get('youtube_url'),
'dropbox_link': result.get('dropbox_link'),
'gdrive_files': result.get('gdrive_files'),
}
})
@@ -729,17 +343,16 @@ async def _handle_native_distribution(
job_manager: JobManager,
temp_dir: str,
result: Dict[str, Any],
storage: StorageService = None,
) -> None:
"""
Handle distribution uploads using native APIs (Dropbox SDK, Google Drive API).
This is used by the remote CLI instead of rclone-based uploads.
The native APIs provide:
- Better error handling and retry logic
- No need for rclone binary in container
- Credentials managed via Secret Manager
Args:
job_id: Job ID
job: Job object with dropbox_path and gdrive_folder_id fields
@@ -747,7 +360,6 @@ async def _handle_native_distribution(
job_manager: Job manager for updating job state
temp_dir: Temporary directory with output files
result: Result dict from KaraokeFinalise.process()
storage: StorageService instance for downloading stems/lyrics
"""
brand_code = result.get('brand_code')
base_name = f"{job.artist} - {job.title}"
@@ -780,22 +392,10 @@ async def _handle_native_distribution(
result['brand_code'] = brand_code
job_log.info(f"Generated brand code: {brand_code}")
# Prepare full distribution directory with stems/ and lyrics/ subfolders
# This must be done before upload to ensure complete output structure
if storage:
await _prepare_distribution_directory(
job_id=job_id,
job=job,
storage=storage,
temp_dir=temp_dir,
base_name=base_name,
job_log=job_log,
)
# Create folder name and upload files
folder_name = f"{brand_code} - {base_name}"
remote_folder = f"{dropbox_path}/{folder_name}"
job_log.info(f"Uploading to Dropbox folder: {remote_folder}")
dropbox.upload_folder(temp_dir, remote_folder)
@@ -1001,139 +601,6 @@ async def _setup_working_directory(
log_progress("Downloaded end JPG")
async def _prepare_distribution_directory(
job_id: str,
job,
storage: StorageService,
temp_dir: str,
base_name: str,
job_log=None
) -> None:
"""
Prepare the full distribution directory structure matching local CLI output.
Creates:
- stems/ subfolder with all audio stems (proper model names)
- lyrics/ subfolder with intermediate lyrics files
- Root-level instrumentals with proper model names
This ensures the Dropbox upload contains the complete output structure.
"""
def log_progress(message: str):
"""Log to both module logger and job logger if available."""
logger.info(f"Job {job_id}: {message}")
if job_log:
job_log.info(message)
log_progress("Preparing full distribution directory structure")
# Get model names from state_data (stored by audio_worker)
model_names = job.state_data.get('model_names', {})
clean_model = model_names.get('clean_instrumental_model', 'model_bs_roformer_ep_317_sdr_12.9755.ckpt')
backing_models = model_names.get('backing_vocals_models', ['mel_band_roformer_karaoke_aufr33_viperx_sdr_10.1956.ckpt'])
other_models = model_names.get('other_stems_models', ['htdemucs_6s.yaml'])
backing_model = backing_models[0] if backing_models else 'mel_band_roformer_karaoke_aufr33_viperx_sdr_10.1956.ckpt'
other_model = other_models[0] if other_models else 'htdemucs_6s.yaml'
# Create stems subdirectory
stems_dir = os.path.join(temp_dir, "stems")
os.makedirs(stems_dir, exist_ok=True)
# Create lyrics subdirectory
lyrics_dir = os.path.join(temp_dir, "lyrics")
os.makedirs(lyrics_dir, exist_ok=True)
stems = job.file_urls.get('stems', {})
lyrics = job.file_urls.get('lyrics', {})
# --- Download stems to stems/ subfolder with proper model names ---
# Clean up simplified-named instrumentals from _setup_working_directory
# These were needed for KaraokeFinalise but shouldn't go to distribution
simplified_instrumental_patterns = [
f"{base_name} (Instrumental Clean).flac",
f"{base_name} (Instrumental Backing).flac",
]
for pattern in simplified_instrumental_patterns:
simplified_path = os.path.join(temp_dir, pattern)
if os.path.exists(simplified_path):
os.remove(simplified_path)
log_progress(f"Removed simplified instrumental: {pattern}")
# Clean instrumental (from clean_instrumental_model)
if stems.get('instrumental_clean'):
dest_path = os.path.join(stems_dir, f"{base_name} (Instrumental {clean_model}).flac")
storage.download_file(stems['instrumental_clean'], dest_path)
log_progress("Downloaded clean instrumental to stems/")
# Also copy to root level for distribution
root_path = os.path.join(temp_dir, f"{base_name} (Instrumental {clean_model}).flac")
shutil.copy2(dest_path, root_path)
# Clean vocals (from clean_instrumental_model)
if stems.get('vocals_clean'):
dest_path = os.path.join(stems_dir, f"{base_name} (Vocals {clean_model}).flac")
storage.download_file(stems['vocals_clean'], dest_path)
log_progress("Downloaded clean vocals to stems/")
# Instrumental with backing vocals (from backing_vocals_model)
if stems.get('instrumental_with_backing'):
dest_path = os.path.join(stems_dir, f"{base_name} (Instrumental +BV {backing_model}).flac")
storage.download_file(stems['instrumental_with_backing'], dest_path)
log_progress("Downloaded instrumental+BV to stems/")
# Also copy to root level for distribution
root_path = os.path.join(temp_dir, f"{base_name} (Instrumental +BV {backing_model}).flac")
shutil.copy2(dest_path, root_path)
# Lead vocals (from backing_vocals_model)
if stems.get('lead_vocals'):
dest_path = os.path.join(stems_dir, f"{base_name} (Lead Vocals {backing_model}).flac")
storage.download_file(stems['lead_vocals'], dest_path)
log_progress("Downloaded lead vocals to stems/")
# Backing vocals (from backing_vocals_model)
if stems.get('backing_vocals'):
dest_path = os.path.join(stems_dir, f"{base_name} (Backing Vocals {backing_model}).flac")
storage.download_file(stems['backing_vocals'], dest_path)
log_progress("Downloaded backing vocals to stems/")
# Other stems (from other_stems_model - typically htdemucs_6s)
other_stem_keys = ['bass', 'drums', 'guitar', 'piano', 'other']
for stem_key in other_stem_keys:
if stems.get(stem_key):
stem_name = stem_key.capitalize()
dest_path = os.path.join(stems_dir, f"{base_name} ({stem_name} {other_model}).flac")
storage.download_file(stems[stem_key], dest_path)
log_progress(f"Downloaded {stem_key} to stems/")
# --- Download lyrics files to lyrics/ subfolder ---
# Common lyrics file types
lyrics_file_keys = ['lrc', 'ass', 'srt', 'txt', 'json', 'original_json', 'corrected_json']
for lyrics_key in lyrics_file_keys:
if lyrics.get(lyrics_key):
# Determine proper extension
ext_map = {
'lrc': '.lrc',
'ass': '.ass',
'srt': '.srt',
'txt': '.txt',
'json': '.json',
'original_json': '_original.json',
'corrected_json': '_corrected.json',
}
ext = ext_map.get(lyrics_key, f'.{lyrics_key}')
dest_path = os.path.join(lyrics_dir, f"{base_name} (Karaoke){ext}")
try:
storage.download_file(lyrics[lyrics_key], dest_path)
log_progress(f"Downloaded {lyrics_key} to lyrics/")
except Exception as e:
log_progress(f"Could not download {lyrics_key}: {e}")
log_progress("Distribution directory prepared with stems/ and lyrics/ subfolders")
async def _upload_results(
job_id: str,
job_manager: JobManager,
@@ -1142,7 +609,7 @@ async def _upload_results(
result: Dict[str, Any]
) -> None:
"""Upload generated files to GCS."""
# Map of result keys to GCS paths
file_mappings = [
('final_video', 'finals', 'lossless_4k_mp4'),
@@ -1,638 +0,0 @@
"""
Video Worker Orchestrator.
Coordinates the video generation pipeline stages in a unified way,
regardless of whether encoding happens locally or on GCE.
This resolves the code path divergence where GCE encoding bypassed
features like YouTube upload, Discord notifications, and CDG/TXT packaging.
Pipeline stages:
1. Setup - Download files, prepare directories
2. Packaging - CDG/TXT generation (if enabled)
3. Encoding - GCE or Local via EncodingBackend interface
4. Organization - Brand code, folder structure
5. Distribution - YouTube, Dropbox, Google Drive uploads
6. Notification - Discord notifications
"""
import logging
import os
import time
from dataclasses import dataclass, field
from typing import Optional, Dict, Any, List
from pathlib import Path
from backend.models.job import JobStatus
from backend.services.job_manager import JobManager
from backend.services.storage_service import StorageService
from backend.services.tracing import job_span, add_span_event
logger = logging.getLogger(__name__)
@dataclass
class OrchestratorConfig:
"""Configuration for the video worker orchestrator."""
job_id: str
artist: str
title: str
# Input file paths (in temp_dir)
title_video_path: str
karaoke_video_path: str
instrumental_audio_path: str
end_video_path: Optional[str] = None
lrc_file_path: Optional[str] = None
title_jpg_path: Optional[str] = None
# Output directory
output_dir: str = ""
# Feature flags
enable_cdg: bool = False
enable_txt: bool = False
enable_youtube_upload: bool = False
# Service configurations
brand_prefix: Optional[str] = None
discord_webhook_url: Optional[str] = None
youtube_credentials: Optional[Dict[str, Any]] = None
youtube_description_template: Optional[str] = None
cdg_styles: Optional[Dict[str, Any]] = None
# Dropbox/GDrive configuration
dropbox_path: Optional[str] = None
gdrive_folder_id: Optional[str] = None
# Keep existing brand code (for re-processing)
keep_brand_code: Optional[str] = None
# Encoding backend preference
encoding_backend: str = "auto" # "auto", "local", "gce"
# Additional options
dry_run: bool = False
non_interactive: bool = True
@dataclass
class OrchestratorResult:
"""Result from the video worker orchestrator."""
success: bool
error_message: Optional[str] = None
# Generated files
final_video: Optional[str] = None # Lossless 4K MP4
final_video_mkv: Optional[str] = None # Lossless 4K MKV
final_video_lossy: Optional[str] = None # Lossy 4K MP4
final_video_720p: Optional[str] = None # Lossy 720p MP4
final_karaoke_cdg_zip: Optional[str] = None
final_karaoke_txt_zip: Optional[str] = None
# Organization
brand_code: Optional[str] = None
# Distribution results
youtube_url: Optional[str] = None
dropbox_link: Optional[str] = None
gdrive_files: Optional[Dict[str, str]] = field(default_factory=dict)
# Timing
encoding_time_seconds: Optional[float] = None
total_time_seconds: Optional[float] = None
class VideoWorkerOrchestrator:
"""
Orchestrates the video generation pipeline.
This class coordinates all stages of video generation in a unified way,
ensuring that features like YouTube upload and Discord notifications
work regardless of whether GCE or local encoding is used.
"""
def __init__(
self,
config: OrchestratorConfig,
job_manager: Optional[JobManager] = None,
storage: Optional[StorageService] = None,
job_logger: Optional[logging.Logger] = None,
):
"""
Initialize the orchestrator.
Args:
config: Orchestrator configuration
job_manager: Job manager for state updates (optional)
storage: Storage service for file downloads (optional)
job_logger: Job-specific logger (optional)
"""
self.config = config
self.job_manager = job_manager
self.storage = storage
self.job_log = job_logger or logging.getLogger(__name__)
# Services (lazy-loaded)
self._encoding_backend = None
self._packaging_service = None
self._youtube_service = None
self._discord_service = None
# State
self.result = OrchestratorResult(success=False)
def _get_encoding_backend(self):
"""Lazy-load the encoding backend."""
if self._encoding_backend is None:
from backend.services.encoding_interface import get_encoding_backend
self._encoding_backend = get_encoding_backend(
backend_type=self.config.encoding_backend,
dry_run=self.config.dry_run,
logger=self.job_log,
)
return self._encoding_backend
def _get_packaging_service(self):
"""Lazy-load the packaging service."""
if self._packaging_service is None:
from backend.services.packaging_service import PackagingService
self._packaging_service = PackagingService(
cdg_styles=self.config.cdg_styles,
dry_run=self.config.dry_run,
non_interactive=self.config.non_interactive,
logger=self.job_log,
)
return self._packaging_service
def _get_youtube_service(self):
"""Lazy-load the YouTube upload service."""
if self._youtube_service is None:
from backend.services.youtube_upload_service import YouTubeUploadService
self._youtube_service = YouTubeUploadService(
credentials=self.config.youtube_credentials,
non_interactive=self.config.non_interactive,
server_side_mode=True,
dry_run=self.config.dry_run,
logger=self.job_log,
)
return self._youtube_service
def _get_discord_service(self):
"""Lazy-load the Discord notification service."""
if self._discord_service is None:
from backend.services.discord_service import DiscordNotificationService
self._discord_service = DiscordNotificationService(
webhook_url=self.config.discord_webhook_url,
dry_run=self.config.dry_run,
logger=self.job_log,
)
return self._discord_service
def _update_progress(self, status: JobStatus, progress: int, message: str):
"""Update job progress if job_manager is available."""
if self.job_manager:
self.job_manager.transition_to_state(
job_id=self.config.job_id,
new_status=status,
progress=progress,
message=message
)
async def run(self) -> OrchestratorResult:
"""
Run the full video generation pipeline.
Returns:
OrchestratorResult with generated files and metadata
"""
start_time = time.time()
try:
with job_span("orchestrator", self.config.job_id) as span:
self.job_log.info(f"Starting orchestrated video generation for {self.config.artist} - {self.config.title}")
# Stage 1: Packaging (CDG/TXT) - runs BEFORE encoding
# This depends on LRC file, not on encoded videos
if self.config.enable_cdg or self.config.enable_txt:
await self._run_packaging()
# Stage 2: Encoding
await self._run_encoding()
# Stage 3: Organization (brand code)
await self._run_organization()
# Stage 4: Distribution (YouTube, Dropbox, GDrive)
await self._run_distribution()
# Stage 5: Notifications (Discord)
await self._run_notifications()
self.result.success = True
self.result.total_time_seconds = time.time() - start_time
self.job_log.info(f"Orchestrated video generation complete in {self.result.total_time_seconds:.1f}s")
except Exception as e:
self.result.success = False
self.result.error_message = str(e)
self.result.total_time_seconds = time.time() - start_time
self.job_log.error(f"Orchestrated video generation failed: {e}")
logger.error(f"[job:{self.config.job_id}] Orchestration failed: {e}")
return self.result
async def _run_packaging(self):
"""Run the packaging stage (CDG/TXT generation)."""
self.job_log.info("Starting packaging stage (CDG/TXT)")
if not self.config.lrc_file_path or not os.path.isfile(self.config.lrc_file_path):
self.job_log.warning("No LRC file available, skipping CDG/TXT packaging")
return
base_name = f"{self.config.artist} - {self.config.title}"
packaging_service = self._get_packaging_service()
# Generate CDG package
if self.config.enable_cdg:
self.job_log.info("Generating CDG package")
try:
cdg_zip_path = os.path.join(
self.config.output_dir,
f"{base_name} (Final Karaoke CDG).zip"
)
mp3_path = os.path.join(
self.config.output_dir,
f"{base_name} (Karaoke).mp3"
)
cdg_path = os.path.join(
self.config.output_dir,
f"{base_name} (Karaoke).cdg"
)
zip_file, mp3_file, cdg_file = packaging_service.create_cdg_package(
lrc_file=self.config.lrc_file_path,
audio_file=self.config.instrumental_audio_path,
output_zip_path=cdg_zip_path,
artist=self.config.artist,
title=self.config.title,
output_mp3_path=mp3_path,
output_cdg_path=cdg_path,
)
self.result.final_karaoke_cdg_zip = zip_file
self.job_log.info(f"CDG package created: {zip_file}")
except Exception as e:
self.job_log.error(f"CDG generation failed: {e}")
# Don't fail the pipeline, CDG is optional
# Generate TXT package
if self.config.enable_txt:
self.job_log.info("Generating TXT package")
try:
# TXT package needs MP3 file (from CDG generation or create it)
mp3_path = os.path.join(
self.config.output_dir,
f"{base_name} (Karaoke).mp3"
)
if not os.path.isfile(mp3_path):
self.job_log.info("MP3 not found, CDG must be enabled first for TXT")
return
txt_zip_path = os.path.join(
self.config.output_dir,
f"{base_name} (Final Karaoke TXT).zip"
)
zip_file, txt_file = packaging_service.create_txt_package(
lrc_file=self.config.lrc_file_path,
mp3_file=mp3_path,
output_zip_path=txt_zip_path,
)
self.result.final_karaoke_txt_zip = zip_file
self.job_log.info(f"TXT package created: {zip_file}")
except Exception as e:
self.job_log.error(f"TXT generation failed: {e}")
# Don't fail the pipeline, TXT is optional
async def _run_encoding(self):
"""Run the encoding stage."""
self.job_log.info("Starting encoding stage")
self._update_progress(JobStatus.ENCODING, 75, "Encoding videos")
encoding_backend = self._get_encoding_backend()
self.job_log.info(f"Using encoding backend: {encoding_backend.name}")
# Build encoding input
from backend.services.encoding_interface import EncodingInput
from backend.config import settings
# For GCE encoding, we need to provide GCS paths
gcs_bucket = settings.gcs_bucket_name
input_gcs_path = f"gs://{gcs_bucket}/jobs/{self.config.job_id}/"
output_gcs_path = f"gs://{gcs_bucket}/jobs/{self.config.job_id}/finals/"
encoding_input = EncodingInput(
title_video_path=self.config.title_video_path,
karaoke_video_path=self.config.karaoke_video_path,
instrumental_audio_path=self.config.instrumental_audio_path,
end_video_path=self.config.end_video_path,
artist=self.config.artist,
title=self.config.title,
brand_code=self.config.keep_brand_code,
output_dir=self.config.output_dir,
options={
"input_gcs_path": input_gcs_path,
"output_gcs_path": output_gcs_path,
},
)
# Run encoding
with job_span("encoding", self.config.job_id) as span:
add_span_event("encoding_started", {"backend": encoding_backend.name})
output = await encoding_backend.encode(encoding_input)
add_span_event("encoding_completed", {
"success": output.success,
"duration": output.encoding_time_seconds or 0
})
if not output.success:
raise Exception(f"Encoding failed: {output.error_message}")
# Store results
self.result.final_video = output.lossless_4k_mp4_path
self.result.final_video_mkv = output.lossless_mkv_path
self.result.final_video_lossy = output.lossy_4k_mp4_path
self.result.final_video_720p = output.lossy_720p_mp4_path
self.result.encoding_time_seconds = output.encoding_time_seconds
self.job_log.info(f"Encoding complete ({encoding_backend.name}) in {output.encoding_time_seconds:.1f}s")
async def _run_organization(self):
"""Run the organization stage (brand code generation)."""
self.job_log.info("Starting organization stage")
# Use existing brand code if provided
if self.config.keep_brand_code:
self.result.brand_code = self.config.keep_brand_code
self.job_log.info(f"Using preserved brand code: {self.result.brand_code}")
return
# Generate brand code from Dropbox if configured
if self.config.dropbox_path and self.config.brand_prefix:
try:
from backend.services.dropbox_service import get_dropbox_service
dropbox = get_dropbox_service()
if dropbox.is_configured:
brand_code = dropbox.get_next_brand_code(
self.config.dropbox_path,
self.config.brand_prefix
)
self.result.brand_code = brand_code
self.job_log.info(f"Generated brand code: {brand_code}")
else:
self.job_log.warning("Dropbox not configured, skipping brand code generation")
except Exception as e:
self.job_log.error(f"Brand code generation failed: {e}")
# Don't fail - brand code is optional
async def _run_distribution(self):
"""Run the distribution stage (YouTube, Dropbox, GDrive uploads)."""
self.job_log.info("Starting distribution stage")
self._update_progress(JobStatus.PACKAGING, 90, "Uploading files")
# YouTube upload
if self.config.enable_youtube_upload and self.config.youtube_credentials:
await self._upload_to_youtube()
# Dropbox upload
if self.config.dropbox_path and self.config.brand_prefix:
await self._upload_to_dropbox()
# Google Drive upload
if self.config.gdrive_folder_id:
await self._upload_to_gdrive()
async def _upload_to_youtube(self):
"""Upload video to YouTube."""
self.job_log.info("Uploading to YouTube")
# Find the best video file to upload (prefer MKV for FLAC audio, then lossless MP4)
video_to_upload = None
if self.result.final_video_mkv and os.path.isfile(self.result.final_video_mkv):
video_to_upload = self.result.final_video_mkv
elif self.result.final_video and os.path.isfile(self.result.final_video):
video_to_upload = self.result.final_video
elif self.result.final_video_lossy and os.path.isfile(self.result.final_video_lossy):
video_to_upload = self.result.final_video_lossy
if not video_to_upload:
self.job_log.warning("No video file available for YouTube upload")
return
try:
youtube_service = self._get_youtube_service()
# Build video title
title = f"{self.config.artist} - {self.config.title} (Karaoke)"
# Build description
description = self.config.youtube_description_template or ""
if self.result.brand_code:
description = f"{description}\n\nBrand Code: {self.result.brand_code}".strip()
# Upload
video_id, video_url = youtube_service.upload_video(
video_path=video_to_upload,
title=title,
description=description,
thumbnail_path=self.config.title_jpg_path,
tags=["karaoke", self.config.artist, self.config.title],
replace_existing=True, # Server-side always replaces
)
if video_url:
self.result.youtube_url = video_url
self.job_log.info(f"Uploaded to YouTube: {video_url}")
else:
self.job_log.warning("YouTube upload did not return a URL")
except Exception as e:
self.job_log.error(f"YouTube upload failed: {e}")
# Don't fail the pipeline - YouTube is optional
async def _upload_to_dropbox(self):
"""Upload files to Dropbox."""
self.job_log.info("Uploading to Dropbox")
try:
from backend.services.dropbox_service import get_dropbox_service
dropbox = get_dropbox_service()
if not dropbox.is_configured:
self.job_log.warning("Dropbox not configured, skipping upload")
return
base_name = f"{self.config.artist} - {self.config.title}"
folder_name = f"{self.result.brand_code or 'TRACK-0000'} - {base_name}"
remote_folder = f"{self.config.dropbox_path}/{folder_name}"
# Upload entire output directory
dropbox.upload_folder(self.config.output_dir, remote_folder)
# Create sharing link
try:
sharing_link = dropbox.create_shared_link(remote_folder)
self.result.dropbox_link = sharing_link
self.job_log.info(f"Dropbox sharing link: {sharing_link}")
except Exception as e:
self.job_log.warning(f"Failed to create Dropbox sharing link: {e}")
self.job_log.info("Dropbox upload complete")
except Exception as e:
self.job_log.error(f"Dropbox upload failed: {e}")
# Don't fail the pipeline - Dropbox is optional
async def _upload_to_gdrive(self):
"""Upload files to Google Drive."""
self.job_log.info("Uploading to Google Drive")
try:
from backend.services.gdrive_service import get_gdrive_service
gdrive = get_gdrive_service()
if not gdrive.is_configured:
self.job_log.warning("Google Drive not configured, skipping upload")
return
base_name = f"{self.config.artist} - {self.config.title}"
brand_code = self.result.brand_code or f"{self.config.brand_prefix or 'TRACK'}-0000"
# Map result files to expected keys
output_files = {
'final_karaoke_lossy_mp4': self.result.final_video_lossy,
'final_karaoke_lossy_720p_mp4': self.result.final_video_720p,
'final_karaoke_cdg_zip': self.result.final_karaoke_cdg_zip,
}
uploaded = gdrive.upload_to_public_share(
root_folder_id=self.config.gdrive_folder_id,
brand_code=brand_code,
base_name=base_name,
output_files=output_files,
)
self.result.gdrive_files = uploaded
self.job_log.info(f"Google Drive upload complete: {len(uploaded)} files")
except Exception as e:
self.job_log.error(f"Google Drive upload failed: {e}")
# Don't fail the pipeline - GDrive is optional
async def _run_notifications(self):
"""Run the notifications stage (Discord)."""
self.job_log.info("Starting notifications stage")
if not self.config.discord_webhook_url:
self.job_log.debug("No Discord webhook configured, skipping notification")
return
if not self.result.youtube_url:
self.job_log.info("No YouTube URL available, skipping Discord notification")
return
try:
discord_service = self._get_discord_service()
discord_service.post_video_notification(self.result.youtube_url)
self.job_log.info("Discord notification sent")
except Exception as e:
self.job_log.error(f"Discord notification failed: {e}")
# Don't fail the pipeline - notifications are optional
def create_orchestrator_config_from_job(
job,
temp_dir: str,
youtube_credentials: Optional[Dict[str, Any]] = None,
cdg_styles: Optional[Dict[str, Any]] = None,
) -> OrchestratorConfig:
"""
Create an OrchestratorConfig from a job object.
This is a helper function to bridge the existing job structure
with the new orchestrator configuration.
Args:
job: Job object from Firestore
temp_dir: Temporary directory with downloaded files
youtube_credentials: Pre-loaded YouTube credentials
cdg_styles: CDG style configuration
Returns:
OrchestratorConfig for the orchestrator
"""
base_name = f"{job.artist} - {job.title}"
# Determine instrumental file path
instrumental_selection = job.state_data.get('instrumental_selection', 'clean')
existing_instrumental = getattr(job, 'existing_instrumental_gcs_path', None)
if existing_instrumental:
ext = Path(existing_instrumental).suffix.lower()
instrumental_path = os.path.join(temp_dir, f"{base_name} (Instrumental User){ext}")
else:
instrumental_suffix = "Clean" if instrumental_selection == 'clean' else "Backing"
instrumental_path = os.path.join(temp_dir, f"{base_name} (Instrumental {instrumental_suffix}).flac")
return OrchestratorConfig(
job_id=job.job_id,
artist=job.artist,
title=job.title,
# Input files
title_video_path=os.path.join(temp_dir, f"{base_name} (Title).mov"),
karaoke_video_path=os.path.join(temp_dir, f"{base_name} (With Vocals).mov"),
instrumental_audio_path=instrumental_path,
end_video_path=os.path.join(temp_dir, f"{base_name} (End).mov"),
lrc_file_path=os.path.join(temp_dir, f"{base_name} (Karaoke).lrc"),
title_jpg_path=os.path.join(temp_dir, f"{base_name} (Title).jpg"),
# Output directory
output_dir=temp_dir,
# Feature flags
enable_cdg=getattr(job, 'enable_cdg', False),
enable_txt=getattr(job, 'enable_txt', False),
enable_youtube_upload=getattr(job, 'enable_youtube_upload', False),
# Service configurations
brand_prefix=getattr(job, 'brand_prefix', None),
discord_webhook_url=getattr(job, 'discord_webhook_url', None),
youtube_credentials=youtube_credentials,
youtube_description_template=getattr(job, 'youtube_description_template', None),
cdg_styles=cdg_styles,
# Dropbox/GDrive
dropbox_path=getattr(job, 'dropbox_path', None),
gdrive_folder_id=getattr(job, 'gdrive_folder_id', None),
# Keep existing brand code
keep_brand_code=getattr(job, 'keep_brand_code', None),
# Encoding backend - auto selects GCE if available
encoding_backend="auto",
# Server-side defaults
dry_run=False,
non_interactive=True,
)
+1 -1
View File
@@ -75,7 +75,7 @@ steps:
--concurrency 1 \
--max-instances 50 \
--min-instances 0 \
--set-env-vars "GOOGLE_CLOUD_PROJECT=$PROJECT_ID,GCS_BUCKET_NAME=karaoke-gen-storage-$PROJECT_ID,FIRESTORE_COLLECTION=jobs,ENVIRONMENT=production,AUDIO_SEPARATOR_API_URL=https://nomadkaraoke--audio-separator-api.modal.run,KARAOKE_GEN_VERSION=$$VERSION,DEFAULT_DROPBOX_PATH=/MediaUnsynced/Karaoke/Tracks-Organized,DEFAULT_GDRIVE_FOLDER_ID=1laRKAyxo0v817SstfM5XkpbWiNKNAMSX,ENABLE_CLOUD_TASKS=true,CLOUD_RUN_SERVICE_URL=https://api.nomadkaraoke.com,GCP_REGION=us-central1,DEFAULT_ENABLE_YOUTUBE_UPLOAD=true,DEFAULT_BRAND_PREFIX=NOMAD,USE_CLOUD_RUN_JOBS_FOR_VIDEO=true" \
--set-env-vars "GOOGLE_CLOUD_PROJECT=$PROJECT_ID,GCS_BUCKET_NAME=karaoke-gen-storage-$PROJECT_ID,FIRESTORE_COLLECTION=jobs,ENVIRONMENT=production,AUDIO_SEPARATOR_API_URL=https://nomadkaraoke--audio-separator-api.modal.run,KARAOKE_GEN_VERSION=$$VERSION,DEFAULT_DROPBOX_PATH=/MediaUnsynced/Karaoke/Tracks-Organized,DEFAULT_GDRIVE_FOLDER_ID=1laRKAyxo0v817SstfM5XkpbWiNKNAMSX,ENABLE_CLOUD_TASKS=true,CLOUD_RUN_SERVICE_URL=https://api.nomadkaraoke.com,GCP_REGION=us-central1,DEFAULT_ENABLE_YOUTUBE_UPLOAD=true,DEFAULT_BRAND_PREFIX=NOMAD" \
--set-secrets "AUDIOSHAKE_API_TOKEN=audioshake-api-key:latest,GENIUS_API_TOKEN=genius-api-key:latest,SPOTIFY_COOKIE_SP_DC=spotify-cookie:latest,RAPIDAPI_KEY=rapidapi-key:latest,DEFAULT_DISCORD_WEBHOOK_URL=discord-releases-webhook:latest,ADMIN_TOKENS=admin-tokens:latest,RED_API_KEY=red-api-key:latest,RED_API_URL=red-api-url:latest,OPS_API_KEY=ops-api-key:latest,OPS_API_URL=ops-api-url:latest,FLACFETCH_API_URL=flacfetch-api-url:latest,FLACFETCH_API_KEY=flacfetch-api-key:latest"
images:
File renamed without changes.
File renamed without changes.
Loaded 100 of 317 files, more files were not shown because too many files have changed in this diff. Show more