Compare commits

..
1057 changed files with 16846 additions and 446333 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.
@@ -1,222 +0,0 @@
# Plan: Worker Logs Rearchitecture
**Created:** 2026-01-04
**Branch:** `feat/sess-20260104-1931-logs-research`
**Status:** Implementation Complete - Pending PR Merge & Deployment
## Overview
Move `worker_logs` from embedded array in job documents to a Firestore subcollection to avoid the 1MB document size limit. The current approach caused job 501258e1 to fail when logs reached 1.26 MB (98.6% of document size).
## Problem Statement
- Firestore documents have a 1 MB size limit
- `worker_logs` is stored as an array field within job documents
- Long-running jobs (especially video encoding) can generate thousands of log entries
- When the limit is exceeded, job updates fail with: `Document cannot be written because its size exceeds the maximum allowed size`
## Requirements
- [x] Logs must remain associated with their job
- [x] Logs should be queryable by job_id, worker type, timestamp
- [x] Old logs should auto-cleanup (TTL: 30 days)
- [x] Existing API endpoint (`GET /api/jobs/{id}/logs`) must continue to work
- [x] Frontend must continue to display logs without changes
- [x] Migration path for existing jobs (optional - can just start fresh)
## Technical Approach
### Option A: Subcollection (Recommended)
Store logs in `jobs/{job_id}/logs/{log_id}` subcollection.
**Pros:**
- Natural association with job (delete job = delete logs with cascading)
- Each log entry is its own document (no size limit concerns)
- Can add TTL via Firestore TTL policies
- Efficient queries with composite indexes
**Cons:**
- More Firestore read operations for paginated log fetching
- Slightly more complex write logic
### Option B: Separate Collection
Store logs in `job_logs` collection with `job_id` field.
**Pros:**
- Can query across all jobs
- Simpler TTL management
**Cons:**
- Orphaned logs if job deleted (need cleanup logic)
- Extra index needed for job_id queries
### Decision: Option A (Subcollection)
## Implementation Steps
### Phase 1: Backend Changes
1. [x] **Create log entry model** - `backend/models/worker_log.py`
- `WorkerLogEntry` dataclass with: id, job_id, timestamp, level, worker, message, metadata, ttl_expiry
- Factory method `create()` for easy instantiation
- `to_dict()` for Firestore storage
- `to_legacy_dict()` for API compatibility
- `from_dict()` for Firestore retrieval
2. [x] **Update FirestoreService** - `backend/services/firestore_service.py`
- Added `append_log_to_subcollection(job_id, log_entry)` method
- Added `get_logs_from_subcollection(job_id, limit, since_timestamp, worker, offset)` method
- Added `get_logs_count_from_subcollection(job_id)` method
- Added `delete_logs_subcollection(job_id, batch_size)` method
- Old `append_worker_log` marked as deprecated
3. [x] **Update JobManager** - `backend/services/job_manager.py`
- Modified `append_worker_log()` to use subcollection when `USE_LOG_SUBCOLLECTION=true`
- Modified `get_worker_logs()` to read from subcollection with fallback to embedded array
- Added `get_worker_logs_count()` for total count
- Updated `delete_job()` to clean up logs subcollection
4. [x] **Update jobs API** - `backend/api/routes/jobs.py`
- `GET /api/jobs/{id}/logs` - Updated to use new methods
- Response format stays the same (backward compatible)
- Fixed `next_index` calculation
5. [x] **Add feature flag** - `backend/config.py`
- Added `USE_LOG_SUBCOLLECTION` environment variable (default: true)
6. [x] **Add TTL configuration** - `infrastructure/__main__.py`
- Added Firestore TTL policy for logs subcollection (30 days)
- Added composite index for worker + timestamp queries
### Phase 2: Testing
7. [x] **Unit tests** - `backend/tests/test_worker_log_subcollection.py`
- 24 tests covering:
- WorkerLogEntry model creation and conversion
- FirestoreService subcollection methods
- JobManager logging with feature flag
- Edge cases (unicode, long messages, empty messages)
8. [x] **Integration tests** - `backend/tests/emulator/test_worker_logs_subcollection.py`
- 11 tests using real Firestore emulator:
- Single and sequential writes
- TTL field verification
- Concurrent writes (no race conditions)
- Large volume (500 logs)
- Worker filtering
- Timestamp ordering
- Subcollection deletion
- Concurrent workers interleaved
- Job deletion cleanup
- Comparison with embedded array
### Phase 3: Deployment & Migration
9. [ ] **Deploy with feature flag**
- Add `USE_LOG_SUBCOLLECTION=true` env var (default is true)
- Deploy to production
10. [ ] **Monitor**
- Watch for errors in Cloud Logging
- Verify logs appear in frontend
11. [x] **Backward compatibility**
- Old jobs with embedded arrays still work (fallback in get_worker_logs)
- No migration needed - new jobs use subcollection, old jobs use array
### Phase 4: Cleanup (Future)
12. [ ] **Remove old code path** (after confidence period)
- Remove `worker_logs` field from job model
- Remove old `append_worker_log` method
- Remove feature flag
## Files Created/Modified
| File | Action | Description |
|------|--------|-------------|
| `backend/models/worker_log.py` | Created | WorkerLogEntry dataclass |
| `backend/services/firestore_service.py` | Modified | Added subcollection methods |
| `backend/services/job_manager.py` | Modified | Switch to subcollection with fallback |
| `backend/api/routes/jobs.py` | Modified | Updated logs endpoint |
| `backend/config.py` | Modified | Added USE_LOG_SUBCOLLECTION setting |
| `backend/tests/test_worker_log_subcollection.py` | Created | Unit tests (24 tests) |
| `backend/tests/emulator/test_worker_logs_subcollection.py` | Created | Integration tests (11 tests) |
| `infrastructure/__main__.py` | Modified | Added TTL policy and index |
## Log Entry Schema
```python
@dataclass
class WorkerLogEntry:
timestamp: datetime
level: str # "DEBUG", "INFO", "WARNING", "ERROR"
worker: str # "audio", "lyrics", "video", "render", "screens", "distribution"
message: str
id: str # Auto-generated UUID
job_id: str
ttl_expiry: datetime # timestamp + 30 days
metadata: Optional[Dict[str, Any]] = None
```
## Firestore Structure
```
jobs/
{job_id}/
... (job fields, worker_logs still present for old jobs)
logs/ # subcollection for new jobs
{log_id}/
id: string
job_id: string
timestamp: datetime
level: string
worker: string
message: string
metadata: map (optional)
ttl_expiry: datetime
```
## API Response (Unchanged)
```json
{
"logs": [
{
"timestamp": "2026-01-04T12:00:00Z",
"level": "INFO",
"worker": "video",
"message": "Starting video generation"
}
],
"next_index": 42,
"total_logs": 150
}
```
## Testing Results
All tests pass:
- 24 unit tests in `test_worker_log_subcollection.py`
- 11 emulator integration tests in `test_worker_logs_subcollection.py`
- 68 total tests in emulator suite pass
## Rollback Plan
1. Set `USE_LOG_SUBCOLLECTION=false` env var
2. Redeploy backend
3. New logs will go back to embedded array
4. Subcollection logs will remain but won't be read
## Answers to Open Questions
- [x] **Should we paginate logs in the API?** - Yes, added `offset` parameter support
- [x] **What's the optimal TTL period?** - 30 days (configurable via DEFAULT_LOG_TTL_DAYS)
- [x] **Should we index by timestamp for efficient range queries?** - Yes, added composite index (worker + timestamp)
## References
- [Firestore TTL](https://cloud.google.com/firestore/docs/ttl)
- [Firestore Subcollections](https://firebase.google.com/docs/firestore/data-model#subcollections)
- [Firestore Limits](https://firebase.google.com/docs/firestore/quotas#limits)
- [Pulumi Firestore Field](https://www.pulumi.com/registry/packages/gcp/api-docs/firestore/field/)
-101
View File
@@ -1,101 +0,0 @@
---
description: Perform a non-destructive cross-artifact consistency and quality analysis across spec.md, plan.md, and tasks.md after task generation.
---
The user input to you can be provided directly by the agent or as a command argument - you **MUST** consider it before proceeding with the prompt (if not empty).
User input:
$ARGUMENTS
Goal: Identify inconsistencies, duplications, ambiguities, and underspecified items across the three core artifacts (`spec.md`, `plan.md`, `tasks.md`) before implementation. This command MUST run only after `/tasks` has successfully produced a complete `tasks.md`.
STRICTLY READ-ONLY: Do **not** modify any files. Output a structured analysis report. Offer an optional remediation plan (user must explicitly approve before any follow-up editing commands would be invoked manually).
Constitution Authority: The project constitution (`.specify/memory/constitution.md`) is **non-negotiable** within this analysis scope. Constitution conflicts are automatically CRITICAL and require adjustment of the spec, plan, or tasks—not dilution, reinterpretation, or silent ignoring of the principle. If a principle itself needs to change, that must occur in a separate, explicit constitution update outside `/analyze`.
Execution steps:
1. Run `.specify/scripts/bash/check-prerequisites.sh --json --require-tasks --include-tasks` once from repo root and parse JSON for FEATURE_DIR and AVAILABLE_DOCS. Derive absolute paths:
- SPEC = FEATURE_DIR/spec.md
- PLAN = FEATURE_DIR/plan.md
- TASKS = FEATURE_DIR/tasks.md
Abort with an error message if any required file is missing (instruct the user to run missing prerequisite command).
2. Load artifacts:
- Parse spec.md sections: Overview/Context, Functional Requirements, Non-Functional Requirements, User Stories, Edge Cases (if present).
- Parse plan.md: Architecture/stack choices, Data Model references, Phases, Technical constraints.
- Parse tasks.md: Task IDs, descriptions, phase grouping, parallel markers [P], referenced file paths.
- Load constitution `.specify/memory/constitution.md` for principle validation.
3. Build internal semantic models:
- Requirements inventory: Each functional + non-functional requirement with a stable key (derive slug based on imperative phrase; e.g., "User can upload file" -> `user-can-upload-file`).
- User story/action inventory.
- Task coverage mapping: Map each task to one or more requirements or stories (inference by keyword / explicit reference patterns like IDs or key phrases).
- Constitution rule set: Extract principle names and any MUST/SHOULD normative statements.
4. Detection passes:
A. Duplication detection:
- Identify near-duplicate requirements. Mark lower-quality phrasing for consolidation.
B. Ambiguity detection:
- Flag vague adjectives (fast, scalable, secure, intuitive, robust) lacking measurable criteria.
- Flag unresolved placeholders (TODO, TKTK, ???, <placeholder>, etc.).
C. Underspecification:
- Requirements with verbs but missing object or measurable outcome.
- User stories missing acceptance criteria alignment.
- Tasks referencing files or components not defined in spec/plan.
D. Constitution alignment:
- Any requirement or plan element conflicting with a MUST principle.
- Missing mandated sections or quality gates from constitution.
E. Coverage gaps:
- Requirements with zero associated tasks.
- Tasks with no mapped requirement/story.
- Non-functional requirements not reflected in tasks (e.g., performance, security).
F. Inconsistency:
- Terminology drift (same concept named differently across files).
- Data entities referenced in plan but absent in spec (or vice versa).
- Task ordering contradictions (e.g., integration tasks before foundational setup tasks without dependency note).
- Conflicting requirements (e.g., one requires to use Next.js while other says to use Vue as the framework).
5. Severity assignment heuristic:
- CRITICAL: Violates constitution MUST, missing core spec artifact, or requirement with zero coverage that blocks baseline functionality.
- HIGH: Duplicate or conflicting requirement, ambiguous security/performance attribute, untestable acceptance criterion.
- MEDIUM: Terminology drift, missing non-functional task coverage, underspecified edge case.
- LOW: Style/wording improvements, minor redundancy not affecting execution order.
6. Produce a Markdown report (no file writes) with sections:
### Specification Analysis Report
| ID | Category | Severity | Location(s) | Summary | Recommendation |
|----|----------|----------|-------------|---------|----------------|
| A1 | Duplication | HIGH | spec.md:L120-134 | Two similar requirements ... | Merge phrasing; keep clearer version |
(Add one row per finding; generate stable IDs prefixed by category initial.)
Additional subsections:
- Coverage Summary Table:
| Requirement Key | Has Task? | Task IDs | Notes |
- Constitution Alignment Issues (if any)
- Unmapped Tasks (if any)
- Metrics:
* Total Requirements
* Total Tasks
* Coverage % (requirements with >=1 task)
* Ambiguity Count
* Duplication Count
* Critical Issues Count
7. At end of report, output a concise Next Actions block:
- If CRITICAL issues exist: Recommend resolving before `/implement`.
- If only LOW/MEDIUM: User may proceed, but provide improvement suggestions.
- Provide explicit command suggestions: e.g., "Run /specify with refinement", "Run /plan to adjust architecture", "Manually edit tasks.md to add coverage for 'performance-metrics'".
8. Ask the user: "Would you like me to suggest concrete remediation edits for the top N issues?" (Do NOT apply them automatically.)
Behavior rules:
- NEVER modify files.
- NEVER hallucinate missing sections—if absent, report them.
- KEEP findings deterministic: if rerun without changes, produce consistent IDs and counts.
- LIMIT total findings in the main table to 50; aggregate remainder in a summarized overflow note.
- If zero issues found, emit a success report with coverage statistics and proceed recommendation.
Context: $ARGUMENTS
-158
View File
@@ -1,158 +0,0 @@
---
description: Identify underspecified areas in the current feature spec by asking up to 5 highly targeted clarification questions and encoding answers back into the spec.
---
The user input to you can be provided directly by the agent or as a command argument - you **MUST** consider it before proceeding with the prompt (if not empty).
User input:
$ARGUMENTS
Goal: Detect and reduce ambiguity or missing decision points in the active feature specification and record the clarifications directly in the spec file.
Note: This clarification workflow is expected to run (and be completed) BEFORE invoking `/plan`. If the user explicitly states they are skipping clarification (e.g., exploratory spike), you may proceed, but must warn that downstream rework risk increases.
Execution steps:
1. Run `.specify/scripts/bash/check-prerequisites.sh --json --paths-only` from repo root **once** (combined `--json --paths-only` mode / `-Json -PathsOnly`). Parse minimal JSON payload fields:
- `FEATURE_DIR`
- `FEATURE_SPEC`
- (Optionally capture `IMPL_PLAN`, `TASKS` for future chained flows.)
- If JSON parsing fails, abort and instruct user to re-run `/specify` or verify feature branch environment.
2. Load the current spec file. Perform a structured ambiguity & coverage scan using this taxonomy. For each category, mark status: Clear / Partial / Missing. Produce an internal coverage map used for prioritization (do not output raw map unless no questions will be asked).
Functional Scope & Behavior:
- Core user goals & success criteria
- Explicit out-of-scope declarations
- User roles / personas differentiation
Domain & Data Model:
- Entities, attributes, relationships
- Identity & uniqueness rules
- Lifecycle/state transitions
- Data volume / scale assumptions
Interaction & UX Flow:
- Critical user journeys / sequences
- Error/empty/loading states
- Accessibility or localization notes
Non-Functional Quality Attributes:
- Performance (latency, throughput targets)
- Scalability (horizontal/vertical, limits)
- Reliability & availability (uptime, recovery expectations)
- Observability (logging, metrics, tracing signals)
- Security & privacy (authN/Z, data protection, threat assumptions)
- Compliance / regulatory constraints (if any)
Integration & External Dependencies:
- External services/APIs and failure modes
- Data import/export formats
- Protocol/versioning assumptions
Edge Cases & Failure Handling:
- Negative scenarios
- Rate limiting / throttling
- Conflict resolution (e.g., concurrent edits)
Constraints & Tradeoffs:
- Technical constraints (language, storage, hosting)
- Explicit tradeoffs or rejected alternatives
Terminology & Consistency:
- Canonical glossary terms
- Avoided synonyms / deprecated terms
Completion Signals:
- Acceptance criteria testability
- Measurable Definition of Done style indicators
Misc / Placeholders:
- TODO markers / unresolved decisions
- Ambiguous adjectives ("robust", "intuitive") lacking quantification
For each category with Partial or Missing status, add a candidate question opportunity unless:
- Clarification would not materially change implementation or validation strategy
- Information is better deferred to planning phase (note internally)
3. Generate (internally) a prioritized queue of candidate clarification questions (maximum 5). Do NOT output them all at once. Apply these constraints:
- Maximum of 5 total questions across the whole session.
- Each question must be answerable with EITHER:
* A short multiple‑choice selection (2–5 distinct, mutually exclusive options), OR
* A one-word / short‑phrase answer (explicitly constrain: "Answer in <=5 words").
- Only include questions whose answers materially impact architecture, data modeling, task decomposition, test design, UX behavior, operational readiness, or compliance validation.
- Ensure category coverage balance: attempt to cover the highest impact unresolved categories first; avoid asking two low-impact questions when a single high-impact area (e.g., security posture) is unresolved.
- Exclude questions already answered, trivial stylistic preferences, or plan-level execution details (unless blocking correctness).
- Favor clarifications that reduce downstream rework risk or prevent misaligned acceptance tests.
- If more than 5 categories remain unresolved, select the top 5 by (Impact * Uncertainty) heuristic.
4. Sequential questioning loop (interactive):
- Present EXACTLY ONE question at a time.
- For multiple‑choice questions render options as a Markdown table:
| Option | Description |
|--------|-------------|
| A | <Option A description> |
| B | <Option B description> |
| C | <Option C description> | (add D/E as needed up to 5)
| Short | Provide a different short answer (<=5 words) | (Include only if free-form alternative is appropriate)
- For short‑answer style (no meaningful discrete options), output a single line after the question: `Format: Short answer (<=5 words)`.
- After the user answers:
* Validate the answer maps to one option or fits the <=5 word constraint.
* If ambiguous, ask for a quick disambiguation (count still belongs to same question; do not advance).
* Once satisfactory, record it in working memory (do not yet write to disk) and move to the next queued question.
- Stop asking further questions when:
* All critical ambiguities resolved early (remaining queued items become unnecessary), OR
* User signals completion ("done", "good", "no more"), OR
* You reach 5 asked questions.
- Never reveal future queued questions in advance.
- If no valid questions exist at start, immediately report no critical ambiguities.
5. Integration after EACH accepted answer (incremental update approach):
- Maintain in-memory representation of the spec (loaded once at start) plus the raw file contents.
- For the first integrated answer in this session:
* Ensure a `## Clarifications` section exists (create it just after the highest-level contextual/overview section per the spec template if missing).
* Under it, create (if not present) a `### Session YYYY-MM-DD` subheading for today.
- Append a bullet line immediately after acceptance: `- Q: <question> → A: <final answer>`.
- Then immediately apply the clarification to the most appropriate section(s):
* Functional ambiguity → Update or add a bullet in Functional Requirements.
* User interaction / actor distinction → Update User Stories or Actors subsection (if present) with clarified role, constraint, or scenario.
* Data shape / entities → Update Data Model (add fields, types, relationships) preserving ordering; note added constraints succinctly.
* Non-functional constraint → Add/modify measurable criteria in Non-Functional / Quality Attributes section (convert vague adjective to metric or explicit target).
* Edge case / negative flow → Add a new bullet under Edge Cases / Error Handling (or create such subsection if template provides placeholder for it).
* Terminology conflict → Normalize term across spec; retain original only if necessary by adding `(formerly referred to as "X")` once.
- If the clarification invalidates an earlier ambiguous statement, replace that statement instead of duplicating; leave no obsolete contradictory text.
- Save the spec file AFTER each integration to minimize risk of context loss (atomic overwrite).
- Preserve formatting: do not reorder unrelated sections; keep heading hierarchy intact.
- Keep each inserted clarification minimal and testable (avoid narrative drift).
6. Validation (performed after EACH write plus final pass):
- Clarifications session contains exactly one bullet per accepted answer (no duplicates).
- Total asked (accepted) questions ≤ 5.
- Updated sections contain no lingering vague placeholders the new answer was meant to resolve.
- No contradictory earlier statement remains (scan for now-invalid alternative choices removed).
- Markdown structure valid; only allowed new headings: `## Clarifications`, `### Session YYYY-MM-DD`.
- Terminology consistency: same canonical term used across all updated sections.
7. Write the updated spec back to `FEATURE_SPEC`.
8. Report completion (after questioning loop ends or early termination):
- Number of questions asked & answered.
- Path to updated spec.
- Sections touched (list names).
- Coverage summary table listing each taxonomy category with Status: Resolved (was Partial/Missing and addressed), Deferred (exceeds question quota or better suited for planning), Clear (already sufficient), Outstanding (still Partial/Missing but low impact).
- If any Outstanding or Deferred remain, recommend whether to proceed to `/plan` or run `/clarify` again later post-plan.
- Suggested next command.
Behavior rules:
- If no meaningful ambiguities found (or all potential questions would be low-impact), respond: "No critical ambiguities detected worth formal clarification." and suggest proceeding.
- If spec file missing, instruct user to run `/specify` first (do not create a new spec here).
- Never exceed 5 total asked questions (clarification retries for a single question do not count as new questions).
- Avoid speculative tech stack questions unless the absence blocks functional clarity.
- Respect user early termination signals ("stop", "done", "proceed").
- If no questions asked due to full coverage, output a compact coverage summary (all categories Clear) then suggest advancing.
- If quota reached with unresolved high-impact categories remaining, explicitly flag them under Deferred with rationale.
Context for prioritization: $ARGUMENTS
-73
View File
@@ -1,73 +0,0 @@
---
description: Create or update the project constitution from interactive or provided principle inputs, ensuring all dependent templates stay in sync.
---
The user input to you can be provided directly by the agent or as a command argument - you **MUST** consider it before proceeding with the prompt (if not empty).
User input:
$ARGUMENTS
You are updating the project constitution at `.specify/memory/constitution.md`. This file is a TEMPLATE containing placeholder tokens in square brackets (e.g. `[PROJECT_NAME]`, `[PRINCIPLE_1_NAME]`). Your job is to (a) collect/derive concrete values, (b) fill the template precisely, and (c) propagate any amendments across dependent artifacts.
Follow this execution flow:
1. Load the existing constitution template at `.specify/memory/constitution.md`.
- Identify every placeholder token of the form `[ALL_CAPS_IDENTIFIER]`.
**IMPORTANT**: The user might require less or more principles than the ones used in the template. If a number is specified, respect that - follow the general template. You will update the doc accordingly.
2. Collect/derive values for placeholders:
- If user input (conversation) supplies a value, use it.
- Otherwise infer from existing repo context (README, docs, prior constitution versions if embedded).
- For governance dates: `RATIFICATION_DATE` is the original adoption date (if unknown ask or mark TODO), `LAST_AMENDED_DATE` is today if changes are made, otherwise keep previous.
- `CONSTITUTION_VERSION` must increment according to semantic versioning rules:
* MAJOR: Backward incompatible governance/principle removals or redefinitions.
* MINOR: New principle/section added or materially expanded guidance.
* PATCH: Clarifications, wording, typo fixes, non-semantic refinements.
- If version bump type ambiguous, propose reasoning before finalizing.
3. Draft the updated constitution content:
- Replace every placeholder with concrete text (no bracketed tokens left except intentionally retained template slots that the project has chosen not to define yet—explicitly justify any left).
- Preserve heading hierarchy and comments can be removed once replaced unless they still add clarifying guidance.
- Ensure each Principle section: succinct name line, paragraph (or bullet list) capturing non‑negotiable rules, explicit rationale if not obvious.
- Ensure Governance section lists amendment procedure, versioning policy, and compliance review expectations.
4. Consistency propagation checklist (convert prior checklist into active validations):
- Read `.specify/templates/plan-template.md` and ensure any "Constitution Check" or rules align with updated principles.
- Read `.specify/templates/spec-template.md` for scope/requirements alignment—update if constitution adds/removes mandatory sections or constraints.
- Read `.specify/templates/tasks-template.md` and ensure task categorization reflects new or removed principle-driven task types (e.g., observability, versioning, testing discipline).
- Read each command file in `.specify/templates/commands/*.md` (including this one) to verify no outdated references (agent-specific names like CLAUDE only) remain when generic guidance is required.
- Read any runtime guidance docs (e.g., `README.md`, `docs/quickstart.md`, or agent-specific guidance files if present). Update references to principles changed.
5. Produce a Sync Impact Report (prepend as an HTML comment at top of the constitution file after update):
- Version change: old → new
- List of modified principles (old title → new title if renamed)
- Added sections
- Removed sections
- Templates requiring updates (✅ updated / ⚠ pending) with file paths
- Follow-up TODOs if any placeholders intentionally deferred.
6. Validation before final output:
- No remaining unexplained bracket tokens.
- Version line matches report.
- Dates ISO format YYYY-MM-DD.
- Principles are declarative, testable, and free of vague language ("should" → replace with MUST/SHOULD rationale where appropriate).
7. Write the completed constitution back to `.specify/memory/constitution.md` (overwrite).
8. Output a final summary to the user with:
- New version and bump rationale.
- Any files flagged for manual follow-up.
- Suggested commit message (e.g., `docs: amend constitution to vX.Y.Z (principle additions + governance update)`).
Formatting & Style Requirements:
- Use Markdown headings exactly as in the template (do not demote/promote levels).
- Wrap long rationale lines to keep readability (<100 chars ideally) but do not hard enforce with awkward breaks.
- Keep a single blank line between sections.
- Avoid trailing whitespace.
If the user supplies partial updates (e.g., only one principle revision), still perform validation and version decision steps.
If critical info missing (e.g., ratification date truly unknown), insert `TODO(<FIELD_NAME>): explanation` and include in the Sync Impact Report under deferred items.
Do not create a new template; always operate on the existing `.specify/memory/constitution.md` file.
-56
View File
@@ -1,56 +0,0 @@
---
description: Execute the implementation plan by processing and executing all tasks defined in tasks.md
---
The user input can be provided directly by the agent or as a command argument - you **MUST** consider it before proceeding with the prompt (if not empty).
User input:
$ARGUMENTS
1. Run `.specify/scripts/bash/check-prerequisites.sh --json --require-tasks --include-tasks` from repo root and parse FEATURE_DIR and AVAILABLE_DOCS list. All paths must be absolute.
2. Load and analyze the implementation context:
- **REQUIRED**: Read tasks.md for the complete task list and execution plan
- **REQUIRED**: Read plan.md for tech stack, architecture, and file structure
- **IF EXISTS**: Read data-model.md for entities and relationships
- **IF EXISTS**: Read contracts/ for API specifications and test requirements
- **IF EXISTS**: Read research.md for technical decisions and constraints
- **IF EXISTS**: Read quickstart.md for integration scenarios
3. Parse tasks.md structure and extract:
- **Task phases**: Setup, Tests, Core, Integration, Polish
- **Task dependencies**: Sequential vs parallel execution rules
- **Task details**: ID, description, file paths, parallel markers [P]
- **Execution flow**: Order and dependency requirements
4. Execute implementation following the task plan:
- **Phase-by-phase execution**: Complete each phase before moving to the next
- **Respect dependencies**: Run sequential tasks in order, parallel tasks [P] can run together
- **Follow TDD approach**: Execute test tasks before their corresponding implementation tasks
- **File-based coordination**: Tasks affecting the same files must run sequentially
- **Validation checkpoints**: Verify each phase completion before proceeding
5. Implementation execution rules:
- **Setup first**: Initialize project structure, dependencies, configuration
- **Tests before code**: If you need to write tests for contracts, entities, and integration scenarios
- **Core development**: Implement models, services, CLI commands, endpoints
- **Integration work**: Database connections, middleware, logging, external services
- **Polish and validation**: Unit tests, performance optimization, documentation
6. Progress tracking and error handling:
- Report progress after each completed task
- Halt execution if any non-parallel task fails
- For parallel tasks [P], continue with successful tasks, report failed ones
- Provide clear error messages with context for debugging
- Suggest next steps if implementation cannot proceed
- **IMPORTANT** For completed tasks, make sure to mark the task off as [X] in the tasks file.
7. Completion validation:
- Verify all required tasks are completed
- Check that implemented features match the original specification
- Validate that tests pass and coverage meets requirements
- Confirm the implementation follows the technical plan
- Report final status with summary of completed work
Note: This command assumes a complete task breakdown exists in tasks.md. If tasks are incomplete or missing, suggest running `/tasks` first to regenerate the task list.
-43
View File
@@ -1,43 +0,0 @@
---
description: Execute the implementation planning workflow using the plan template to generate design artifacts.
---
The user input to you can be provided directly by the agent or as a command argument - you **MUST** consider it before proceeding with the prompt (if not empty).
User input:
$ARGUMENTS
Given the implementation details provided as an argument, do this:
1. Run `.specify/scripts/bash/setup-plan.sh --json` from the repo root and parse JSON for FEATURE_SPEC, IMPL_PLAN, SPECS_DIR, BRANCH. All future file paths must be absolute.
- BEFORE proceeding, inspect FEATURE_SPEC for a `## Clarifications` section with at least one `Session` subheading. If missing or clearly ambiguous areas remain (vague adjectives, unresolved critical choices), PAUSE and instruct the user to run `/clarify` first to reduce rework. Only continue if: (a) Clarifications exist OR (b) an explicit user override is provided (e.g., "proceed without clarification"). Do not attempt to fabricate clarifications yourself.
2. Read and analyze the feature specification to understand:
- The feature requirements and user stories
- Functional and non-functional requirements
- Success criteria and acceptance criteria
- Any technical constraints or dependencies mentioned
3. Read the constitution at `.specify/memory/constitution.md` to understand constitutional requirements.
4. Execute the implementation plan template:
- Load `.specify/templates/plan-template.md` (already copied to IMPL_PLAN path)
- Set Input path to FEATURE_SPEC
- Run the Execution Flow (main) function steps 1-9
- The template is self-contained and executable
- Follow error handling and gate checks as specified
- Let the template guide artifact generation in $SPECS_DIR:
* Phase 0 generates research.md
* Phase 1 generates data-model.md, contracts/, quickstart.md
* Phase 2 generates tasks.md
- Incorporate user-provided details from arguments into Technical Context: $ARGUMENTS
- Update Progress Tracking as you complete each phase
5. Verify execution completed:
- Check Progress Tracking shows all phases complete
- Ensure all required artifacts were generated
- Confirm no ERROR states in execution
6. Report results with branch name, file paths, and generated artifacts.
Use absolute paths with the repository root for all file operations to avoid path issues.
-21
View File
@@ -1,21 +0,0 @@
---
description: Create or update the feature specification from a natural language feature description.
---
The user input to you can be provided directly by the agent or as a command argument - you **MUST** consider it before proceeding with the prompt (if not empty).
User input:
$ARGUMENTS
The text the user typed after `/specify` in the triggering message **is** the feature description. Assume you always have it available in this conversation even if `$ARGUMENTS` appears literally below. Do not ask the user to repeat it unless they provided an empty command.
Given that feature description, do this:
1. Run the script `.specify/scripts/bash/create-new-feature.sh --json "$ARGUMENTS"` from repo root and parse its JSON output for BRANCH_NAME and SPEC_FILE. All file paths must be absolute.
**IMPORTANT** You must only ever run this script once. The JSON is provided in the terminal as output - always refer to it to get the actual content you're looking for.
2. Load `.specify/templates/spec-template.md` to understand required sections.
3. Write the specification to SPEC_FILE using the template structure, replacing placeholders with concrete details derived from the feature description (arguments) while preserving section order and headings.
4. Report completion with branch name, spec file path, and readiness for the next phase.
Note: The script creates and checks out the new branch and initializes the spec file before writing.
-62
View File
@@ -1,62 +0,0 @@
---
description: Generate an actionable, dependency-ordered tasks.md for the feature based on available design artifacts.
---
The user input to you can be provided directly by the agent or as a command argument - you **MUST** consider it before proceeding with the prompt (if not empty).
User input:
$ARGUMENTS
1. Run `.specify/scripts/bash/check-prerequisites.sh --json` from repo root and parse FEATURE_DIR and AVAILABLE_DOCS list. All paths must be absolute.
2. Load and analyze available design documents:
- Always read plan.md for tech stack and libraries
- IF EXISTS: Read data-model.md for entities
- IF EXISTS: Read contracts/ for API endpoints
- IF EXISTS: Read research.md for technical decisions
- IF EXISTS: Read quickstart.md for test scenarios
Note: Not all projects have all documents. For example:
- CLI tools might not have contracts/
- Simple libraries might not need data-model.md
- Generate tasks based on what's available
3. Generate tasks following the template:
- Use `.specify/templates/tasks-template.md` as the base
- Replace example tasks with actual tasks based on:
* **Setup tasks**: Project init, dependencies, linting
* **Test tasks [P]**: One per contract, one per integration scenario
* **Core tasks**: One per entity, service, CLI command, endpoint
* **Integration tasks**: DB connections, middleware, logging
* **Polish tasks [P]**: Unit tests, performance, docs
4. Task generation rules:
- Each contract file → contract test task marked [P]
- Each entity in data-model → model creation task marked [P]
- Each endpoint → implementation task (not parallel if shared files)
- Each user story → integration test marked [P]
- Different files = can be parallel [P]
- Same file = sequential (no [P])
5. Order tasks by dependencies:
- Setup before everything
- Tests before implementation (TDD)
- Models before services
- Services before endpoints
- Core before integration
- Everything before polish
6. Include parallel execution examples:
- Group [P] tasks that can run together
- Show actual Task agent commands
7. Create FEATURE_DIR/tasks.md with:
- Correct feature name from implementation plan
- Numbered tasks (T001, T002, etc.)
- Clear file paths for each task
- Dependency notes
- Parallel execution guidance
Context for task generation: $ARGUMENTS
The tasks.md should be immediately executable - each task must be specific enough that an LLM can complete it without additional context.
@@ -1,368 +0,0 @@
---
name: Anchor Sequence Optimization
overview: Replace the current multiprocessing-based anchor sequence algorithm with an efficient single-threaded implementation using hash-based n-gram indexing, greedy longest-first matching, and simplified scoring to achieve sub-30-second performance in both local and cloud environments.
todos:
- id: create-golden-fixtures
content: Create script to generate 10 golden test fixtures from representative song data (varying lengths/complexity), run current algorithm to capture expected anchor outputs
status: completed
- id: create-golden-test
content: Create test_anchor_sequence_golden.py with regression tests that verify anchor finder output matches fixtures, ensure tests pass with current implementation before any changes
status: completed
- id: remove-multiprocessing
content: Remove multiprocessing.Pool from find_anchors() and _remove_overlapping_sequences(), replace with single-threaded loops
status: completed
- id: build-ngram-index
content: Add _build_ngram_index() method to create hash-based lookup table for O(1) n-gram matching
status: completed
- id: greedy-skip
content: Add covered_positions set tracking and skip logic to avoid processing overlapping n-grams
status: completed
- id: simple-scoring
content: Add _simple_score_anchor() with rule-based heuristics, make spaCy scoring optional via use_nlp_scoring flag
status: completed
- id: optimize-overlap
content: Replace O(n^2) overlap removal with O(n log n) sorted single-pass algorithm
status: completed
- id: add-perf-tests
content: Add performance benchmark test asserting <30 second completion for all fixture sizes
status: pending
---
# Anchor Sequence Algorithm Optimization
## Problem Analysis
The current `AnchorSequenceFinder` has critical performance issues:
### Root Causes of Hanging
1. **Multiprocessing Pool with fork()**: Python's `Pool()` uses `fork()` on Linux, which causes deadlocks in Cloud Run containers
2. **spaCy model loading in forked processes**: The `PhraseAnalyzer` loads spaCy's `en_core_web_sm` model, which can hang when forked
3. **Pool creation blocking**: The hang occurs before job submission, so timeout checks never trigger
### Algorithmic Inefficiencies
1. **O(n^2) n-gram matching**: Linear search through references for each n-gram
2. **Redundant work**: Processes all n-gram lengths (3 to ~30) even though longer matches are preferred
3. **O(n^2) overlap removal**: Each anchor checked against all previous anchors
4. **Expensive phrase scoring**: spaCy NLP called twice per anchor (phrase + context)
## Proposed Solution: Hash-Based Greedy Algorithm
### Core Algorithm Changes
**1. Hash-Based N-gram Index (O(1) lookup instead of O(n))**
- Pre-build a dictionary mapping n-grams to their positions in each reference
- Use tuple of cleaned words as key for O(1) lookup
- Build index once during preprocessing
**2. Greedy Longest-First Matching**
- Process n-gram lengths from longest to shortest (current behavior)
- BUT: Skip positions already covered by longer anchors immediately
- Use a "covered positions" set to avoid redundant work
**3. Single-Threaded Processing**
- Remove all `multiprocessing.Pool` usage
- Use efficient algorithms instead of parallelism
- Works identically in local and cloud environments
**4. Simplified Phrase Scoring (Optional)**
- Make spaCy-based scoring optional via configuration flag
- Default to rule-based heuristic scoring:
- Prefer sequences starting/ending at word boundaries
- Prefer sequences matching more reference sources
- Prefer longer sequences
- Option to enable full NLP scoring for higher-quality results offline
**5. O(n log n) Overlap Removal**
- Sort anchors by position
- Single pass with interval tracking using sorted list
- Skip anchors that overlap with any already-selected anchor
### New Data Structures
```python
# N-gram index: maps (word1, word2, ...) -> {source: [positions]}
ngram_index: Dict[Tuple[str, ...], Dict[str, List[int]]]
# Covered positions in transcription (for greedy skip)
covered_trans_positions: Set[int]
```
### Performance Targets
- **Target**: Complete in under 30 seconds for any song
- **Typical song**: 200-400 words, 3 reference sources
- **Expected performance**: 1-5 seconds for typical inputs
## Implementation Plan
### Execution Order (Critical)
1. **Phase 0**: Create golden test fixtures and verify tests pass with current code
2. **Phase 1-5**: Implement optimizations incrementally, running golden tests after each phase
3. **Final**: Add performance benchmarks
### Files to Create/Modify
- `lyrics_transcriber_temp/scripts/generate_anchor_fixtures.py` (new)
- `lyrics_transcriber_temp/tests/fixtures/anchor_golden/*.json` (new)
- `lyrics_transcriber_temp/tests/unit/correction/test_anchor_sequence_golden.py` (new)
- `lyrics_transcriber_temp/lyrics_transcriber/correction/anchor_sequence.py` (modify)
### Key Changes
**Phase 0: Golden Test Setup** (MUST complete and pass before any algorithm changes)
- Create fixture generation script with 10 representative test cases
- Run script to generate fixtures using current implementation
- Create golden test file that loads fixtures and verifies outputs
- Verify all golden tests pass with current code
**Phase 1: Remove Multiprocessing**
- Replace `Pool().apply_async()` with direct function calls
- Remove all pool creation, cleanup, and timeout handling
- Single-threaded loop through n-gram lengths
**Phase 2: Add Hash-Based Index**
- New method `_build_ngram_index()` that builds lookup table during preprocessing
- Modify `_find_matching_sources()` to use O(1) index lookup
- Index built once, shared across all n-gram length iterations
**Phase 3: Greedy Position Skipping**
- Track covered transcription positions in a set
- Skip n-grams that start in already-covered positions
- Reduces redundant work significantly for songs with good matches
**Phase 4: Simplify Scoring**
- Add `use_nlp_scoring: bool = False` parameter to constructor
- New method `_simple_score_anchor()` using rule-based heuristics
- Keep spaCy scoring available for offline/high-quality mode
**Phase 5: Optimize Overlap Removal**
- Sort anchors by (start_position, -length)
- Single pass: keep anchor if no overlap with last kept anchor
- O(n log n) total instead of O(n^2)
## API Compatibility
The public interface remains unchanged:
- `find_anchors(transcribed, references, transcription_result) -> List[ScoredAnchor]`
- `find_gaps(transcribed, anchors, references, transcription_result) -> List[GapSequence]`
New optional constructor parameters:
- `use_nlp_scoring: bool = False` - Enable spaCy-based phrase scoring (slower but higher quality)
- Timeout parameter retained but less critical with efficient algorithm
## Fallback Strategy
If performance is still insufficient for edge cases:
1. **Early termination**: Stop after finding sufficient coverage (e.g., 80% of words anchored)
2. **Adaptive n-gram range**: Start with medium lengths (8-15), expand only if needed
3. **Sampling**: For very long songs, sample n-gram positions instead of exhaustive search
## Phase 0: Golden Test Setup (BEFORE any algorithm changes)
### Goal
Create regression tests using REAL song data from local cache to verify the optimized algorithm produces equivalent results.
### Cache File Structure (Understanding)
The local cache at `~/lyrics-transcriber-cache/` contains:
- **Reference lyrics**: `{provider}_{hash}_converted.json` where provider is spotify/genius/lrclib/musixmatch
- Hash is based on (artist, title) lookup - same song shares same hash across providers
- `_raw.json` contains metadata (track name, artist)
- `_converted.json` contains LyricsData structure with segments/words
- **Transcriptions**: `audioshake_{hash}_converted.json`
- Hash is based on audio file content (different from reference hash)
- Contains TranscriptionData structure
- **Anchor results**: `anchors_{hash}.json`
- Hash is computed from combined inputs (transcription + all references)
### Manual Song Selection
Identify 10 songs from cache with good coverage. Search raw files for track names:
### Finding Song Mappings
To link audioshake transcriptions to reference lyrics, search cache files:
```bash
# Find songs by searching raw files for track names
grep -h "trackName" ~/lyrics-transcriber-cache/spotify_*_raw.json | head -20
# Find audioshake files for a known song (e.g., search for filename patterns)
ls ~/lyrics-transcriber-cache/audioshake_*_raw.json | head -20
# Search converted files for specific lyrics text
grep -l "Napoleon did surrender" ~/lyrics-transcriber-cache/*_converted.json
```
**Target song list** (reference_hash to be paired with audioshake_hash):
1. ABBA - Waterloo (refs: 3365f6a1e42388d84bcbfc0ac6f8aa6c) - short, repetitive chorus
2. The Format - Time Bomb (refs: 3a3802ec28c4ab6689909b7ef784bb6f) - medium length
3. Rancid - Time Bomb (refs: d02d20b854cbc6b890f274bd6c278752) - fast punk lyrics
4. Minutemen - Storm in My House (refs: bc625704b26b307d8680ae5235b74994) - short
5. + 6 more songs to be identified during fixture generation by exploring cache
### Fixture Generation Script
Create `lyrics_transcriber_temp/scripts/generate_anchor_fixtures.py`:
```python
# Input: List of (name, audioshake_hash, reference_hash) tuples
# For each:
# 1. Load audioshake_{hash}_converted.json as transcription
# 2. Load {spotify,genius,lrclib}_{hash}_converted.json as references
# 3. Run current AnchorSequenceFinder
# 4. Save complete fixture with inputs + outputs
```
The script will:
1. Accept a config file listing the 10 song mappings
2. Load real LyricsData from cache files
3. Run the CURRENT AnchorSequenceFinder implementation
4. Save fixtures that capture the real behavior
### Fixture Format
```
lyrics_transcriber_temp/tests/fixtures/anchor_golden/
- waterloo_abba.json
- time_bomb_format.json
- time_bomb_rancid.json
- ...
```
Each fixture contains REAL data:
```json
{
"name": "waterloo_abba",
"description": "ABBA - Waterloo, short song with repetitive chorus",
"source_hashes": {
"audioshake": "1654b7c0755fad7f23bc888308f274de",
"references": "3365f6a1e42388d84bcbfc0ac6f8aa6c"
},
"transcription": {
"segments": [...], // Full LyricsData from audioshake cache
"word_count": 150
},
"references": {
"spotify": { "segments": [...] },
"genius": { "segments": [...] },
"lrclib": { "segments": [...] }
},
"expected_anchors": [
{
"text": "My my at Waterloo Napoleon did surrender",
"transcription_position": 0,
"length": 7,
"reference_positions": {"spotify": 0, "genius": 0, "lrclib": 0},
"confidence": 1.0
},
// ... all anchors from current implementation
],
"expected_anchor_count": 25,
"expected_word_coverage": 142,
"expected_coverage_percent": 94.6
}
```
### Golden Test
Create `lyrics_transcriber_temp/tests/unit/correction/test_anchor_sequence_golden.py`:
```python
import pytest
import json
from pathlib import Path
FIXTURES_DIR = Path(__file__).parent.parent.parent / "fixtures" / "anchor_golden"
@pytest.fixture(params=list(FIXTURES_DIR.glob("*.json")))
def golden_fixture(request):
with open(request.param) as f:
return json.load(f)
def test_anchor_count_matches(golden_fixture, anchor_finder):
"""Anchor count should be within 10% of expected."""
anchors = run_anchor_finder(golden_fixture)
expected = golden_fixture["expected_anchor_count"]
assert abs(len(anchors) - expected) <= expected * 0.1
def test_key_anchors_match(golden_fixture, anchor_finder):
"""First, last, and longest anchors should match exactly."""
anchors = run_anchor_finder(golden_fixture)
expected = golden_fixture["expected_anchors"]
# Compare first anchor
assert anchors[0].text == expected[0]["text"]
# Compare positions match
...
def test_word_coverage(golden_fixture, anchor_finder):
"""Total word coverage should be within 5% of expected."""
anchors = run_anchor_finder(golden_fixture)
coverage = calculate_coverage(anchors, golden_fixture)
expected = golden_fixture["expected_coverage_percent"]
assert abs(coverage - expected) <= 5.0
def test_no_invalid_positions(golden_fixture, anchor_finder):
"""All anchor positions should be valid."""
anchors = run_anchor_finder(golden_fixture)
word_count = golden_fixture["transcription"]["word_count"]
for anchor in anchors:
assert 0 <= anchor.transcription_position < word_count
```
### Validation Steps
1. **Generate fixtures from current implementation**:
```bash
cd lyrics_transcriber_temp
python scripts/generate_anchor_fixtures.py
```
2. **Verify fixtures were created**:
```bash
ls tests/fixtures/anchor_golden/
# Should show 10 .json files
```
3. **Run golden tests with CURRENT implementation**:
```bash
pytest tests/unit/correction/test_anchor_sequence_golden.py -v
```
4. **All tests MUST pass before any algorithm changes**
5. **After each optimization phase, re-run golden tests**:
```bash
pytest tests/unit/correction/test_anchor_sequence_golden.py -v
# Must still pass!
```
## Testing (Post-Optimization)
- Golden tests verify correctness (same outputs as before)
- Existing unit tests verify API compatibility
- Performance benchmark test with 30-second timeout assertion
- Test with various song lengths via golden fixtures
@@ -1,717 +0,0 @@
---
name: Instrumental Review UI
overview: Add an intelligent instrumental selection workflow with audio analysis, waveform visualization, playback controls, and the ability to mute sections of backing vocals to create custom instrumentals. This replaces the current text-only CLI prompt with a web UI that works for both local and remote workflows, with shared core logic for DRY/maintainable code.
todos:
- id: shared-core-module
content: Create karaoke_gen/instrumental_review/ shared module with AudioAnalyzer and AudioEditor classes (used by both local and remote)
status: completed
- id: shared-core-tests
content: Add comprehensive unit tests for shared module with >80% coverage (tests/unit/test_instrumental_review.py)
status: completed
- id: backend-services
content: Create backend service wrappers that use shared core module (audio_analysis_service.py, audio_editing_service.py)
status: completed
- id: backend-services-tests
content: Add unit tests for backend services with mocked GCS interactions (backend/tests/test_audio_services.py)
status: completed
- id: api-endpoints
content: Add new API endpoints for analysis, audio streaming, and custom instrumental creation
status: completed
- id: api-endpoints-tests
content: Add API endpoint tests with >80% coverage (backend/tests/test_instrumental_api.py)
status: completed
- id: render-worker-integration
content: Integrate audio analysis into render_video_worker before transitioning to awaiting_instrumental_selection
status: completed
- id: render-worker-tests
content: Add/update render_video_worker tests to cover new analysis integration
status: completed
- id: frontend-components
content: Create React components (WaveformDisplay, AudioPlayer, RegionSelector, InstrumentalReviewPage)
status: completed
- id: local-cli-integration
content: Update local gen_cli.py to use shared core module with local file paths (feature parity with remote)
status: completed
- id: local-cli-review-server
content: Add lightweight review server to local CLI for browser-based review (similar to lyrics review pattern)
status: completed
- id: remote-cli-update
content: Update remote_cli.py to use new analysis API and open browser for review
status: completed
- id: cli-tests
content: Add CLI tests verifying feature parity between local and remote modes
status: completed
- id: integration-tests
content: Add end-to-end integration tests for the full instrumental review workflow
status: completed
---
# Intelligent Instrumental Selection Plan
## Current State
The instrumental selection workflow currently:
- Presents a simple 1/2 choice in the CLI (clean vs. with_backing)
- Requires manual inspection in Audacity to evaluate backing vocals quality
- Cannot handle the common "Scenario 3" where backing vocals need partial muting
- Has no audio preview capability in remote mode
## Target Architecture
```
┌────────────────────────────────────────────────────────────────────────────┐
│ INSTRUMENTAL REVIEW WORKFLOW │
├────────────────────────────────────────────────────────────────────────────┤
│ │
│ 1. AUDIO ANALYSIS (automatic after render_video completes) │
│ │ │
│ ├── Analyze backing vocals stem for amplitude │
│ ├── Detect audible segments (> -40dB threshold) │
│ ├── Generate waveform visualization image │
│ └── Store analysis results in job state_data │
│ │
│ 2. AUTO-DECISION CHECK │
│ │ │
│ └── IF no audible segments detected: │
│ ├── Set recommended_selection = "clean" │
│ └── Skip to step 4 (or show minimal UI with suggestion) │
│ │
│ 3. HUMAN REVIEW (Web UI) │
│ │ │
│ ├── Display waveform with time axis │
│ ├── Show audible segment markers │
│ ├── Audio playback with waveform-click seeking │
│ ├── Toggle between: clean / with_backing / preview-custom │
│ ├── Select regions to mute (click/drag on waveform) │
│ └── Create custom instrumental if regions selected │
│ │
│ 4. SELECTION SUBMISSION │
│ │ │
│ └── POST /api/jobs/{job_id}/select-instrumental │
│ with selection = "clean" | "with_backing" | "custom" │
│ │
└────────────────────────────────────────────────────────────────────────────┘
```
## Architecture: Shared Core for DRY/SOLID
To ensure feature parity between local and remote CLIs while keeping code maintainable, we use a **shared core module** pattern:
```
┌─────────────────────────────────────────────────────────────────────────────┐
│ SHARED CORE ARCHITECTURE │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ karaoke_gen/instrumental_review/ <── SHARED CORE MODULE │
│ ├── __init__.py │
│ ├── analyzer.py # AudioAnalyzer class (pure Python, no GCS) │
│ ├── editor.py # AudioEditor class (pure Python, no GCS) │
│ ├── waveform.py # WaveformGenerator class (matplotlib) │
│ └── models.py # Pydantic models: AnalysisResult, MuteRegion │
│ │
│ ┌─────────────────────┐ ┌──────────────────────┐ │
│ │ LOCAL CLI │ │ REMOTE BACKEND │ │
│ │ (karaoke-gen) │ │ (Cloud Run) │ │
│ ├─────────────────────┤ ├──────────────────────┤ │
│ │ │ │ │ │
│ │ gen_cli.py │ │ audio_analysis_ │ │
│ │ └── uses shared ───┼──────────────┼──► service.py │ │
│ │ core directly │ │ └── wraps shared│ │
│ │ with local │ │ core with │ │
│ │ file paths │ │ GCS I/O │ │
│ │ │ │ │ │
│ │ local_review_ │ │ audio_editing_ │ │
│ │ server.py │ │ service.py │ │
│ │ └── serves same ───┼──────────────┼──► (same pattern) │ │
│ │ React UI │ │ │ │
│ │ │ │ │ │
│ └─────────────────────┘ └──────────────────────┘ │
│ │
│ BENEFITS: │
│ ✓ Single source of truth for analysis logic │
│ ✓ Bug fixes apply to both local and remote │
│ ✓ Easy to test core logic without GCS mocks │
│ ✓ Backend services are thin wrappers (Single Responsibility) │
│ ✓ Same React UI served by both local server and Cloud Run │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
```
### Shared Core Module Design
```python
# karaoke_gen/instrumental_review/analyzer.py
class AudioAnalyzer:
"""
Analyzes audio files for backing vocals content.
Pure Python - no cloud dependencies. Works with local file paths.
"""
def __init__(self, silence_threshold_db: float = -40.0,
min_segment_duration_ms: int = 100):
self.silence_threshold_db = silence_threshold_db
self.min_segment_duration_ms = min_segment_duration_ms
def analyze(self, audio_path: str) -> AnalysisResult:
"""Analyze audio file and return structured result."""
...
def get_amplitude_envelope(self, audio_path: str,
window_ms: int = 100) -> List[float]:
"""Get amplitude envelope for waveform rendering."""
...
# karaoke_gen/instrumental_review/editor.py
class AudioEditor:
"""
Creates custom instrumentals by muting regions of backing vocals.
Pure Python - no cloud dependencies.
"""
def create_custom_instrumental(
self,
clean_instrumental_path: str,
backing_vocals_path: str,
mute_regions: List[MuteRegion],
output_path: str
) -> str:
"""Create custom instrumental with muted regions."""
...
# karaoke_gen/instrumental_review/waveform.py
class WaveformGenerator:
"""Generates waveform visualization images."""
def generate(self, audio_path: str, output_path: str,
segments: List[AudibleSegment] = None,
width: int = 1200, height: int = 200) -> str:
"""Generate waveform PNG with optional segment highlighting."""
...
```
## Implementation Components
### 1. Shared Core Module (karaoke_gen/instrumental_review/)
Create the shared module first - this is the foundation:
```python
# karaoke_gen/instrumental_review/models.py
from pydantic import BaseModel
from typing import List, Optional
from enum import Enum
class RecommendedSelection(str, Enum):
CLEAN = "clean"
WITH_BACKING = "with_backing"
REVIEW_NEEDED = "review_needed"
class AudibleSegment(BaseModel):
start_seconds: float
end_seconds: float
duration_seconds: float
avg_amplitude_db: float
class MuteRegion(BaseModel):
start_seconds: float
end_seconds: float
class AnalysisResult(BaseModel):
has_audible_content: bool
total_duration_seconds: float
audible_segments: List[AudibleSegment]
recommended_selection: RecommendedSelection
waveform_data: Optional[List[float]] = None # For JSON API response
```
### 2. Backend Service Wrappers
Create `backend/services/audio_analysis_service.py`:
```python
# Key functionality:
- analyze_backing_vocals(audio_path) -> AnalysisResult
- Uses pydub for audio loading
- Calculates RMS amplitude in dB across time windows
- Detects audible segments (contiguous regions > threshold)
- Returns: {
"has_audible_content": bool,
"total_duration_seconds": float,
"audible_segments": [
{"start_seconds": float, "end_seconds": float,
"duration_seconds": float, "avg_amplitude_db": float}
],
"recommended_selection": "clean" | "with_backing" | "review_needed"
}
- generate_waveform_image(audio_path, output_path, segments=None) -> str
- Uses matplotlib to render amplitude envelope over time
- Highlights audible segments with different colors
- Returns path to generated PNG image
```
### 2. Audio Editing Service
Create `backend/services/audio_editing_service.py`:
```python
# Key functionality:
- create_custom_instrumental(
clean_instrumental_path: str,
backing_vocals_path: str,
mute_regions: List[Tuple[float, float]], # [(start_s, end_s), ...]
output_path: str
) -> str
- Loads backing vocals
- Applies silence to mute_regions
- Mixes with clean instrumental
- Saves as new FLAC file
```
### 3. Backend API Endpoints
Add to `backend/api/routes/jobs.py`:
```python
GET /api/jobs/{job_id}/instrumental-analysis
# Returns analysis data + waveform URL
GET /api/jobs/{job_id}/audio-stream/{stem_type}
# Stream audio for playback (clean, backing_vocals, combined)
POST /api/jobs/{job_id}/create-custom-instrumental
# Body: {"mute_regions": [[0.5, 2.3], [45.0, 48.5]]}
# Creates custom instrumental, updates job state
POST /api/jobs/{job_id}/select-instrumental
# Extended to accept: "clean" | "with_backing" | "custom"
```
### 4. Frontend Web UI
Create `frontend/app/jobs/[id]/instrumental-review/page.tsx`:
```
Components needed:
- WaveformDisplay: SVG/Canvas waveform with time axis
- AudioPlayer: HTML5 audio with controls + waveform sync
- RegionSelector: Click/drag to select mute regions
- InstrumentalOptions: Radio buttons for clean/backing/custom
- SegmentList: Table showing detected audible segments
```
Key interactions:
- Click on waveform to seek playback position
- Drag on waveform to select mute region
- Toggle audio source (clean/backing/preview)
- Submit selection
### 5. Backend Worker Updates
Modify `backend/workers/render_video_worker.py`:
```python
# After video render completes, before transitioning to AWAITING_INSTRUMENTAL_SELECTION:
1. Download backing_vocals stem
2. Run audio analysis
3. Generate waveform image
4. Upload waveform to GCS
5. Store analysis results in job.state_data
6. If no audible content: set recommended_selection = "clean"
7. Transition to AWAITING_INSTRUMENTAL_SELECTION
```
### 6. CLI Updates
Modify `karaoke_gen/utils/remote_cli.py`:
```python
def handle_instrumental_selection(self, job_id: str):
# Get analysis data
analysis = self.client.get_instrumental_analysis(job_id)
# If no backing vocals detected, suggest auto-select
if analysis['recommended_selection'] == 'clean':
if self.config.non_interactive:
# Auto-select clean
self.client.select_instrumental(job_id, 'clean')
return
else:
# Show suggestion, offer to open browser for verification
self.logger.info("No backing vocals detected - recommending clean instrumental")
# Open browser anyway so user can verify if desired
# Open browser to instrumental review UI
self.open_instrumental_review_ui(job_id)
# Poll until selection made
while job.status == 'awaiting_instrumental_selection':
time.sleep(self.config.poll_interval)
```
### 7. Local CLI Integration (Feature Parity)
The local CLI (`karaoke-gen`) uses the **same shared core module** as the backend:
```python
# karaoke_gen/utils/gen_cli.py - Updated instrumental selection flow
def handle_instrumental_selection(self, output_dir: str, base_name: str):
"""Handle instrumental selection using shared core module."""
from karaoke_gen.instrumental_review import AudioAnalyzer, WaveformGenerator
# Paths to local files (already exist from audio separation)
backing_vocals_path = os.path.join(output_dir, "stems",
f"{base_name} (Backing Vocals ...).flac")
clean_instrumental_path = os.path.join(output_dir, "stems",
f"{base_name} (Instrumental ...).flac")
# Use SAME analyzer as backend
analyzer = AudioAnalyzer(silence_threshold_db=-40.0)
analysis = analyzer.analyze(backing_vocals_path)
# Generate waveform locally
waveform_path = os.path.join(output_dir, "backing_vocals_waveform.png")
WaveformGenerator().generate(backing_vocals_path, waveform_path,
analysis.audible_segments)
if not analysis.has_audible_content:
self.logger.info("No backing vocals detected - using clean instrumental")
if not self.non_interactive:
# Offer to open browser for verification
...
return "clean"
# Start local review server (serves same React UI)
from karaoke_gen.instrumental_review.server import InstrumentalReviewServer
server = InstrumentalReviewServer(
output_dir=output_dir,
base_name=base_name,
analysis=analysis,
waveform_path=waveform_path,
)
server.start_and_open_browser() # Blocking until user submits selection
return server.get_selection()
```
### 8. Local Review Server
Create `karaoke_gen/instrumental_review/server.py`:
```python
"""
Lightweight local server for instrumental review.
Serves the same React frontend used by the cloud backend.
Similar pattern to LyricsTranscriber's ReviewServer.
"""
from http.server import HTTPServer, SimpleHTTPRequestHandler
import json
import threading
class InstrumentalReviewServer:
"""
Local HTTP server for instrumental review UI.
Endpoints:
- GET /api/analysis - Returns analysis data
- GET /api/audio/{type} - Streams audio files
- GET /api/waveform - Returns waveform image
- POST /api/create-custom - Creates custom instrumental
- POST /api/select - Submits selection
- GET /* - Serves React frontend static files
"""
def __init__(self, output_dir: str, base_name: str,
analysis: AnalysisResult, waveform_path: str):
...
def start_and_open_browser(self, port: int = 8765):
"""Start server, open browser, block until selection submitted."""
...
def get_selection(self) -> str:
"""Get the user's selection after browser submission."""
...
```
## Testing Strategy
### Test Coverage Requirements
All new code must meet the project's **70% minimum coverage** requirement, with critical paths targeting **>80%**:
| Module | Target Coverage | Test File |
|--------|----------------|-----------|
| `karaoke_gen/instrumental_review/analyzer.py` | >90% | `tests/unit/test_instrumental_analyzer.py` |
| `karaoke_gen/instrumental_review/editor.py` | >90% | `tests/unit/test_instrumental_editor.py` |
| `karaoke_gen/instrumental_review/waveform.py` | >80% | `tests/unit/test_instrumental_waveform.py` |
| `karaoke_gen/instrumental_review/server.py` | >70% | `tests/unit/test_instrumental_server.py` |
| `backend/services/audio_analysis_service.py` | >80% | `backend/tests/test_audio_analysis_service.py` |
| `backend/services/audio_editing_service.py` | >80% | `backend/tests/test_audio_editing_service.py` |
| `backend/api/routes/jobs.py` (new endpoints) | >80% | `backend/tests/test_instrumental_api.py` |
### Test Categories
**1. Unit Tests (Shared Core) - tests/unit/test_instrumental_*.py**
```python
# tests/unit/test_instrumental_analyzer.py
class TestAudioAnalyzer:
def test_analyze_silent_audio_returns_no_audible_content(self):
"""Silent audio should return has_audible_content=False."""
def test_analyze_audio_with_content_detects_segments(self):
"""Audio with content should detect audible segments."""
def test_segment_detection_respects_threshold(self):
"""Segments below threshold should not be detected."""
def test_segment_merging_for_close_segments(self):
"""Close segments should be merged into one."""
def test_recommended_selection_clean_for_silent(self):
"""Silent audio should recommend 'clean'."""
def test_recommended_selection_review_for_content(self):
"""Audio with content should recommend 'review_needed'."""
# tests/unit/test_instrumental_editor.py
class TestAudioEditor:
def test_mute_single_region(self):
"""Single mute region should be applied correctly."""
def test_mute_multiple_regions(self):
"""Multiple mute regions should all be applied."""
def test_mute_region_boundaries(self):
"""Mute region at start/end of audio should work."""
def test_output_format_is_flac(self):
"""Output should be FLAC format."""
def test_combines_with_clean_instrumental(self):
"""Result should be backing vocals mixed with clean instrumental."""
```
**2. Unit Tests (Backend Services) - backend/tests/test_audio_*_service.py**
```python
# backend/tests/test_audio_analysis_service.py
class TestAudioAnalysisService:
@pytest.fixture
def mock_storage(self):
"""Mock GCS storage service."""
def test_analyze_downloads_from_gcs(self, mock_storage):
"""Service should download audio from GCS before analysis."""
def test_analyze_uploads_waveform_to_gcs(self, mock_storage):
"""Service should upload waveform image to GCS."""
def test_analyze_updates_job_state_data(self, mock_storage):
"""Service should store analysis in job.state_data."""
```
**3. API Endpoint Tests - backend/tests/test_instrumental_api.py**
```python
# backend/tests/test_instrumental_api.py
class TestInstrumentalAnalysisEndpoint:
def test_get_analysis_returns_data(self, client, mock_job):
"""GET /instrumental-analysis should return analysis data."""
def test_get_analysis_requires_correct_status(self, client, mock_job):
"""Should return 400 if job not in correct status."""
class TestAudioStreamEndpoint:
def test_stream_backing_vocals(self, client, mock_job):
"""Should stream backing vocals audio."""
def test_stream_clean_instrumental(self, client, mock_job):
"""Should stream clean instrumental audio."""
class TestCreateCustomInstrumental:
def test_create_with_mute_regions(self, client, mock_job):
"""Should create custom instrumental with mute regions."""
def test_validates_mute_regions(self, client, mock_job):
"""Should validate mute region boundaries."""
```
**4. Integration Tests - tests/integration/test_instrumental_review.py**
```python
# tests/integration/test_instrumental_review_flow.py
class TestInstrumentalReviewFlow:
"""End-to-end tests for instrumental review workflow."""
def test_full_flow_clean_selection(self):
"""Test complete flow: analysis -> review -> select clean."""
def test_full_flow_with_backing_selection(self):
"""Test complete flow: analysis -> review -> select with_backing."""
def test_full_flow_custom_creation(self):
"""Test complete flow: analysis -> mute regions -> custom."""
def test_auto_recommend_clean_for_silent_backing(self):
"""When no backing vocals, should recommend clean."""
```
**5. CLI Feature Parity Tests - tests/unit/test_cli_feature_parity.py**
```python
# tests/unit/test_cli_feature_parity.py
class TestCLIFeatureParity:
"""Verify local and remote CLIs have equivalent functionality."""
def test_both_clis_use_same_analyzer(self):
"""Both CLIs should use AudioAnalyzer from shared module."""
def test_both_clis_support_custom_instrumental(self):
"""Both CLIs should support creating custom instrumentals."""
def test_analysis_results_identical(self):
"""Same audio should produce identical analysis from both CLIs."""
```
### Test Data
Create test fixtures in `tests/data/instrumental_review/`:
- `silent_backing_vocals.flac` - Silent/near-silent audio (~10s)
- `backing_vocals_with_content.flac` - Audio with clear backing vocals (~30s)
- `backing_vocals_mixed_quality.flac` - Audio with some good/some bad sections (~30s)
Use pydub to programmatically generate these in `tests/conftest.py` fixtures.
## File Changes Summary
| Category | Files to Create/Modify |
|----------|------------------------|
| **Shared Core** | `karaoke_gen/instrumental_review/__init__.py` (new) |
| Shared Core | `karaoke_gen/instrumental_review/models.py` (new) |
| Shared Core | `karaoke_gen/instrumental_review/analyzer.py` (new) |
| Shared Core | `karaoke_gen/instrumental_review/editor.py` (new) |
| Shared Core | `karaoke_gen/instrumental_review/waveform.py` (new) |
| Shared Core | `karaoke_gen/instrumental_review/server.py` (new) |
| **Backend Services** | `backend/services/audio_analysis_service.py` (new) |
| Backend Services | `backend/services/audio_editing_service.py` (new) |
| **API** | `backend/api/routes/jobs.py` (modify - add endpoints) |
| API | `backend/api/routes/instrumental.py` (new - if endpoints get large) |
| **Workers** | `backend/workers/render_video_worker.py` (modify) |
| **Models** | `backend/models/job.py` (add analysis fields to state_data) |
| **Frontend** | `frontend/app/jobs/[id]/instrumental-review/page.tsx` (new) |
| Frontend | `frontend/components/waveform-display.tsx` (new) |
| Frontend | `frontend/components/audio-player-with-waveform.tsx` (new) |
| Frontend | `frontend/components/region-selector.tsx` (new) |
| **Local CLI** | `karaoke_gen/utils/gen_cli.py` (modify) |
| **Remote CLI** | `karaoke_gen/utils/remote_cli.py` (modify) |
| **Tests - Shared** | `tests/unit/test_instrumental_analyzer.py` (new) |
| Tests - Shared | `tests/unit/test_instrumental_editor.py` (new) |
| Tests - Shared | `tests/unit/test_instrumental_waveform.py` (new) |
| Tests - Shared | `tests/unit/test_instrumental_server.py` (new) |
| **Tests - Backend** | `backend/tests/test_audio_analysis_service.py` (new) |
| Tests - Backend | `backend/tests/test_audio_editing_service.py` (new) |
| Tests - Backend | `backend/tests/test_instrumental_api.py` (new) |
| **Tests - Parity** | `tests/unit/test_cli_feature_parity.py` (new) |
| **Tests - Integration** | `tests/integration/test_instrumental_review.py` (new) |
| **Test Data** | `tests/conftest.py` (modify - add fixtures) |
## Dependencies
Already available in `pyproject.toml`:
- `pydub>=0.25.1` - Audio loading and manipulation
- `matplotlib>=3` - Waveform visualization
- `numpy>=2` - Audio array processing
Frontend:
- React/Next.js (existing)
- HTML5 Audio API (native)
- Canvas or SVG for waveform (native)
## Implementation Order
Execute in this order to enable incremental testing:
### Phase 1: Shared Core Module (Foundation)
1. Create `karaoke_gen/instrumental_review/` package with models, analyzer, editor, waveform
2. Add comprehensive unit tests for shared core (>90% coverage)
3. Create test audio fixtures in `tests/conftest.py`
### Phase 2: Backend Integration
4. Create backend service wrappers with GCS integration
5. Add backend service unit tests with mocked GCS
6. Add new API endpoints to `backend/api/routes/jobs.py`
7. Add API endpoint tests
8. Integrate analysis into `render_video_worker.py`
9. Update render worker tests
### Phase 3: Frontend
10. Create React components (WaveformDisplay, AudioPlayer, RegionSelector)
11. Create instrumental review page
12. Test frontend manually with backend
### Phase 4: CLI Integration
13. Update `remote_cli.py` to use new analysis API and open browser
14. Create local review server `karaoke_gen/instrumental_review/server.py`
15. Update `gen_cli.py` to use shared core and local server
16. Add CLI feature parity tests
### Phase 5: Integration Testing
17. Add end-to-end integration tests
18. Manual testing of full workflow (local and remote)
### Verification Checklist
- [ ] All unit tests pass: `pytest tests/unit/ -v`
- [ ] All backend tests pass: `pytest backend/tests/ -v`
- [ ] Coverage meets 70% minimum: `pytest --cov=karaoke_gen --cov-fail-under=70`
- [ ] Local CLI works: `karaoke-gen "Artist" "Title"` (reaches instrumental selection)
- [ ] Remote CLI works: `karaoke-gen-remote ./audio.flac "Artist" "Title"`
- [ ] Both CLIs produce identical analysis for same audio
- [ ] Custom instrumental creation works in both modes
- [ ] Version bumped in `pyproject.toml`
@@ -1,217 +0,0 @@
---
name: MidiCo-Style Synchronizer
overview: Build a new MidiCo-style Synchronizer component for efficient re-syncing of lyrics timing, particularly for fixing progressive drift in the second half of songs. This involves refactoring the "Edit All" entry point and creating a high-performance timeline-based sync interface.
todos:
- id: mode-selection-modal
content: Create ModeSelectionModal for 'Replace All' vs 'Re-sync Existing' choice
status: completed
- id: timeline-canvas
content: Build canvas-based TimelineCanvas component for high-performance word block rendering
status: completed
- id: upcoming-words-bar
content: Create UpcomingWordsBar component showing next unsynced words in fixed position
status: completed
- id: sync-controls
content: Build SyncControls with Start Sync, Clear Sync, Unsync from Cursor, Delete Selected buttons
status: completed
- id: lyrics-synchronizer
content: Create main LyricsSynchronizer component integrating all sub-components
status: completed
- id: unsync-from-cursor
content: Add 'unsync from cursor' functionality to useManualSync hook
status: completed
- id: integrate-modal
content: Integrate new synchronizer into ReplaceAllLyricsModal with mode selection
status: completed
- id: word-selection
content: Implement single-click and drag-select for word blocks
status: completed
- id: zoom-slider
content: Add smooth zoom slider with 4.5s-24s range
status: completed
- id: performance-test
content: Test performance with long songs and optimize as needed
status: completed
---
# MidiCo-Style Synchronizer Implementation
## Current State Analysis
The existing implementation in [`ReplaceAllLyricsModal.tsx`](lyrics_transcriber_temp/lyrics_transcriber/frontend/src/components/ReplaceAllLyricsModal.tsx) has two phases:
1. **Paste Phase** - User pastes new lyrics text
2. **Sync Phase** - Manual sync using spacebar with timeline view
Key existing components:
- [`useManualSync.ts`](lyrics_transcriber_temp/lyrics_transcriber/frontend/src/hooks/useManualSync.ts) - Spacebar handling, tap/hold detection
- [`EditTimelineSection.tsx`](lyrics_transcriber_temp/lyrics_transcriber/frontend/src/components/EditTimelineSection.tsx) - Timeline controls with zoom/scroll
- [`TimelineEditor.tsx`](lyrics_transcriber_temp/lyrics_transcriber/frontend/src/components/TimelineEditor.tsx) - Timeline rendering
**Problems with current implementation:**
1. Forces full lyrics replacement - no option to keep existing sync data
2. Performance issues (laggy, slow rendering)
3. Poor UX for seeing upcoming words while syncing
4. No "unsync from cursor" feature for fixing drift
5. No two-level word block layout for overlapping segments
## Architecture Overview
```mermaid
flowchart TB
subgraph Entry [Entry Point]
EditAll[Edit All Button]
EditAll --> ChoiceModal[Mode Selection Modal]
ChoiceModal -->|Replace All| PastePhase[Paste New Lyrics]
ChoiceModal -->|Re-sync Existing| SyncView[Synchronizer View]
PastePhase --> SyncView
end
subgraph Sync [Synchronizer Component]
SyncView --> Timeline[Timeline Canvas]
SyncView --> Controls[Control Buttons]
SyncView --> UpcomingWords[Upcoming Words Display]
Timeline --> WordBlocks[Word Blocks Renderer]
Timeline --> Playhead[Playhead Marker]
Timeline --> TimeBar[Time Bar]
end
subgraph Audio [Audio Integration]
AudioPlayer[Audio Player]
AudioPlayer <--> SyncView
end
```
## Implementation Plan
### Phase 1: Entry Point Refactor
Modify the "Edit All" button flow to show a choice modal:
```typescript
// New ModeSelectionModal component
interface ModeSelectionModalProps {
open: boolean
onClose: () => void
onSelectReplace: () => void // Goes to paste phase
onSelectResync: () => void // Goes directly to sync view
}
```
- **Replace All Lyrics**: Current flow (paste box -> sync)
- **Re-sync Existing Lyrics**: Load current segments directly into sync view
### Phase 2: New Synchronizer Component
Create a new high-performance `LyricsSynchronizer.tsx` component inspired by MidiCo:
#### Core Features
1. **Timeline Canvas** (HTML5 Canvas for performance)
- Time bar at top (MM:SS format with decisecond ticks)
- Playhead with arrow indicator + vertical line
- Red word blocks with text labels
- Two-level word layout for overlapping segments
- Zoom slider (4.5s to 24s visible range)
- Horizontal scroll with smooth panning
2. **Upcoming Words Display** (dual location)
- Fixed position above timeline: next words as red/white blocks
- On timeline: words appear to right of playhead during sync
3. **Control Buttons**
- **Start Sync** - Begin sync mode from first unsynced word
- **Clear Sync** - Reset all word timings to null
- **Edit Lyrics** - Modal to edit lyrics text (warns about timing loss)
- **Unsync from Cursor** - Critical: reset all words after playhead position
- **Split/Edit Word** - Edit single selected word
- **Delete Selected** - Remove selected word blocks
4. **Word Selection**
- Single click: select one word (white border)
- Click-drag on background: selection rectangle for multi-select
- Click on time bar: set playhead position
5. **Spacebar Sync Logic** (reuse/enhance `useManualSync`)
- Tap: set start time, default 500ms duration
- Hold: set both start and end times
- Handle previous word end time calculation
### Phase 3: Performance Optimization
The current `TimelineEditor` uses DOM elements which causes lag. New approach:
1. **Canvas-based rendering** for word blocks and timeline
- Single canvas element, no DOM nodes per word
- RequestAnimationFrame for smooth playhead updates
- Only re-render changed regions
2. **Virtual scrolling** for very long songs
- Only render visible word blocks
- Cache off-screen block positions
3. **Debounced state updates**
- Batch word timing updates
- Throttle zoom/scroll handlers
### Phase 4: Apply/Cancel Flow
Changes are held in local state until user clicks Apply:
```typescript
interface SynchronizerState {
words: Word[] // Working copy of words
segments: LyricsSegment[] // Working copy of segments
isDirty: boolean // Has unsaved changes
}
```
- **Apply**: Commit changes to parent component
- **Cancel**: Discard changes, close modal
## File Changes
### New Files
- `src/components/LyricsSynchronizer.tsx` - Main synchronizer component
- `src/components/LyricsSynchronizer/TimelineCanvas.tsx` - Canvas-based timeline
- `src/components/LyricsSynchronizer/UpcomingWordsBar.tsx` - Fixed upcoming words display
- `src/components/LyricsSynchronizer/SyncControls.tsx` - Control buttons
- `src/components/ModeSelectionModal.tsx` - Entry point choice modal
### Modified Files
- [`ReplaceAllLyricsModal.tsx`](lyrics_transcriber_temp/lyrics_transcriber/frontend/src/components/ReplaceAllLyricsModal.tsx) - Add mode selection, integrate new synchronizer
- [`useManualSync.ts`](lyrics_transcriber_temp/lyrics_transcriber/frontend/src/hooks/useManualSync.ts) - Add "unsync from cursor" functionality
## Key UX Details from MidiCo Reference
Per the documentation at [`MIDICO_SYNCHRONIZER_REFERENCE.md`](lyrics_transcriber_temp/docs/MIDICO_SYNCHRONIZER_REFERENCE.md):
1. **Zoom range**: 4.5s (max zoom) to 24s (min zoom) visible
2. **Timeline click behavior**:
- Time bar click = set playhead (no playback change)
- Background click = nothing (prevent accidental deselection)
- Word block click = select
3. **Two-level word blocks**: Adjacent/overlapping words display on alternating vertical levels
4. **Playhead**: Small arrow in time bar + white vertical line spanning timeline height
5. **Selection rectangle**: Click-drag on background creates selection box
## Testing Strategy
1. Manual testing with the provided URL: `http://localhost:8000/?baseApiUrl=...`
2. Test sync accuracy with songs that have known drift issues
3. Performance testing with 400+ word songs
4. Test "unsync from cursor" workflow for fixing drift
-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
-73
View File
@@ -1,73 +0,0 @@
# .gcloudignore - Exclude files from Cloud Build uploads
# This dramatically reduces upload time (from 218MB to ~5-10MB)
# Git
.git/
.gitignore
.gitmodules
# Node.js / Frontend
node_modules/
frontend-react/node_modules/
frontend-react/dist/
frontend-react/.vite/
*.log
npm-debug.log*
yarn-debug.log*
yarn-error.log*
# Python
__pycache__/
*.py[cod]
*$py.class
*.so
.Python
.venv/
venv/
ENV/
env/
*.egg-info/
.eggs/
dist/
build/
*.egg
# IDE
.idea/
.vscode/
*.swp
*.swo
*~
.DS_Store
# Testing
.pytest_cache/
.coverage
htmlcov/
.tox/
.nox/
coverage.xml
*.cover
# Documentation (not needed for Docker build)
docs/
# Local development files
lyrics_transcriber_local/
*.local
.env
.env.*
# Large test files
tests/data/*.mp3
tests/data/*.wav
tests/data/*.mp4
tests/data/*.mkv
# Infrastructure (not needed for Docker build)
infrastructure/
# Misc
*.bak
*.tmp
Thumbs.db
-128
View File
@@ -1,128 +0,0 @@
# GitHub Actions CI/CD
This directory contains GitHub Actions workflows for automated testing and deployment.
## Workflows
### `test.yml` - Automated Testing & Deployment (CI/CD)
**Triggers:**
- Push to `main` or `replace-modal-with-google-cloud` branches
- Pull requests to `main`
**Jobs:**
#### Testing Phase (runs in parallel)
1. **Unit Tests** (~30s)
- Runs 62 unit tests with mocked dependencies
- Fast validation of business logic
- Uses Python 3.12 with pip caching
2. **Emulator Integration Tests** (~2min)
- Runs 11 integration tests against local GCP emulators
- Tests real Firestore and GCS interactions
- Requires:
- Java 21 (for Firestore emulator)
- Google Cloud SDK (for Firestore emulator)
- Docker (for GCS emulator via fake-gcs-server)
- Uses the same `scripts/run-emulator-tests.sh` as local development
3. **Code Quality** (~20s)
- Basic Python syntax validation
- Import checks
- Optional: flake8, black, isort
#### Deployment Phase (runs after all tests pass)
4. **Deploy to Cloud Run** (~3-4min)
- **Only runs on push to `replace-modal-with-google-cloud` branch** (not on PRs)
- Builds Docker image and pushes to Artifact Registry
- Deploys to Cloud Run with proper configuration
- Verifies deployment health
- **Requires GitHub secrets:**
- `GCP_SA_KEY` - Service account key JSON
- `ADMIN_TOKENS` - Admin authentication tokens
**Total Runtime:**
- **Testing only** (PRs): ~3 minutes
- **Testing + Deployment** (push to branch): ~7 minutes
## Local vs CI
The CI runs the exact same tests as local development:
```bash
# Local development
./scripts/run-tests.sh # Unit tests (same as CI job 1)
./scripts/run-emulator-tests.sh # Emulator tests (same as CI job 2)
python backend/validate.py # Validation (same as CI job 3)
# CI automatically runs all three on every push
```
## Viewing Results
1. Go to the [Actions tab](../../actions) in GitHub
2. Click on the latest workflow run
3. View job logs and test results
4. Download test artifacts (coverage reports) if needed
## Adding New Tests
Tests are automatically discovered by pytest. To add new tests:
1. **Unit tests:** Add to `backend/tests/test_*.py`
2. **Emulator tests:** Add to `backend/tests/emulator/test_*.py`
3. **Cloud tests:** Add to `backend/tests/test_api_integration.py` (runs manually)
The CI will automatically pick them up!
## Troubleshooting
### Emulator Tests Fail in CI
**Common issues:**
- Emulator startup timeout → Increase wait time in `scripts/start-emulators.sh`
- Docker not available → Check GitHub Actions runner compatibility
- Port conflicts → Emulators use ports 8080 (Firestore) and 4443 (GCS)
### CI is Slow
**Optimizations:**
- ✅ Python pip caching enabled
- ✅ Jobs run in parallel
- ✅ Docker image pre-pulled
- Future: Cache gcloud SDK installation
### Tests Pass Locally But Fail in CI
**Debug steps:**
1. Check Python version matches (3.12)
2. Check environment variables are set correctly
3. Review CI logs for missing dependencies
4. Run tests in a clean venv locally
## Setting Up Continuous Deployment
The CD pipeline is configured but requires GitHub secrets to be set. See the [CD Setup Guide](../docs/03-deployment/CD-SETUP.md) for detailed instructions.
**Quick setup:**
1. Create GCP service account with deployment permissions
2. Download service account key JSON
3. Add GitHub secrets:
- `GCP_SA_KEY` - Full service account key JSON content
- `ADMIN_TOKENS` - Comma-separated admin tokens
Once configured, every push to `replace-modal-with-google-cloud` will automatically deploy to Cloud Run after all tests pass.
## Future Enhancements
- [ ] Add test coverage reporting (coveralls, codecov)
- [x] ✅ Add deployment workflow (deploy to Cloud Run after tests pass)
- [ ] Add frontend tests (when frontend is built)
- [ ] Add performance benchmarking
- [ ] Add security scanning (dependabot, snyk)
- [ ] Migrate to Workload Identity Federation (more secure than service account keys)
-28
View File
@@ -1,28 +0,0 @@
2384d2383
< triton = ">=2.0.0,<3"
4185d4183
< triton = {version = "2.3.1", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\" and python_version < \"3.12\""}
4318,4340d4315
< name = "triton"
< version = "2.3.1"
< description = "A language and compiler for custom Deep Learning operations"
< optional = false
< python-versions = "*"
< files = [
< {file = "triton-2.3.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3c84595cbe5e546b1b290d2a58b1494df5a2ef066dd890655e5b8a8a92205c33"},
< {file = "triton-2.3.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c9d64ae33bcb3a7a18081e3a746e8cf87ca8623ca13d2c362413ce7a486f893e"},
< {file = "triton-2.3.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eaf80e8761a9e3498aa92e7bf83a085b31959c61f5e8ac14eedd018df6fccd10"},
< {file = "triton-2.3.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b13bf35a2b659af7159bf78e92798dc62d877aa991de723937329e2d382f1991"},
< {file = "triton-2.3.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:63381e35ded3304704ea867ffde3b7cfc42c16a55b3062d41e017ef510433d66"},
< {file = "triton-2.3.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1d968264523c7a07911c8fb51b4e0d1b920204dae71491b1fe7b01b62a31e124"},
< ]
<
< [package.dependencies]
< filelock = "*"
<
< [package.extras]
< build = ["cmake (>=3.20)", "lit"]
< tests = ["autopep8", "flake8", "isort", "numpy", "pytest", "scipy (>=1.7.1)", "torch"]
< tutorials = ["matplotlib", "pandas", "tabulate", "torch"]
<
< [[package]]
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
+19
View File
@@ -0,0 +1,19 @@
name: Auto-publish
on: [push, workflow_dispatch]
jobs:
# Auto-publish when version is increased
publish-pypi:
# Only publish on `main` branch
if: github.ref == 'refs/heads/main'
runs-on: ubuntu-latest
permissions: # Don't forget permissions
contents: write
steps:
- uses: etils-actions/pypi-auto-publish@v1
with:
pypi-token: ${{ secrets.PYPI_API_TOKEN }}
gh-token: ${{ secrets.GITHUB_TOKEN }}
parse-changelog: false
+1 -62
View File
@@ -8,60 +8,7 @@
/audio/
/lyrics/
/karaoke/
tests/outputs
/input
/output/
# Cloud Infra
.emulator-logs
# Next.js / React Frontend (./frontend)
node_modules/
frontend/node_modules/
frontend/.next/
frontend/out/
frontend/.swc/
frontend/.turbo/
frontend/build/
frontend/dist/
# Next.js specific
frontend/*.tsbuildinfo
frontend/next-env.d.ts
# Environment files (local overrides)
frontend/.env*.local
# Vercel
frontend/.vercel/
# Package manager logs
frontend/npm-debug.log*
frontend/yarn-debug.log*
frontend/yarn-error.log*
frontend/pnpm-debug.log*
frontend/.pnpm-debug.log*
# Testing
frontend/coverage/
frontend/test-results/
frontend/playwright-report/
frontend/playwright/.cache/
frontend/e2e/screenshots/
# TypeScript
frontend/*.tsbuildinfo
# ESLint
frontend/.eslintcache
# Storybook
frontend/storybook-static/
# PWA files
frontend/**/public/sw.js
frontend/**/public/workbox-*.js
frontend/**/public/swe-worker-*.js
/tests/outputs
# Byte-compiled / optimized / DLL files
@@ -80,12 +27,8 @@ dist/
downloads/
eggs/
.eggs/
# Python lib directories (not frontend)
lib/
lib64/
# But allow frontend lib directories
!frontend/lib/
!buy-site/lib/
parts/
sdist/
var/
@@ -228,7 +171,3 @@ cython_debug/
# and can be added to the global gitignore or merged into this file. For a more nuclear
# option (not recommended) you can uncomment the following to ignore the entire idea folder.
#.idea/
flacfetch
# Test output directories
Rick Astley*/
-50
View File
@@ -1,50 +0,0 @@
# [PROJECT_NAME] Constitution
<!-- Example: Spec Constitution, TaskFlow Constitution, etc. -->
## Core Principles
### [PRINCIPLE_1_NAME]
<!-- Example: I. Library-First -->
[PRINCIPLE_1_DESCRIPTION]
<!-- Example: Every feature starts as a standalone library; Libraries must be self-contained, independently testable, documented; Clear purpose required - no organizational-only libraries -->
### [PRINCIPLE_2_NAME]
<!-- Example: II. CLI Interface -->
[PRINCIPLE_2_DESCRIPTION]
<!-- Example: Every library exposes functionality via CLI; Text in/out protocol: stdin/args → stdout, errors → stderr; Support JSON + human-readable formats -->
### [PRINCIPLE_3_NAME]
<!-- Example: III. Test-First (NON-NEGOTIABLE) -->
[PRINCIPLE_3_DESCRIPTION]
<!-- Example: TDD mandatory: Tests written → User approved → Tests fail → Then implement; Red-Green-Refactor cycle strictly enforced -->
### [PRINCIPLE_4_NAME]
<!-- Example: IV. Integration Testing -->
[PRINCIPLE_4_DESCRIPTION]
<!-- Example: Focus areas requiring integration tests: New library contract tests, Contract changes, Inter-service communication, Shared schemas -->
### [PRINCIPLE_5_NAME]
<!-- Example: V. Observability, VI. Versioning & Breaking Changes, VII. Simplicity -->
[PRINCIPLE_5_DESCRIPTION]
<!-- Example: Text I/O ensures debuggability; Structured logging required; Or: MAJOR.MINOR.BUILD format; Or: Start simple, YAGNI principles -->
## [SECTION_2_NAME]
<!-- Example: Additional Constraints, Security Requirements, Performance Standards, etc. -->
[SECTION_2_CONTENT]
<!-- Example: Technology stack requirements, compliance standards, deployment policies, etc. -->
## [SECTION_3_NAME]
<!-- Example: Development Workflow, Review Process, Quality Gates, etc. -->
[SECTION_3_CONTENT]
<!-- Example: Code review requirements, testing gates, deployment approval process, etc. -->
## Governance
<!-- Example: Constitution supersedes all other practices; Amendments require documentation, approval, migration plan -->
[GOVERNANCE_RULES]
<!-- Example: All PRs/reviews must verify compliance; Complexity must be justified; Use [GUIDANCE_FILE] for runtime development guidance -->
**Version**: [CONSTITUTION_VERSION] | **Ratified**: [RATIFICATION_DATE] | **Last Amended**: [LAST_AMENDED_DATE]
<!-- Example: Version: 2.1.1 | Ratified: 2025-06-13 | Last Amended: 2025-07-16 -->
@@ -1,166 +0,0 @@
#!/usr/bin/env bash
# Consolidated prerequisite checking script
#
# This script provides unified prerequisite checking for Spec-Driven Development workflow.
# It replaces the functionality previously spread across multiple scripts.
#
# Usage: ./check-prerequisites.sh [OPTIONS]
#
# OPTIONS:
# --json Output in JSON format
# --require-tasks Require tasks.md to exist (for implementation phase)
# --include-tasks Include tasks.md in AVAILABLE_DOCS list
# --paths-only Only output path variables (no validation)
# --help, -h Show help message
#
# OUTPUTS:
# JSON mode: {"FEATURE_DIR":"...", "AVAILABLE_DOCS":["..."]}
# Text mode: FEATURE_DIR:... \n AVAILABLE_DOCS: \n ✓/✗ file.md
# Paths only: REPO_ROOT: ... \n BRANCH: ... \n FEATURE_DIR: ... etc.
set -e
# Parse command line arguments
JSON_MODE=false
REQUIRE_TASKS=false
INCLUDE_TASKS=false
PATHS_ONLY=false
for arg in "$@"; do
case "$arg" in
--json)
JSON_MODE=true
;;
--require-tasks)
REQUIRE_TASKS=true
;;
--include-tasks)
INCLUDE_TASKS=true
;;
--paths-only)
PATHS_ONLY=true
;;
--help|-h)
cat << 'EOF'
Usage: check-prerequisites.sh [OPTIONS]
Consolidated prerequisite checking for Spec-Driven Development workflow.
OPTIONS:
--json Output in JSON format
--require-tasks Require tasks.md to exist (for implementation phase)
--include-tasks Include tasks.md in AVAILABLE_DOCS list
--paths-only Only output path variables (no prerequisite validation)
--help, -h Show this help message
EXAMPLES:
# Check task prerequisites (plan.md required)
./check-prerequisites.sh --json
# Check implementation prerequisites (plan.md + tasks.md required)
./check-prerequisites.sh --json --require-tasks --include-tasks
# Get feature paths only (no validation)
./check-prerequisites.sh --paths-only
EOF
exit 0
;;
*)
echo "ERROR: Unknown option '$arg'. Use --help for usage information." >&2
exit 1
;;
esac
done
# Source common functions
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
source "$SCRIPT_DIR/common.sh"
# Get feature paths and validate branch
eval $(get_feature_paths)
check_feature_branch "$CURRENT_BRANCH" "$HAS_GIT" || exit 1
# If paths-only mode, output paths and exit (support JSON + paths-only combined)
if $PATHS_ONLY; then
if $JSON_MODE; then
# Minimal JSON paths payload (no validation performed)
printf '{"REPO_ROOT":"%s","BRANCH":"%s","FEATURE_DIR":"%s","FEATURE_SPEC":"%s","IMPL_PLAN":"%s","TASKS":"%s"}\n' \
"$REPO_ROOT" "$CURRENT_BRANCH" "$FEATURE_DIR" "$FEATURE_SPEC" "$IMPL_PLAN" "$TASKS"
else
echo "REPO_ROOT: $REPO_ROOT"
echo "BRANCH: $CURRENT_BRANCH"
echo "FEATURE_DIR: $FEATURE_DIR"
echo "FEATURE_SPEC: $FEATURE_SPEC"
echo "IMPL_PLAN: $IMPL_PLAN"
echo "TASKS: $TASKS"
fi
exit 0
fi
# Validate required directories and files
if [[ ! -d "$FEATURE_DIR" ]]; then
echo "ERROR: Feature directory not found: $FEATURE_DIR" >&2
echo "Run /specify first to create the feature structure." >&2
exit 1
fi
if [[ ! -f "$IMPL_PLAN" ]]; then
echo "ERROR: plan.md not found in $FEATURE_DIR" >&2
echo "Run /plan first to create the implementation plan." >&2
exit 1
fi
# Check for tasks.md if required
if $REQUIRE_TASKS && [[ ! -f "$TASKS" ]]; then
echo "ERROR: tasks.md not found in $FEATURE_DIR" >&2
echo "Run /tasks first to create the task list." >&2
exit 1
fi
# Build list of available documents
docs=()
# Always check these optional docs
[[ -f "$RESEARCH" ]] && docs+=("research.md")
[[ -f "$DATA_MODEL" ]] && docs+=("data-model.md")
# Check contracts directory (only if it exists and has files)
if [[ -d "$CONTRACTS_DIR" ]] && [[ -n "$(ls -A "$CONTRACTS_DIR" 2>/dev/null)" ]]; then
docs+=("contracts/")
fi
[[ -f "$QUICKSTART" ]] && docs+=("quickstart.md")
# Include tasks.md if requested and it exists
if $INCLUDE_TASKS && [[ -f "$TASKS" ]]; then
docs+=("tasks.md")
fi
# Output results
if $JSON_MODE; then
# Build JSON array of documents
if [[ ${#docs[@]} -eq 0 ]]; then
json_docs="[]"
else
json_docs=$(printf '"%s",' "${docs[@]}")
json_docs="[${json_docs%,}]"
fi
printf '{"FEATURE_DIR":"%s","AVAILABLE_DOCS":%s}\n' "$FEATURE_DIR" "$json_docs"
else
# Text output
echo "FEATURE_DIR:$FEATURE_DIR"
echo "AVAILABLE_DOCS:"
# Show status of each potential document
check_file "$RESEARCH" "research.md"
check_file "$DATA_MODEL" "data-model.md"
check_dir "$CONTRACTS_DIR" "contracts/"
check_file "$QUICKSTART" "quickstart.md"
if $INCLUDE_TASKS; then
check_file "$TASKS" "tasks.md"
fi
fi
-113
View File
@@ -1,113 +0,0 @@
#!/usr/bin/env bash
# Common functions and variables for all scripts
# Get repository root, with fallback for non-git repositories
get_repo_root() {
if git rev-parse --show-toplevel >/dev/null 2>&1; then
git rev-parse --show-toplevel
else
# Fall back to script location for non-git repos
local script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
(cd "$script_dir/../../.." && pwd)
fi
}
# Get current branch, with fallback for non-git repositories
get_current_branch() {
# First check if SPECIFY_FEATURE environment variable is set
if [[ -n "${SPECIFY_FEATURE:-}" ]]; then
echo "$SPECIFY_FEATURE"
return
fi
# Then check git if available
if git rev-parse --abbrev-ref HEAD >/dev/null 2>&1; then
git rev-parse --abbrev-ref HEAD
return
fi
# For non-git repos, try to find the latest feature directory
local repo_root=$(get_repo_root)
local specs_dir="$repo_root/specs"
if [[ -d "$specs_dir" ]]; then
local latest_feature=""
local highest=0
for dir in "$specs_dir"/*; do
if [[ -d "$dir" ]]; then
local dirname=$(basename "$dir")
if [[ "$dirname" =~ ^([0-9]{3})- ]]; then
local number=${BASH_REMATCH[1]}
number=$((10#$number))
if [[ "$number" -gt "$highest" ]]; then
highest=$number
latest_feature=$dirname
fi
fi
fi
done
if [[ -n "$latest_feature" ]]; then
echo "$latest_feature"
return
fi
fi
echo "main" # Final fallback
}
# Check if we have git available
has_git() {
git rev-parse --show-toplevel >/dev/null 2>&1
}
check_feature_branch() {
local branch="$1"
local has_git_repo="$2"
# For non-git repos, we can't enforce branch naming but still provide output
if [[ "$has_git_repo" != "true" ]]; then
echo "[specify] Warning: Git repository not detected; skipped branch validation" >&2
return 0
fi
if [[ ! "$branch" =~ ^[0-9]{3}- ]]; then
echo "ERROR: Not on a feature branch. Current branch: $branch" >&2
echo "Feature branches should be named like: 001-feature-name" >&2
return 1
fi
return 0
}
get_feature_dir() { echo "$1/specs/$2"; }
get_feature_paths() {
local repo_root=$(get_repo_root)
local current_branch=$(get_current_branch)
local has_git_repo="false"
if has_git; then
has_git_repo="true"
fi
local feature_dir=$(get_feature_dir "$repo_root" "$current_branch")
cat <<EOF
REPO_ROOT='$repo_root'
CURRENT_BRANCH='$current_branch'
HAS_GIT='$has_git_repo'
FEATURE_DIR='$feature_dir'
FEATURE_SPEC='$feature_dir/spec.md'
IMPL_PLAN='$feature_dir/plan.md'
TASKS='$feature_dir/tasks.md'
RESEARCH='$feature_dir/research.md'
DATA_MODEL='$feature_dir/data-model.md'
QUICKSTART='$feature_dir/quickstart.md'
CONTRACTS_DIR='$feature_dir/contracts'
EOF
}
check_file() { [[ -f "$1" ]] && echo " ✓ $2" || echo " ✗ $2"; }
check_dir() { [[ -d "$1" && -n $(ls -A "$1" 2>/dev/null) ]] && echo " ✓ $2" || echo " ✗ $2"; }
@@ -1,97 +0,0 @@
#!/usr/bin/env bash
set -e
JSON_MODE=false
ARGS=()
for arg in "$@"; do
case "$arg" in
--json) JSON_MODE=true ;;
--help|-h) echo "Usage: $0 [--json] <feature_description>"; exit 0 ;;
*) ARGS+=("$arg") ;;
esac
done
FEATURE_DESCRIPTION="${ARGS[*]}"
if [ -z "$FEATURE_DESCRIPTION" ]; then
echo "Usage: $0 [--json] <feature_description>" >&2
exit 1
fi
# Function to find the repository root by searching for existing project markers
find_repo_root() {
local dir="$1"
while [ "$dir" != "/" ]; do
if [ -d "$dir/.git" ] || [ -d "$dir/.specify" ]; then
echo "$dir"
return 0
fi
dir="$(dirname "$dir")"
done
return 1
}
# Resolve repository root. Prefer git information when available, but fall back
# to searching for repository markers so the workflow still functions in repositories that
# were initialised with --no-git.
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
if git rev-parse --show-toplevel >/dev/null 2>&1; then
REPO_ROOT=$(git rev-parse --show-toplevel)
HAS_GIT=true
else
REPO_ROOT="$(find_repo_root "$SCRIPT_DIR")"
if [ -z "$REPO_ROOT" ]; then
echo "Error: Could not determine repository root. Please run this script from within the repository." >&2
exit 1
fi
HAS_GIT=false
fi
cd "$REPO_ROOT"
SPECS_DIR="$REPO_ROOT/specs"
mkdir -p "$SPECS_DIR"
HIGHEST=0
if [ -d "$SPECS_DIR" ]; then
for dir in "$SPECS_DIR"/*; do
[ -d "$dir" ] || continue
dirname=$(basename "$dir")
number=$(echo "$dirname" | grep -o '^[0-9]\+' || echo "0")
number=$((10#$number))
if [ "$number" -gt "$HIGHEST" ]; then HIGHEST=$number; fi
done
fi
NEXT=$((HIGHEST + 1))
FEATURE_NUM=$(printf "%03d" "$NEXT")
BRANCH_NAME=$(echo "$FEATURE_DESCRIPTION" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/-/g' | sed 's/-\+/-/g' | sed 's/^-//' | sed 's/-$//')
WORDS=$(echo "$BRANCH_NAME" | tr '-' '\n' | grep -v '^$' | head -3 | tr '\n' '-' | sed 's/-$//')
BRANCH_NAME="${FEATURE_NUM}-${WORDS}"
if [ "$HAS_GIT" = true ]; then
git checkout -b "$BRANCH_NAME"
else
>&2 echo "[specify] Warning: Git repository not detected; skipped branch creation for $BRANCH_NAME"
fi
FEATURE_DIR="$SPECS_DIR/$BRANCH_NAME"
mkdir -p "$FEATURE_DIR"
TEMPLATE="$REPO_ROOT/.specify/templates/spec-template.md"
SPEC_FILE="$FEATURE_DIR/spec.md"
if [ -f "$TEMPLATE" ]; then cp "$TEMPLATE" "$SPEC_FILE"; else touch "$SPEC_FILE"; fi
# Set the SPECIFY_FEATURE environment variable for the current session
export SPECIFY_FEATURE="$BRANCH_NAME"
if $JSON_MODE; then
printf '{"BRANCH_NAME":"%s","SPEC_FILE":"%s","FEATURE_NUM":"%s"}\n' "$BRANCH_NAME" "$SPEC_FILE" "$FEATURE_NUM"
else
echo "BRANCH_NAME: $BRANCH_NAME"
echo "SPEC_FILE: $SPEC_FILE"
echo "FEATURE_NUM: $FEATURE_NUM"
echo "SPECIFY_FEATURE environment variable set to: $BRANCH_NAME"
fi
-60
View File
@@ -1,60 +0,0 @@
#!/usr/bin/env bash
set -e
# Parse command line arguments
JSON_MODE=false
ARGS=()
for arg in "$@"; do
case "$arg" in
--json)
JSON_MODE=true
;;
--help|-h)
echo "Usage: $0 [--json]"
echo " --json Output results in JSON format"
echo " --help Show this help message"
exit 0
;;
*)
ARGS+=("$arg")
;;
esac
done
# Get script directory and load common functions
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
source "$SCRIPT_DIR/common.sh"
# Get all paths and variables from common functions
eval $(get_feature_paths)
# Check if we're on a proper feature branch (only for git repos)
check_feature_branch "$CURRENT_BRANCH" "$HAS_GIT" || exit 1
# Ensure the feature directory exists
mkdir -p "$FEATURE_DIR"
# Copy plan template if it exists
TEMPLATE="$REPO_ROOT/.specify/templates/plan-template.md"
if [[ -f "$TEMPLATE" ]]; then
cp "$TEMPLATE" "$IMPL_PLAN"
echo "Copied plan template to $IMPL_PLAN"
else
echo "Warning: Plan template not found at $TEMPLATE"
# Create a basic plan file if template doesn't exist
touch "$IMPL_PLAN"
fi
# Output results
if $JSON_MODE; then
printf '{"FEATURE_SPEC":"%s","IMPL_PLAN":"%s","SPECS_DIR":"%s","BRANCH":"%s","HAS_GIT":"%s"}\n' \
"$FEATURE_SPEC" "$IMPL_PLAN" "$FEATURE_DIR" "$CURRENT_BRANCH" "$HAS_GIT"
else
echo "FEATURE_SPEC: $FEATURE_SPEC"
echo "IMPL_PLAN: $IMPL_PLAN"
echo "SPECS_DIR: $FEATURE_DIR"
echo "BRANCH: $CURRENT_BRANCH"
echo "HAS_GIT: $HAS_GIT"
fi
@@ -1,719 +0,0 @@
#!/usr/bin/env bash
# Update agent context files with information from plan.md
#
# This script maintains AI agent context files by parsing feature specifications
# and updating agent-specific configuration files with project information.
#
# MAIN FUNCTIONS:
# 1. Environment Validation
# - Verifies git repository structure and branch information
# - Checks for required plan.md files and templates
# - Validates file permissions and accessibility
#
# 2. Plan Data Extraction
# - Parses plan.md files to extract project metadata
# - Identifies language/version, frameworks, databases, and project types
# - Handles missing or incomplete specification data gracefully
#
# 3. Agent File Management
# - Creates new agent context files from templates when needed
# - Updates existing agent files with new project information
# - Preserves manual additions and custom configurations
# - Supports multiple AI agent formats and directory structures
#
# 4. Content Generation
# - Generates language-specific build/test commands
# - Creates appropriate project directory structures
# - Updates technology stacks and recent changes sections
# - Maintains consistent formatting and timestamps
#
# 5. Multi-Agent Support
# - Handles agent-specific file paths and naming conventions
# - Supports: Claude, Gemini, Copilot, Cursor, Qwen, opencode, Codex, Windsurf
# - Can update single agents or all existing agent files
# - Creates default Claude file if no agent files exist
#
# Usage: ./update-agent-context.sh [agent_type]
# Agent types: claude|gemini|copilot|cursor|qwen|opencode|codex|windsurf
# Leave empty to update all existing agent files
set -e
# Enable strict error handling
set -u
set -o pipefail
#==============================================================================
# Configuration and Global Variables
#==============================================================================
# Get script directory and load common functions
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
source "$SCRIPT_DIR/common.sh"
# Get all paths and variables from common functions
eval $(get_feature_paths)
NEW_PLAN="$IMPL_PLAN" # Alias for compatibility with existing code
AGENT_TYPE="${1:-}"
# Agent-specific file paths
CLAUDE_FILE="$REPO_ROOT/CLAUDE.md"
GEMINI_FILE="$REPO_ROOT/GEMINI.md"
COPILOT_FILE="$REPO_ROOT/.github/copilot-instructions.md"
CURSOR_FILE="$REPO_ROOT/.cursor/rules/specify-rules.mdc"
QWEN_FILE="$REPO_ROOT/QWEN.md"
AGENTS_FILE="$REPO_ROOT/AGENTS.md"
WINDSURF_FILE="$REPO_ROOT/.windsurf/rules/specify-rules.md"
KILOCODE_FILE="$REPO_ROOT/.kilocode/rules/specify-rules.md"
AUGGIE_FILE="$REPO_ROOT/.augment/rules/specify-rules.md"
ROO_FILE="$REPO_ROOT/.roo/rules/specify-rules.md"
# Template file
TEMPLATE_FILE="$REPO_ROOT/.specify/templates/agent-file-template.md"
# Global variables for parsed plan data
NEW_LANG=""
NEW_FRAMEWORK=""
NEW_DB=""
NEW_PROJECT_TYPE=""
#==============================================================================
# Utility Functions
#==============================================================================
log_info() {
echo "INFO: $1"
}
log_success() {
echo "✓ $1"
}
log_error() {
echo "ERROR: $1" >&2
}
log_warning() {
echo "WARNING: $1" >&2
}
# Cleanup function for temporary files
cleanup() {
local exit_code=$?
rm -f /tmp/agent_update_*_$$
rm -f /tmp/manual_additions_$$
exit $exit_code
}
# Set up cleanup trap
trap cleanup EXIT INT TERM
#==============================================================================
# Validation Functions
#==============================================================================
validate_environment() {
# Check if we have a current branch/feature (git or non-git)
if [[ -z "$CURRENT_BRANCH" ]]; then
log_error "Unable to determine current feature"
if [[ "$HAS_GIT" == "true" ]]; then
log_info "Make sure you're on a feature branch"
else
log_info "Set SPECIFY_FEATURE environment variable or create a feature first"
fi
exit 1
fi
# Check if plan.md exists
if [[ ! -f "$NEW_PLAN" ]]; then
log_error "No plan.md found at $NEW_PLAN"
log_info "Make sure you're working on a feature with a corresponding spec directory"
if [[ "$HAS_GIT" != "true" ]]; then
log_info "Use: export SPECIFY_FEATURE=your-feature-name or create a new feature first"
fi
exit 1
fi
# Check if template exists (needed for new files)
if [[ ! -f "$TEMPLATE_FILE" ]]; then
log_warning "Template file not found at $TEMPLATE_FILE"
log_warning "Creating new agent files will fail"
fi
}
#==============================================================================
# Plan Parsing Functions
#==============================================================================
extract_plan_field() {
local field_pattern="$1"
local plan_file="$2"
grep "^\*\*${field_pattern}\*\*: " "$plan_file" 2>/dev/null | \
head -1 | \
sed "s|^\*\*${field_pattern}\*\*: ||" | \
sed 's/^[ \t]*//;s/[ \t]*$//' | \
grep -v "NEEDS CLARIFICATION" | \
grep -v "^N/A$" || echo ""
}
parse_plan_data() {
local plan_file="$1"
if [[ ! -f "$plan_file" ]]; then
log_error "Plan file not found: $plan_file"
return 1
fi
if [[ ! -r "$plan_file" ]]; then
log_error "Plan file is not readable: $plan_file"
return 1
fi
log_info "Parsing plan data from $plan_file"
NEW_LANG=$(extract_plan_field "Language/Version" "$plan_file")
NEW_FRAMEWORK=$(extract_plan_field "Primary Dependencies" "$plan_file")
NEW_DB=$(extract_plan_field "Storage" "$plan_file")
NEW_PROJECT_TYPE=$(extract_plan_field "Project Type" "$plan_file")
# Log what we found
if [[ -n "$NEW_LANG" ]]; then
log_info "Found language: $NEW_LANG"
else
log_warning "No language information found in plan"
fi
if [[ -n "$NEW_FRAMEWORK" ]]; then
log_info "Found framework: $NEW_FRAMEWORK"
fi
if [[ -n "$NEW_DB" ]] && [[ "$NEW_DB" != "N/A" ]]; then
log_info "Found database: $NEW_DB"
fi
if [[ -n "$NEW_PROJECT_TYPE" ]]; then
log_info "Found project type: $NEW_PROJECT_TYPE"
fi
}
format_technology_stack() {
local lang="$1"
local framework="$2"
local parts=()
# Add non-empty parts
[[ -n "$lang" && "$lang" != "NEEDS CLARIFICATION" ]] && parts+=("$lang")
[[ -n "$framework" && "$framework" != "NEEDS CLARIFICATION" && "$framework" != "N/A" ]] && parts+=("$framework")
# Join with proper formatting
if [[ ${#parts[@]} -eq 0 ]]; then
echo ""
elif [[ ${#parts[@]} -eq 1 ]]; then
echo "${parts[0]}"
else
# Join multiple parts with " + "
local result="${parts[0]}"
for ((i=1; i<${#parts[@]}; i++)); do
result="$result + ${parts[i]}"
done
echo "$result"
fi
}
#==============================================================================
# Template and Content Generation Functions
#==============================================================================
get_project_structure() {
local project_type="$1"
if [[ "$project_type" == *"web"* ]]; then
echo "backend/\\nfrontend/\\ntests/"
else
echo "src/\\ntests/"
fi
}
get_commands_for_language() {
local lang="$1"
case "$lang" in
*"Python"*)
echo "cd src && pytest && ruff check ."
;;
*"Rust"*)
echo "cargo test && cargo clippy"
;;
*"JavaScript"*|*"TypeScript"*)
echo "npm test && npm run lint"
;;
*)
echo "# Add commands for $lang"
;;
esac
}
get_language_conventions() {
local lang="$1"
echo "$lang: Follow standard conventions"
}
create_new_agent_file() {
local target_file="$1"
local temp_file="$2"
local project_name="$3"
local current_date="$4"
if [[ ! -f "$TEMPLATE_FILE" ]]; then
log_error "Template not found at $TEMPLATE_FILE"
return 1
fi
if [[ ! -r "$TEMPLATE_FILE" ]]; then
log_error "Template file is not readable: $TEMPLATE_FILE"
return 1
fi
log_info "Creating new agent context file from template..."
if ! cp "$TEMPLATE_FILE" "$temp_file"; then
log_error "Failed to copy template file"
return 1
fi
# Replace template placeholders
local project_structure
project_structure=$(get_project_structure "$NEW_PROJECT_TYPE")
local commands
commands=$(get_commands_for_language "$NEW_LANG")
local language_conventions
language_conventions=$(get_language_conventions "$NEW_LANG")
# Perform substitutions with error checking using safer approach
# Escape special characters for sed by using a different delimiter or escaping
local escaped_lang=$(printf '%s\n' "$NEW_LANG" | sed 's/[\[\.*^$()+{}|]/\\&/g')
local escaped_framework=$(printf '%s\n' "$NEW_FRAMEWORK" | sed 's/[\[\.*^$()+{}|]/\\&/g')
local escaped_branch=$(printf '%s\n' "$CURRENT_BRANCH" | sed 's/[\[\.*^$()+{}|]/\\&/g')
# Build technology stack and recent change strings conditionally
local tech_stack
if [[ -n "$escaped_lang" && -n "$escaped_framework" ]]; then
tech_stack="- $escaped_lang + $escaped_framework ($escaped_branch)"
elif [[ -n "$escaped_lang" ]]; then
tech_stack="- $escaped_lang ($escaped_branch)"
elif [[ -n "$escaped_framework" ]]; then
tech_stack="- $escaped_framework ($escaped_branch)"
else
tech_stack="- ($escaped_branch)"
fi
local recent_change
if [[ -n "$escaped_lang" && -n "$escaped_framework" ]]; then
recent_change="- $escaped_branch: Added $escaped_lang + $escaped_framework"
elif [[ -n "$escaped_lang" ]]; then
recent_change="- $escaped_branch: Added $escaped_lang"
elif [[ -n "$escaped_framework" ]]; then
recent_change="- $escaped_branch: Added $escaped_framework"
else
recent_change="- $escaped_branch: Added"
fi
local substitutions=(
"s|\[PROJECT NAME\]|$project_name|"
"s|\[DATE\]|$current_date|"
"s|\[EXTRACTED FROM ALL PLAN.MD FILES\]|$tech_stack|"
"s|\[ACTUAL STRUCTURE FROM PLANS\]|$project_structure|g"
"s|\[ONLY COMMANDS FOR ACTIVE TECHNOLOGIES\]|$commands|"
"s|\[LANGUAGE-SPECIFIC, ONLY FOR LANGUAGES IN USE\]|$language_conventions|"
"s|\[LAST 3 FEATURES AND WHAT THEY ADDED\]|$recent_change|"
)
for substitution in "${substitutions[@]}"; do
if ! sed -i.bak -e "$substitution" "$temp_file"; then
log_error "Failed to perform substitution: $substitution"
rm -f "$temp_file" "$temp_file.bak"
return 1
fi
done
# Convert \n sequences to actual newlines
newline=$(printf '\n')
sed -i.bak2 "s/\\\\n/${newline}/g" "$temp_file"
# Clean up backup files
rm -f "$temp_file.bak" "$temp_file.bak2"
return 0
}
update_existing_agent_file() {
local target_file="$1"
local current_date="$2"
log_info "Updating existing agent context file..."
# Use a single temporary file for atomic update
local temp_file
temp_file=$(mktemp) || {
log_error "Failed to create temporary file"
return 1
}
# Process the file in one pass
local tech_stack=$(format_technology_stack "$NEW_LANG" "$NEW_FRAMEWORK")
local new_tech_entries=()
local new_change_entry=""
# Prepare new technology entries
if [[ -n "$tech_stack" ]] && ! grep -q "$tech_stack" "$target_file"; then
new_tech_entries+=("- $tech_stack ($CURRENT_BRANCH)")
fi
if [[ -n "$NEW_DB" ]] && [[ "$NEW_DB" != "N/A" ]] && [[ "$NEW_DB" != "NEEDS CLARIFICATION" ]] && ! grep -q "$NEW_DB" "$target_file"; then
new_tech_entries+=("- $NEW_DB ($CURRENT_BRANCH)")
fi
# Prepare new change entry
if [[ -n "$tech_stack" ]]; then
new_change_entry="- $CURRENT_BRANCH: Added $tech_stack"
elif [[ -n "$NEW_DB" ]] && [[ "$NEW_DB" != "N/A" ]] && [[ "$NEW_DB" != "NEEDS CLARIFICATION" ]]; then
new_change_entry="- $CURRENT_BRANCH: Added $NEW_DB"
fi
# Process file line by line
local in_tech_section=false
local in_changes_section=false
local tech_entries_added=false
local changes_entries_added=false
local existing_changes_count=0
while IFS= read -r line || [[ -n "$line" ]]; do
# Handle Active Technologies section
if [[ "$line" == "## Active Technologies" ]]; then
echo "$line" >> "$temp_file"
in_tech_section=true
continue
elif [[ $in_tech_section == true ]] && [[ "$line" =~ ^##[[:space:]] ]]; then
# Add new tech entries before closing the section
if [[ $tech_entries_added == false ]] && [[ ${#new_tech_entries[@]} -gt 0 ]]; then
printf '%s\n' "${new_tech_entries[@]}" >> "$temp_file"
tech_entries_added=true
fi
echo "$line" >> "$temp_file"
in_tech_section=false
continue
elif [[ $in_tech_section == true ]] && [[ -z "$line" ]]; then
# Add new tech entries before empty line in tech section
if [[ $tech_entries_added == false ]] && [[ ${#new_tech_entries[@]} -gt 0 ]]; then
printf '%s\n' "${new_tech_entries[@]}" >> "$temp_file"
tech_entries_added=true
fi
echo "$line" >> "$temp_file"
continue
fi
# Handle Recent Changes section
if [[ "$line" == "## Recent Changes" ]]; then
echo "$line" >> "$temp_file"
# Add new change entry right after the heading
if [[ -n "$new_change_entry" ]]; then
echo "$new_change_entry" >> "$temp_file"
fi
in_changes_section=true
changes_entries_added=true
continue
elif [[ $in_changes_section == true ]] && [[ "$line" =~ ^##[[:space:]] ]]; then
echo "$line" >> "$temp_file"
in_changes_section=false
continue
elif [[ $in_changes_section == true ]] && [[ "$line" == "- "* ]]; then
# Keep only first 2 existing changes
if [[ $existing_changes_count -lt 2 ]]; then
echo "$line" >> "$temp_file"
((existing_changes_count++))
fi
continue
fi
# Update timestamp
if [[ "$line" =~ \*\*Last\ updated\*\*:.*[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9] ]]; then
echo "$line" | sed "s/[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]/$current_date/" >> "$temp_file"
else
echo "$line" >> "$temp_file"
fi
done < "$target_file"
# Post-loop check: if we're still in the Active Technologies section and haven't added new entries
if [[ $in_tech_section == true ]] && [[ $tech_entries_added == false ]] && [[ ${#new_tech_entries[@]} -gt 0 ]]; then
printf '%s\n' "${new_tech_entries[@]}" >> "$temp_file"
fi
# Move temp file to target atomically
if ! mv "$temp_file" "$target_file"; then
log_error "Failed to update target file"
rm -f "$temp_file"
return 1
fi
return 0
}
#==============================================================================
# Main Agent File Update Function
#==============================================================================
update_agent_file() {
local target_file="$1"
local agent_name="$2"
if [[ -z "$target_file" ]] || [[ -z "$agent_name" ]]; then
log_error "update_agent_file requires target_file and agent_name parameters"
return 1
fi
log_info "Updating $agent_name context file: $target_file"
local project_name
project_name=$(basename "$REPO_ROOT")
local current_date
current_date=$(date +%Y-%m-%d)
# Create directory if it doesn't exist
local target_dir
target_dir=$(dirname "$target_file")
if [[ ! -d "$target_dir" ]]; then
if ! mkdir -p "$target_dir"; then
log_error "Failed to create directory: $target_dir"
return 1
fi
fi
if [[ ! -f "$target_file" ]]; then
# Create new file from template
local temp_file
temp_file=$(mktemp) || {
log_error "Failed to create temporary file"
return 1
}
if create_new_agent_file "$target_file" "$temp_file" "$project_name" "$current_date"; then
if mv "$temp_file" "$target_file"; then
log_success "Created new $agent_name context file"
else
log_error "Failed to move temporary file to $target_file"
rm -f "$temp_file"
return 1
fi
else
log_error "Failed to create new agent file"
rm -f "$temp_file"
return 1
fi
else
# Update existing file
if [[ ! -r "$target_file" ]]; then
log_error "Cannot read existing file: $target_file"
return 1
fi
if [[ ! -w "$target_file" ]]; then
log_error "Cannot write to existing file: $target_file"
return 1
fi
if update_existing_agent_file "$target_file" "$current_date"; then
log_success "Updated existing $agent_name context file"
else
log_error "Failed to update existing agent file"
return 1
fi
fi
return 0
}
#==============================================================================
# Agent Selection and Processing
#==============================================================================
update_specific_agent() {
local agent_type="$1"
case "$agent_type" in
claude)
update_agent_file "$CLAUDE_FILE" "Claude Code"
;;
gemini)
update_agent_file "$GEMINI_FILE" "Gemini CLI"
;;
copilot)
update_agent_file "$COPILOT_FILE" "GitHub Copilot"
;;
cursor)
update_agent_file "$CURSOR_FILE" "Cursor IDE"
;;
qwen)
update_agent_file "$QWEN_FILE" "Qwen Code"
;;
opencode)
update_agent_file "$AGENTS_FILE" "opencode"
;;
codex)
update_agent_file "$AGENTS_FILE" "Codex CLI"
;;
windsurf)
update_agent_file "$WINDSURF_FILE" "Windsurf"
;;
kilocode)
update_agent_file "$KILOCODE_FILE" "Kilo Code"
;;
auggie)
update_agent_file "$AUGGIE_FILE" "Auggie CLI"
;;
roo)
update_agent_file "$ROO_FILE" "Roo Code"
;;
*)
log_error "Unknown agent type '$agent_type'"
log_error "Expected: claude|gemini|copilot|cursor|qwen|opencode|codex|windsurf|kilocode|auggie|roo"
exit 1
;;
esac
}
update_all_existing_agents() {
local found_agent=false
# Check each possible agent file and update if it exists
if [[ -f "$CLAUDE_FILE" ]]; then
update_agent_file "$CLAUDE_FILE" "Claude Code"
found_agent=true
fi
if [[ -f "$GEMINI_FILE" ]]; then
update_agent_file "$GEMINI_FILE" "Gemini CLI"
found_agent=true
fi
if [[ -f "$COPILOT_FILE" ]]; then
update_agent_file "$COPILOT_FILE" "GitHub Copilot"
found_agent=true
fi
if [[ -f "$CURSOR_FILE" ]]; then
update_agent_file "$CURSOR_FILE" "Cursor IDE"
found_agent=true
fi
if [[ -f "$QWEN_FILE" ]]; then
update_agent_file "$QWEN_FILE" "Qwen Code"
found_agent=true
fi
if [[ -f "$AGENTS_FILE" ]]; then
update_agent_file "$AGENTS_FILE" "Codex/opencode"
found_agent=true
fi
if [[ -f "$WINDSURF_FILE" ]]; then
update_agent_file "$WINDSURF_FILE" "Windsurf"
found_agent=true
fi
if [[ -f "$KILOCODE_FILE" ]]; then
update_agent_file "$KILOCODE_FILE" "Kilo Code"
found_agent=true
fi
if [[ -f "$AUGGIE_FILE" ]]; then
update_agent_file "$AUGGIE_FILE" "Auggie CLI"
found_agent=true
fi
if [[ -f "$ROO_FILE" ]]; then
update_agent_file "$ROO_FILE" "Roo Code"
found_agent=true
fi
# If no agent files exist, create a default Claude file
if [[ "$found_agent" == false ]]; then
log_info "No existing agent files found, creating default Claude file..."
update_agent_file "$CLAUDE_FILE" "Claude Code"
fi
}
print_summary() {
echo
log_info "Summary of changes:"
if [[ -n "$NEW_LANG" ]]; then
echo " - Added language: $NEW_LANG"
fi
if [[ -n "$NEW_FRAMEWORK" ]]; then
echo " - Added framework: $NEW_FRAMEWORK"
fi
if [[ -n "$NEW_DB" ]] && [[ "$NEW_DB" != "N/A" ]]; then
echo " - Added database: $NEW_DB"
fi
echo
log_info "Usage: $0 [claude|gemini|copilot|cursor|qwen|opencode|codex|windsurf|kilocode|auggie|roo]"
}
#==============================================================================
# Main Execution
#==============================================================================
main() {
# Validate environment before proceeding
validate_environment
log_info "=== Updating agent context files for feature $CURRENT_BRANCH ==="
# Parse the plan file to extract project information
if ! parse_plan_data "$NEW_PLAN"; then
log_error "Failed to parse plan data"
exit 1
fi
# Process based on agent type argument
local success=true
if [[ -z "$AGENT_TYPE" ]]; then
# No specific agent provided - update all existing agent files
log_info "No agent specified, updating all existing agent files..."
if ! update_all_existing_agents; then
success=false
fi
else
# Specific agent provided - update only that agent
log_info "Updating specific agent: $AGENT_TYPE"
if ! update_specific_agent "$AGENT_TYPE"; then
success=false
fi
fi
# Print summary
print_summary
if [[ "$success" == true ]]; then
log_success "Agent context update completed successfully"
exit 0
else
log_error "Agent context update completed with errors"
exit 1
fi
}
# Execute main function if script is run directly
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
main "$@"
fi
-23
View File
@@ -1,23 +0,0 @@
# [PROJECT NAME] Development Guidelines
Auto-generated from all feature plans. Last updated: [DATE]
## Active Technologies
[EXTRACTED FROM ALL PLAN.MD FILES]
## Project Structure
```
[ACTUAL STRUCTURE FROM PLANS]
```
## Commands
[ONLY COMMANDS FOR ACTIVE TECHNOLOGIES]
## Code Style
[LANGUAGE-SPECIFIC, ONLY FOR LANGUAGES IN USE]
## Recent Changes
[LAST 3 FEATURES AND WHAT THEY ADDED]
<!-- MANUAL ADDITIONS START -->
<!-- MANUAL ADDITIONS END -->
-219
View File
@@ -1,219 +0,0 @@
# Implementation Plan: [FEATURE]
**Branch**: `[###-feature-name]` | **Date**: [DATE] | **Spec**: [link]
**Input**: Feature specification from `/specs/[###-feature-name]/spec.md`
## Execution Flow (/plan command scope)
```
1. Load feature spec from Input path
→ If not found: ERROR "No feature spec at {path}"
2. Fill Technical Context (scan for NEEDS CLARIFICATION)
→ Detect Project Type from file system structure or context (web=frontend+backend, mobile=app+api)
→ Set Structure Decision based on project type
3. Fill the Constitution Check section based on the content of the constitution document.
4. Evaluate Constitution Check section below
→ If violations exist: Document in Complexity Tracking
→ If no justification possible: ERROR "Simplify approach first"
→ Update Progress Tracking: Initial Constitution Check
5. Execute Phase 0 → research.md
→ If NEEDS CLARIFICATION remain: ERROR "Resolve unknowns"
6. Execute Phase 1 → contracts, data-model.md, quickstart.md, agent-specific template file (e.g., `CLAUDE.md` for Claude Code, `.github/copilot-instructions.md` for GitHub Copilot, `GEMINI.md` for Gemini CLI, `QWEN.md` for Qwen Code or `AGENTS.md` for opencode).
7. Re-evaluate Constitution Check section
→ If new violations: Refactor design, return to Phase 1
→ Update Progress Tracking: Post-Design Constitution Check
8. Plan Phase 2 → Describe task generation approach (DO NOT create tasks.md)
9. STOP - Ready for /tasks command
```
**IMPORTANT**: The /plan command STOPS at step 7. Phases 2-4 are executed by other commands:
- Phase 2: /tasks command creates tasks.md
- Phase 3-4: Implementation execution (manual or via tools)
## Summary
[Extract from feature spec: primary requirement + technical approach from research]
## Technical Context
**Language/Version**: [e.g., Python 3.11, Swift 5.9, Rust 1.75 or NEEDS CLARIFICATION]
**Primary Dependencies**: [e.g., FastAPI, UIKit, LLVM or NEEDS CLARIFICATION]
**Storage**: [if applicable, e.g., PostgreSQL, CoreData, files or N/A]
**Testing**: [e.g., pytest, XCTest, cargo test or NEEDS CLARIFICATION]
**Target Platform**: [e.g., Linux server, iOS 15+, WASM or NEEDS CLARIFICATION]
**Project Type**: [single/web/mobile - determines source structure]
**Performance Goals**: [domain-specific, e.g., 1000 req/s, 10k lines/sec, 60 fps or NEEDS CLARIFICATION]
**Constraints**: [domain-specific, e.g., <200ms p95, <100MB memory, offline-capable or NEEDS CLARIFICATION]
**Scale/Scope**: [domain-specific, e.g., 10k users, 1M LOC, 50 screens or NEEDS CLARIFICATION]
## Constitution Check
*GATE: Must pass before Phase 0 research. Re-check after Phase 1 design.*
[Gates determined based on constitution file]
## Project Structure
### Documentation (this feature)
```
specs/[###-feature]/
├── plan.md # This file (/plan command output)
├── research.md # Phase 0 output (/plan command)
├── data-model.md # Phase 1 output (/plan command)
├── quickstart.md # Phase 1 output (/plan command)
├── contracts/ # Phase 1 output (/plan command)
└── tasks.md # Phase 2 output (/tasks command - NOT created by /plan)
```
### Source Code (repository root)
<!--
ACTION REQUIRED: Replace the placeholder tree below with the concrete layout
for this feature. Delete unused options and expand the chosen structure with
real paths (e.g., apps/admin, packages/something). The delivered plan must
not include Option labels.
-->
```
# [REMOVE IF UNUSED] Option 1: Single project (DEFAULT)
src/
├── models/
├── services/
├── cli/
└── lib/
tests/
├── contract/
├── integration/
└── unit/
# [REMOVE IF UNUSED] Option 2: Web application (when "frontend" + "backend" detected)
backend/
├── src/
│ ├── models/
│ ├── services/
│ └── api/
└── tests/
frontend/
├── src/
│ ├── components/
│ ├── pages/
│ └── services/
└── tests/
# [REMOVE IF UNUSED] Option 3: Mobile + API (when "iOS/Android" detected)
api/
└── [same as backend above]
ios/ or android/
└── [platform-specific structure: feature modules, UI flows, platform tests]
```
**Structure Decision**: [Document the selected structure and reference the real
directories captured above]
## Phase 0: Outline & Research
1. **Extract unknowns from Technical Context** above:
- For each NEEDS CLARIFICATION → research task
- For each dependency → best practices task
- For each integration → patterns task
2. **Generate and dispatch research agents**:
```
For each unknown in Technical Context:
Task: "Research {unknown} for {feature context}"
For each technology choice:
Task: "Find best practices for {tech} in {domain}"
```
3. **Consolidate findings** in `research.md` using format:
- Decision: [what was chosen]
- Rationale: [why chosen]
- Alternatives considered: [what else evaluated]
**Output**: research.md with all NEEDS CLARIFICATION resolved
## Phase 1: Design & Contracts
*Prerequisites: research.md complete*
1. **Extract entities from feature spec** → `data-model.md`:
- Entity name, fields, relationships
- Validation rules from requirements
- State transitions if applicable
2. **Generate API contracts** from functional requirements:
- For each user action → endpoint
- Use standard REST/GraphQL patterns
- Output OpenAPI/GraphQL schema to `/contracts/`
3. **Generate contract tests** from contracts:
- One test file per endpoint
- Assert request/response schemas
- Tests must fail (no implementation yet)
4. **Extract test scenarios** from user stories:
- Each story → integration test scenario
- Quickstart test = story validation steps
5. **Update agent file incrementally** (O(1) operation):
- Run `.specify/scripts/bash/update-agent-context.sh cursor`
**IMPORTANT**: Execute it exactly as specified above. Do not add or remove any arguments.
- If exists: Add only NEW tech from current plan
- Preserve manual additions between markers
- Update recent changes (keep last 3)
- Keep under 150 lines for token efficiency
- Output to repository root
**Output**: data-model.md, /contracts/*, failing tests, quickstart.md, agent-specific file
## Phase 2: Task Planning Approach
*This section describes what the /tasks command will do - DO NOT execute during /plan*
**Task Generation Strategy**:
- Load `.specify/templates/tasks-template.md` as base
- Generate tasks from Phase 1 design docs (contracts, data model, quickstart)
- Each contract → contract test task [P]
- Each entity → model creation task [P]
- Each user story → integration test task
- Implementation tasks to make tests pass
**Ordering Strategy**:
- TDD order: Tests before implementation
- Dependency order: Models before services before UI
- Mark [P] for parallel execution (independent files)
**Estimated Output**: 25-30 numbered, ordered tasks in tasks.md
**IMPORTANT**: This phase is executed by the /tasks command, NOT by /plan
## Phase 3+: Future Implementation
*These phases are beyond the scope of the /plan command*
**Phase 3**: Task execution (/tasks command creates tasks.md)
**Phase 4**: Implementation (execute tasks.md following constitutional principles)
**Phase 5**: Validation (run tests, execute quickstart.md, performance validation)
## Complexity Tracking
*Fill ONLY if Constitution Check has violations that must be justified*
| Violation | Why Needed | Simpler Alternative Rejected Because |
|-----------|------------|-------------------------------------|
| [e.g., 4th project] | [current need] | [why 3 projects insufficient] |
| [e.g., Repository pattern] | [specific problem] | [why direct DB access insufficient] |
## Progress Tracking
*This checklist is updated during execution flow*
**Phase Status**:
- [ ] Phase 0: Research complete (/plan command)
- [ ] Phase 1: Design complete (/plan command)
- [ ] Phase 2: Task planning complete (/plan command - describe approach only)
- [ ] Phase 3: Tasks generated (/tasks command)
- [ ] Phase 4: Implementation complete
- [ ] Phase 5: Validation passed
**Gate Status**:
- [ ] Initial Constitution Check: PASS
- [ ] Post-Design Constitution Check: PASS
- [ ] All NEEDS CLARIFICATION resolved
- [ ] Complexity deviations documented
---
*Based on Constitution v2.1.1 - See `/memory/constitution.md`*
-116
View File
@@ -1,116 +0,0 @@
# Feature Specification: [FEATURE NAME]
**Feature Branch**: `[###-feature-name]`
**Created**: [DATE]
**Status**: Draft
**Input**: User description: "$ARGUMENTS"
## Execution Flow (main)
```
1. Parse user description from Input
→ If empty: ERROR "No feature description provided"
2. Extract key concepts from description
→ Identify: actors, actions, data, constraints
3. For each unclear aspect:
→ Mark with [NEEDS CLARIFICATION: specific question]
4. Fill User Scenarios & Testing section
→ If no clear user flow: ERROR "Cannot determine user scenarios"
5. Generate Functional Requirements
→ Each requirement must be testable
→ Mark ambiguous requirements
6. Identify Key Entities (if data involved)
7. Run Review Checklist
→ If any [NEEDS CLARIFICATION]: WARN "Spec has uncertainties"
→ If implementation details found: ERROR "Remove tech details"
8. Return: SUCCESS (spec ready for planning)
```
---
## ⚡ Quick Guidelines
- ✅ Focus on WHAT users need and WHY
- ❌ Avoid HOW to implement (no tech stack, APIs, code structure)
- 👥 Written for business stakeholders, not developers
### Section Requirements
- **Mandatory sections**: Must be completed for every feature
- **Optional sections**: Include only when relevant to the feature
- When a section doesn't apply, remove it entirely (don't leave as "N/A")
### For AI Generation
When creating this spec from a user prompt:
1. **Mark all ambiguities**: Use [NEEDS CLARIFICATION: specific question] for any assumption you'd need to make
2. **Don't guess**: If the prompt doesn't specify something (e.g., "login system" without auth method), mark it
3. **Think like a tester**: Every vague requirement should fail the "testable and unambiguous" checklist item
4. **Common underspecified areas**:
- User types and permissions
- Data retention/deletion policies
- Performance targets and scale
- Error handling behaviors
- Integration requirements
- Security/compliance needs
---
## User Scenarios & Testing *(mandatory)*
### Primary User Story
[Describe the main user journey in plain language]
### Acceptance Scenarios
1. **Given** [initial state], **When** [action], **Then** [expected outcome]
2. **Given** [initial state], **When** [action], **Then** [expected outcome]
### Edge Cases
- What happens when [boundary condition]?
- How does system handle [error scenario]?
## Requirements *(mandatory)*
### Functional Requirements
- **FR-001**: System MUST [specific capability, e.g., "allow users to create accounts"]
- **FR-002**: System MUST [specific capability, e.g., "validate email addresses"]
- **FR-003**: Users MUST be able to [key interaction, e.g., "reset their password"]
- **FR-004**: System MUST [data requirement, e.g., "persist user preferences"]
- **FR-005**: System MUST [behavior, e.g., "log all security events"]
*Example of marking unclear requirements:*
- **FR-006**: System MUST authenticate users via [NEEDS CLARIFICATION: auth method not specified - email/password, SSO, OAuth?]
- **FR-007**: System MUST retain user data for [NEEDS CLARIFICATION: retention period not specified]
### Key Entities *(include if feature involves data)*
- **[Entity 1]**: [What it represents, key attributes without implementation]
- **[Entity 2]**: [What it represents, relationships to other entities]
---
## Review & Acceptance Checklist
*GATE: Automated checks run during main() execution*
### Content Quality
- [ ] No implementation details (languages, frameworks, APIs)
- [ ] Focused on user value and business needs
- [ ] Written for non-technical stakeholders
- [ ] All mandatory sections completed
### Requirement Completeness
- [ ] No [NEEDS CLARIFICATION] markers remain
- [ ] Requirements are testable and unambiguous
- [ ] Success criteria are measurable
- [ ] Scope is clearly bounded
- [ ] Dependencies and assumptions identified
---
## Execution Status
*Updated by main() during processing*
- [ ] User description parsed
- [ ] Key concepts extracted
- [ ] Ambiguities marked
- [ ] User scenarios defined
- [ ] Requirements generated
- [ ] Entities identified
- [ ] Review checklist passed
---
-127
View File
@@ -1,127 +0,0 @@
# Tasks: [FEATURE NAME]
**Input**: Design documents from `/specs/[###-feature-name]/`
**Prerequisites**: plan.md (required), research.md, data-model.md, contracts/
## Execution Flow (main)
```
1. Load plan.md from feature directory
→ If not found: ERROR "No implementation plan found"
→ Extract: tech stack, libraries, structure
2. Load optional design documents:
→ data-model.md: Extract entities → model tasks
→ contracts/: Each file → contract test task
→ research.md: Extract decisions → setup tasks
3. Generate tasks by category:
→ Setup: project init, dependencies, linting
→ Tests: contract tests, integration tests
→ Core: models, services, CLI commands
→ Integration: DB, middleware, logging
→ Polish: unit tests, performance, docs
4. Apply task rules:
→ Different files = mark [P] for parallel
→ Same file = sequential (no [P])
→ Tests before implementation (TDD)
5. Number tasks sequentially (T001, T002...)
6. Generate dependency graph
7. Create parallel execution examples
8. Validate task completeness:
→ All contracts have tests?
→ All entities have models?
→ All endpoints implemented?
9. Return: SUCCESS (tasks ready for execution)
```
## Format: `[ID] [P?] Description`
- **[P]**: Can run in parallel (different files, no dependencies)
- Include exact file paths in descriptions
## Path Conventions
- **Single project**: `src/`, `tests/` at repository root
- **Web app**: `backend/src/`, `frontend/src/`
- **Mobile**: `api/src/`, `ios/src/` or `android/src/`
- Paths shown below assume single project - adjust based on plan.md structure
## Phase 3.1: Setup
- [ ] T001 Create project structure per implementation plan
- [ ] T002 Initialize [language] project with [framework] dependencies
- [ ] T003 [P] Configure linting and formatting tools
## Phase 3.2: Tests First (TDD) ⚠️ MUST COMPLETE BEFORE 3.3
**CRITICAL: These tests MUST be written and MUST FAIL before ANY implementation**
- [ ] T004 [P] Contract test POST /api/users in tests/contract/test_users_post.py
- [ ] T005 [P] Contract test GET /api/users/{id} in tests/contract/test_users_get.py
- [ ] T006 [P] Integration test user registration in tests/integration/test_registration.py
- [ ] T007 [P] Integration test auth flow in tests/integration/test_auth.py
## Phase 3.3: Core Implementation (ONLY after tests are failing)
- [ ] T008 [P] User model in src/models/user.py
- [ ] T009 [P] UserService CRUD in src/services/user_service.py
- [ ] T010 [P] CLI --create-user in src/cli/user_commands.py
- [ ] T011 POST /api/users endpoint
- [ ] T012 GET /api/users/{id} endpoint
- [ ] T013 Input validation
- [ ] T014 Error handling and logging
## Phase 3.4: Integration
- [ ] T015 Connect UserService to DB
- [ ] T016 Auth middleware
- [ ] T017 Request/response logging
- [ ] T018 CORS and security headers
## Phase 3.5: Polish
- [ ] T019 [P] Unit tests for validation in tests/unit/test_validation.py
- [ ] T020 Performance tests (<200ms)
- [ ] T021 [P] Update docs/api.md
- [ ] T022 Remove duplication
- [ ] T023 Run manual-testing.md
## Dependencies
- Tests (T004-T007) before implementation (T008-T014)
- T008 blocks T009, T015
- T016 blocks T018
- Implementation before polish (T019-T023)
## Parallel Example
```
# Launch T004-T007 together:
Task: "Contract test POST /api/users in tests/contract/test_users_post.py"
Task: "Contract test GET /api/users/{id} in tests/contract/test_users_get.py"
Task: "Integration test registration in tests/integration/test_registration.py"
Task: "Integration test auth in tests/integration/test_auth.py"
```
## Notes
- [P] tasks = different files, no dependencies
- Verify tests fail before implementing
- Commit after each task
- Avoid: vague tasks, same file conflicts
## Task Generation Rules
*Applied during main() execution*
1. **From Contracts**:
- Each contract file → contract test task [P]
- Each endpoint → implementation task
2. **From Data Model**:
- Each entity → model creation task [P]
- Relationships → service layer tasks
3. **From User Stories**:
- Each story → integration test [P]
- Quickstart scenarios → validation tasks
4. **Ordering**:
- Setup → Tests → Models → Services → Endpoints → Polish
- Dependencies block parallel execution
## Validation Checklist
*GATE: Checked by main() before returning*
- [ ] All contracts have corresponding tests
- [ ] All entities have model tasks
- [ ] All tests come before implementation
- [ ] Parallel tasks truly independent
- [ ] Each task specifies exact file path
- [ ] No task modifies same file as another [P] task
-144
View File
@@ -1,144 +0,0 @@
# Karaoke-Gen AI Assistant Guidelines
## Project Overview
**Karaoke video generation platform** - CLI tool and web service that creates professional karaoke videos with synchronized lyrics.
- **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>
## Quick Reference
| 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` |
## Tech Stack
- **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
## Essential Rules
### 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
### Testing (Required Before Commit)
```bash
# Backend (10 min timeout, limit output)
make test 2>&1 | tail -n 500
# Frontend
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
### Infrastructure
- All GCP changes via Pulumi in `infrastructure/`
- `gcloud` CLI for reading/debugging only
- Stop and notify user on auth issues
## API Authentication (for Agents)
When you need to call backend APIs programmatically:
### Internal Worker Endpoints
Use the `X-Admin-Token` header with the token from Secret Manager:
```bash
# Trigger video worker
curl -X POST "https://api.nomadkaraoke.com/api/internal/workers/video" \
-H "X-Admin-Token: $(gcloud secrets versions access latest --secret=admin-tokens --project=nomadkaraoke)" \
-H "Content-Type: application/json" \
-d '{"job_id": "YOUR_JOB_ID"}'
# Other internal endpoints follow the same pattern
```
### Firestore Direct Access
```bash
# Set the correct project
export GOOGLE_CLOUD_PROJECT=nomadkaraoke
# Use Python with google-cloud-firestore
python3 << 'EOF'
import os
os.environ['GOOGLE_CLOUD_PROJECT'] = 'nomadkaraoke'
from google.cloud import firestore
db = firestore.Client(project='nomadkaraoke')
# Query/update documents...
EOF
```
### GCE Encoding Worker
```bash
# SSH to restart service (clears in-memory job queue)
gcloud compute ssh encoding-worker --zone=us-central1-a --project=nomadkaraoke \
--command="sudo systemctl restart encoding-worker"
# Check health
gcloud compute ssh encoding-worker --zone=us-central1-a --project=nomadkaraoke \
--command="curl -s http://localhost:8080/health"
```
### What Doesn't Work
- `gcloud auth print-identity-token` - Wrong token type for internal endpoints
- Cloud Tasks without proper service account - Gets 401 from Cloud Run
## Documentation Maintenance
### 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)
```
### 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
### 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
## 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)
+1 -1
View File
@@ -1,6 +1,6 @@
MIT License
Copyright (c) 2024 Nomad Karaoke LLC
Copyright (c) 2025 Nomad Karaoke LLC
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
-77
View File
@@ -1,77 +0,0 @@
# Makefile for karaoke-gen project
# Run `make help` to see available commands
.PHONY: help test test-unit test-backend test-integration test-e2e test-all lint clean emulators-start emulators-stop
# Default target
help:
@echo "Available commands:"
@echo " make test - Run all tests (unit + backend + emulator-based)"
@echo " make test-unit - Run unit tests only (karaoke_gen)"
@echo " make test-backend - Run backend unit tests only"
@echo " make test-e2e - Run E2E tests with emulators (starts/stops automatically)"
@echo " make test-all - Alias for 'make test'"
@echo " make lint - Run linter checks"
@echo " make emulators-start - Start GCP emulators for local development"
@echo " make emulators-stop - Stop GCP emulators"
@echo ""
@echo "Before committing, run: make test"
# Run unit tests for karaoke_gen package
test-unit:
@echo "=== Running karaoke_gen unit tests ==="
poetry run pytest tests/unit/ -v --cov=karaoke_gen --cov-report=term-missing --cov-fail-under=69
# Run backend unit tests
test-backend:
@echo "=== Running backend unit tests ==="
poetry run pytest backend/tests/ --ignore=backend/tests/emulator -v
# Run E2E integration tests with emulators
test-e2e:
@echo "=== Running E2E integration tests with emulators ==="
@./scripts/start-emulators.sh || (echo "Failed to start emulators" && exit 1)
@export FIRESTORE_EMULATOR_HOST=127.0.0.1:8080 && \
export STORAGE_EMULATOR_HOST=http://127.0.0.1:4443 && \
export GOOGLE_CLOUD_PROJECT=test-project && \
export GCS_BUCKET_NAME=test-bucket && \
export ADMIN_TOKENS=test-admin-token && \
export ENVIRONMENT=test && \
poetry run pytest backend/tests/emulator/ -v; \
TEST_RESULT=$$?; \
./scripts/stop-emulators.sh; \
exit $$TEST_RESULT
# Run all tests (use this before committing!)
test: test-unit test-backend test-e2e
@echo ""
@echo "✅ All tests passed! Ready to commit."
# Alias for test
test-all: test
# Lint checks
lint:
@echo "=== Running lint checks ==="
poetry run ruff check karaoke_gen/ backend/
poetry run ruff format --check karaoke_gen/ backend/
# Start emulators for local development
emulators-start:
@echo "=== Starting GCP emulators ==="
./scripts/start-emulators.sh
# Stop emulators
emulators-stop:
@echo "=== Stopping GCP emulators ==="
./scripts/stop-emulators.sh
# Clean up temporary files
clean:
find . -type d -name "__pycache__" -exec rm -rf {} + 2>/dev/null || true
find . -type d -name ".pytest_cache" -exec rm -rf {} + 2>/dev/null || true
find . -type d -name ".coverage" -exec rm -rf {} + 2>/dev/null || true
find . -type f -name "*.pyc" -delete 2>/dev/null || true
rm -rf htmlcov/ .coverage coverage.xml 2>/dev/null || true
@echo "Cleaned up temporary files"
+111 -660
View File
@@ -1,693 +1,144 @@
# Karaoke Generator 🎶 🎥 🚀
# Karaoke Gen
![PyPI - Version](https://img.shields.io/pypi/v/karaoke-gen)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/karaoke-gen)
![Tests](https://github.com/nomadkaraoke/karaoke-gen/workflows/Test%20and%20Publish/badge.svg)
![Test Coverage](https://codecov.io/gh/nomadkaraoke/karaoke-gen/branch/main/graph/badge.svg)
Generate karaoke videos with synchronized lyrics. Handles the entire process from downloading audio and lyrics to creating the final video with title screens.
Generate professional karaoke videos with instrumental audio and synchronized lyrics. Available as a **local CLI** (`karaoke-gen`) or **cloud-based CLI** (`karaoke-gen-remote`) that offloads processing to Google Cloud.
## Overview
## ✨ Two Ways to Generate Karaoke
Karaoke Gen is a comprehensive tool for creating high-quality karaoke videos. It automates the entire workflow:
### 1. Local CLI (`karaoke-gen`)
Run all processing locally on your machine. Requires GPU for optimal audio separation performance.
1. **Download** audio and lyrics for a specified song
2. **Separate** audio stems (vocals, instrumental)
3. **Synchronize** lyrics with the audio
4. **Generate** title and end screens
5. **Combine** everything into a polished final video
6. **Organize** and **share** the output files
```bash
karaoke-gen "ABBA" "Waterloo"
```
### 2. Remote CLI (`karaoke-gen-remote`)
Offload all processing to a cloud backend. No GPU required - just authenticate and submit jobs.
```bash
karaoke-gen-remote ./song.flac "ABBA" "Waterloo"
```
Both CLIs produce identical outputs: 4K karaoke videos, CDG+MP3 packages, audio stems, and more.
---
## 🎯 Features
### Core Pipeline
- **Audio Separation**: AI-powered vocal/instrumental separation using MDX and Demucs models
- **Lyrics Transcription**: Word-level timestamps via AudioShake API
- **Lyrics Correction**: Match transcription against online lyrics (Genius, Spotify, Musixmatch)
- **Human Review**: Interactive UI for correcting lyrics before final render
- **Video Rendering**: High-quality 4K karaoke videos with customizable styles
- **Multiple Outputs**: MP4 (4K lossless/lossy, 720p), MKV, CDG+MP3, TXT+MP3
### Distribution Features
- **YouTube Upload**: Automatic upload to your YouTube channel
- **Dropbox Integration**: Organize output in brand-coded folders
- **Google Drive**: Upload to public share folders
- **Discord Notifications**: Webhook notifications on completion
---
## 📦 Installation
## Installation
```bash
pip install karaoke-gen
```
This installs both `karaoke-gen` (local) and `karaoke-gen-remote` (cloud) CLIs.
### Requirements
- Python 3.10-3.13
- FFmpeg
- For local processing: CUDA-capable GPU or Apple Silicon CPU recommended
### Transcription Provider Setup
**Transcription is required** for creating karaoke videos with synchronized lyrics. The system needs word-level timing data to display lyrics in sync with the music.
#### Option 1: AudioShake (Recommended)
Commercial service with high-quality transcription. Best for production use.
## Quick Start
```bash
export AUDIOSHAKE_API_TOKEN="your_audioshake_token"
```
# Generate a karaoke video from a YouTube URL
karaoke-gen "https://www.youtube.com/watch?v=dQw4w9WgXcQ" "Rick Astley" "Never Gonna Give You Up"
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.
```bash
export RUNPOD_API_KEY="your_runpod_key"
export WHISPER_RUNPOD_ID="your_whisper_endpoint_id"
```
Set up a Whisper endpoint at [https://www.runpod.io/](https://www.runpod.io/)
#### Without Transcription (Instrumental Only)
If you don't need synchronized lyrics, use the `--skip-lyrics` flag:
```bash
karaoke-gen --skip-lyrics "Artist" "Title"
```
This creates an instrumental-only karaoke video without lyrics overlay.
> **Note:** See `lyrics_transcriber_temp/README.md` for detailed transcription provider configuration options.
---
## 🖥️ Local CLI (`karaoke-gen`)
### Basic Usage
```bash
# Generate from local audio file
karaoke-gen ./song.mp3 "Artist Name" "Song Title"
# Search and download audio automatically
# Or let it search YouTube for you
karaoke-gen "Rick Astley" "Never Gonna Give You Up"
# Process from YouTube URL
karaoke-gen "https://www.youtube.com/watch?v=dQw4w9WgXcQ" "Rick Astley" "Never Gonna Give You Up"
# Process multiple tracks in bulk from a CSV file
karaoke-bulk input.csv --style_params_json=style.json
```
### Remote Audio Separation (Optional)
## Workflow Options
Offload just the GPU-intensive audio separation to Modal.com while keeping other processing local:
Karaoke Gen supports different workflow options to fit your needs:
```bash
export AUDIO_SEPARATOR_API_URL="https://USERNAME--audio-separator-api.modal.run"
karaoke-gen "Artist" "Title"
# Run only the preparation phase (download, separate stems, create title screens)
karaoke-gen --prep-only "Rick Astley" "Never Gonna Give You Up"
# Run only the finalisation phase (must be run in a directory prepared by the prep phase)
karaoke-gen --finalise-only
# Skip automatic lyrics transcription/synchronization (for manual syncing)
karaoke-gen --skip-transcription "Rick Astley" "Never Gonna Give You Up"
# Skip audio separation (if you already have instrumental)
karaoke-gen --skip-separation --existing-instrumental="path/to/instrumental.mp3" "Rick Astley" "Never Gonna Give You Up"
```
### Key Options
## Advanced Features
### Audio Processing
```bash
# Custom styling
karaoke-gen --style_params_json="./styles.json" "Artist" "Title"
# Generate CDG and TXT packages
karaoke-gen --enable_cdg --enable_txt "Artist" "Title"
# YouTube upload
karaoke-gen --enable_youtube_upload --youtube_description_file="./desc.txt" "Artist" "Title"
# Full production run
karaoke-gen \
--style_params_json="./branding.json" \
--enable_cdg \
--enable_txt \
--brand_prefix="BRAND" \
--enable_youtube_upload \
--youtube_description_file="./description.txt" \
"Artist" "Title"
# Specify custom audio separation models
karaoke-gen --clean_instrumental_model="model_name.ckpt" "Rick Astley" "Never Gonna Give You Up"
```
### Full Options Reference
### Lyrics Handling
```bash
# Use a local lyrics file instead of fetching from online
karaoke-gen --lyrics_file="path/to/lyrics.txt" "Rick Astley" "Never Gonna Give You Up"
# Adjust subtitle timing
karaoke-gen --subtitle_offset_ms=500 "Rick Astley" "Never Gonna Give You Up"
```
### Finalisation Options
```bash
# Enable CDG ZIP generation
karaoke-gen --enable_cdg --style_params_json="path/to/style.json" "Rick Astley" "Never Gonna Give You Up"
# Enable TXT ZIP generation
karaoke-gen --enable_txt "Rick Astley" "Never Gonna Give You Up"
# Upload to YouTube
karaoke-gen --youtube_client_secrets_file="path/to/client_secret.json" --youtube_description_file="path/to/description.txt" "Rick Astley" "Never Gonna Give You Up"
# Organize files with brand code
karaoke-gen --brand_prefix="BRAND" --organised_dir="path/to/Tracks-Organized" "Rick Astley" "Never Gonna Give You Up"
```
## Python API
Karaoke Gen can also be used as a Python library:
```python
import asyncio
from karaoke_gen import KaraokeController, ProjectConfig
async def generate_karaoke():
# Create a configuration
config = ProjectConfig(
artist="Rick Astley",
title="Never Gonna Give You Up",
input_media="https://www.youtube.com/watch?v=dQw4w9WgXcQ",
output_dir="output",
create_track_subfolders=True,
)
# Create a controller
controller = KaraokeController(config)
# Process the track
tracks = await controller.process()
# Print the output files
for track in tracks:
print(f"Final video: {track.final_video}")
# Run the async function
asyncio.run(generate_karaoke())
```
## Architecture
Karaoke Gen has a modular architecture with the following components:
- **Controller**: Orchestrates the entire process
- **Services**: Handle specific aspects of the process
- **Media Service**: Downloads and extracts media
- **Audio Service**: Separates and processes audio
- **Lyrics Service**: Fetches and synchronizes lyrics
- **Video Service**: Renders video with synchronized lyrics
- **Distribution Service**: Organizes and shares the output files
- **Utilities**: Common utility functions for file handling, logging, etc.
## Full Command Reference
For a complete list of options:
```bash
karaoke-gen --help
karaoke-bulk --help
```
---
## ☁️ Remote CLI (`karaoke-gen-remote`)
The remote CLI submits jobs to a Google Cloud backend that handles all processing. You don't need a GPU or any audio processing libraries installed locally.
### Setup
1. **Set the backend URL:**
```bash
export KARAOKE_GEN_URL="https://api.nomadkaraoke.com" # Or your own backend
```
2. **Authenticate with Google Cloud:**
```bash
gcloud auth login
```
### Basic Usage
```bash
# Submit a job
karaoke-gen-remote ./song.flac "ABBA" "Waterloo"
# The CLI will:
# 1. Upload your audio file
# 2. Monitor processing progress
# 3. Open lyrics review UI when ready
# 4. Prompt for instrumental selection
# 5. Download all outputs when complete
```
### Job Management
```bash
# List all jobs
karaoke-gen-remote --list
# Resume monitoring an existing job
karaoke-gen-remote --resume abc12345
# Cancel a running job
karaoke-gen-remote --cancel abc12345
# Delete a job and its files
karaoke-gen-remote --delete abc12345
```
### Full Production Run
```bash
karaoke-gen-remote \
--style_params_json="./karaoke-styles.json" \
--enable_cdg \
--enable_txt \
--brand_prefix=NOMAD \
--enable_youtube_upload \
--youtube_description_file="./youtube-description.txt" \
./song.flac "Artist" "Title"
```
### Environment Variables
| Variable | Description | Default |
|----------|-------------|---------|
| `KARAOKE_GEN_URL` | Backend service URL | Required |
| `KARAOKE_GEN_AUTH_TOKEN` | Admin auth token (for protected endpoints) | Optional |
| `REVIEW_UI_URL` | Lyrics review UI URL | `https://gen.nomadkaraoke.com/lyrics/` |
| `POLL_INTERVAL` | Seconds between status polls | `5` |
**Note:** The `REVIEW_UI_URL` defaults to the hosted lyrics review UI. For local development, set it to `http://localhost:5173` if you're running the frontend dev server.
### Authentication
The backend uses token-based authentication for admin operations (bulk delete, internal worker triggers). For basic job submission and monitoring, authentication is optional.
**For admin access:**
```bash
export KARAOKE_GEN_AUTH_TOKEN="your-admin-token"
```
The token must match one of the tokens configured in the backend's `ADMIN_TOKENS` environment variable.
### Non-Interactive Mode
For automated/CI usage:
```bash
karaoke-gen-remote -y ./song.flac "Artist" "Title"
```
The `-y` flag auto-accepts default corrections and selects clean instrumental.
---
## 🎨 Style Configuration
Create a `styles.json` file to customize the karaoke video appearance:
```json
{
"intro": {
"video_duration": 5,
"background_image": "/path/to/title-background.png",
"font": "/path/to/Font.ttf",
"artist_color": "#ffdf6b",
"title_color": "#ffffff"
},
"karaoke": {
"background_image": "/path/to/karaoke-background.png",
"font_path": "/path/to/Font.ttf"
},
"end": {
"background_image": "/path/to/end-background.png"
},
"cdg": {
"font_path": "/path/to/Font.ttf",
"instrumental_background": "/path/to/cdg-background.png"
}
}
```
When using `karaoke-gen-remote`, all referenced files are automatically uploaded with your job.
---
## 📤 Output Files
A completed job produces:
```
BRAND-1234 - Artist - Title/
├── Artist - Title (Final Karaoke Lossless 4k).mp4 # ProRes 4K
├── Artist - Title (Final Karaoke Lossless 4k).mkv # FLAC audio 4K
├── Artist - Title (Final Karaoke Lossy 4k).mp4 # H.264 4K
├── Artist - Title (Final Karaoke Lossy 720p).mp4 # H.264 720p
├── Artist - Title (Final Karaoke CDG).zip # CDG+MP3 package
├── Artist - Title (Final Karaoke TXT).zip # TXT+MP3 package
├── Artist - Title (Karaoke).cdg # Individual CDG
├── Artist - Title (Karaoke).mp3 # Karaoke audio
├── Artist - Title (Karaoke).lrc # LRC lyrics
├── Artist - Title (Karaoke).ass # ASS subtitles
├── Artist - Title (Title).mov # Title screen video
├── Artist - Title (End).mov # End screen video
├── Artist - Title (Instrumental...).flac # Clean instrumental
├── Artist - Title (Instrumental +BV...).flac # With backing vocals
└── stems/ # All audio stems
├── ...Vocals....flac
├── ...Bass....flac
├── ...Drums....flac
└── ...
```
---
## 🏗️ Deploy Your Own Backend
The cloud backend runs on Google Cloud Platform using:
- **Cloud Run**: Serverless API hosting
- **Firestore**: Job state management
- **Cloud Storage**: File uploads and outputs
- **Modal.com**: GPU-accelerated audio separation
- **AudioShake**: Lyrics transcription API
### Prerequisites
- Google Cloud account with billing enabled
- [Pulumi CLI](https://www.pulumi.com/docs/install/)
- Modal.com account (for audio separation)
- AudioShake API key
### Infrastructure Setup
```bash
cd infrastructure
# Install dependencies
pip install -r requirements.txt
# Login to Pulumi
pulumi login
# Create a stack
pulumi stack init prod
# Configure GCP project
pulumi config set gcp:project your-project-id
pulumi config set gcp:region us-central1
# Deploy infrastructure
pulumi up
```
This creates:
- Firestore database
- Cloud Storage bucket
- Artifact Registry
- Service account with IAM roles
- Secret Manager secrets (you add values)
### Add Secret Values
```bash
# AudioShake API key
echo -n "your-audioshake-key" | gcloud secrets versions add audioshake-api-key --data-file=-
# Genius API key
echo -n "your-genius-key" | gcloud secrets versions add genius-api-key --data-file=-
# Modal API URL
echo -n "https://your-modal-url" | gcloud secrets versions add audio-separator-api-url --data-file=-
# YouTube OAuth credentials (JSON)
gcloud secrets versions add youtube-oauth-credentials --data-file=./youtube-creds.json
# Dropbox OAuth credentials (JSON)
gcloud secrets versions add dropbox-oauth-credentials --data-file=./dropbox-creds.json
# Google Drive service account (JSON)
gcloud secrets versions add gdrive-service-account --data-file=./gdrive-sa.json
```
### Deploy Cloud Run
```bash
# Build and deploy
gcloud builds submit --config=cloudbuild.yaml
# Get outputs from Pulumi
SA_EMAIL=$(pulumi stack output service_account_email)
BUCKET_NAME=$(pulumi stack output bucket_name)
# Deploy Cloud Run service
gcloud run deploy karaoke-backend \
--image us-central1-docker.pkg.dev/YOUR-PROJECT/karaoke-repo/karaoke-backend:latest \
--platform managed \
--region us-central1 \
--allow-unauthenticated \
--service-account $SA_EMAIL \
--memory 2Gi \
--cpu 2 \
--timeout 600 \
--set-env-vars="GOOGLE_CLOUD_PROJECT=YOUR-PROJECT,GCS_BUCKET_NAME=$BUCKET_NAME"
```
### Point CLI to Your Backend
```bash
export KARAOKE_GEN_URL="https://your-backend.run.app"
karaoke-gen-remote ./song.flac "Artist" "Title"
```
---
## 🔌 Backend API Reference
The backend exposes a REST API for job management.
### Job Submission
**POST** `/api/jobs/upload`
Submit a new karaoke generation job with audio file and options.
```bash
curl -X POST "https://api.example.com/api/jobs/upload" \
-F "file=@song.flac" \
-F "artist=ABBA" \
-F "title=Waterloo" \
-F "enable_cdg=true" \
-F "enable_txt=true" \
-F "brand_prefix=NOMAD" \
-F "style_params=@styles.json" \
-F "style_karaoke_background=@background.png"
```
### Job Status
**GET** `/api/jobs/{job_id}`
Get job status and details.
```bash
curl "https://api.example.com/api/jobs/abc12345"
```
### List Jobs
**GET** `/api/jobs`
List all jobs with optional status filter.
```bash
curl "https://api.example.com/api/jobs?status=complete&limit=10"
```
### Cancel Job
**POST** `/api/jobs/{job_id}/cancel`
Cancel a running job.
```bash
curl -X POST "https://api.example.com/api/jobs/abc12345/cancel" \
-H "Content-Type: application/json" \
-d '{"reason": "User cancelled"}'
```
### Delete Job
**DELETE** `/api/jobs/{job_id}`
Delete a job and its files.
```bash
curl -X DELETE "https://api.example.com/api/jobs/abc12345?delete_files=true"
```
### Lyrics Review
**GET** `/api/review/{job_id}/correction-data`
Get correction data for lyrics review.
**POST** `/api/review/{job_id}/complete`
Submit corrected lyrics and trigger video rendering.
### Instrumental Selection
**GET** `/api/jobs/{job_id}/instrumental-options`
Get available instrumental options.
**POST** `/api/jobs/{job_id}/select-instrumental`
Submit instrumental selection (clean or with_backing).
```bash
curl -X POST "https://api.example.com/api/jobs/abc12345/select-instrumental" \
-H "Content-Type: application/json" \
-d '{"selection": "clean"}'
```
### Download Files
**GET** `/api/jobs/{job_id}/download-urls`
Get download URLs for all output files.
**GET** `/api/jobs/{job_id}/download/{category}/{file_key}`
Stream download a specific file.
### Health Check
**GET** `/api/health`
Check backend health status.
---
## 🔧 Troubleshooting
### "No suitable files found for processing"
This error occurs during the finalisation step when the `(With Vocals).mkv` file is missing. This file is created during lyrics transcription.
**Most common cause:** No transcription provider configured.
**Quick fix:**
1. Check if transcription providers are configured:
```bash
echo $AUDIOSHAKE_API_TOKEN
echo $RUNPOD_API_KEY
```
2. If both are empty, set up a provider (see [Transcription Provider Setup](#transcription-provider-setup))
3. Or use `--skip-lyrics` for instrumental-only karaoke:
```bash
karaoke-gen --skip-lyrics "Artist" "Title"
```
**Other causes:**
- Invalid API credentials - verify your tokens are correct and active
- API service unavailable - check service status pages
- Network connectivity issues - ensure you can reach the API endpoints
- Transcription timeout - try again or use a different provider
### Transcription Fails Silently
If karaoke-gen runs without errors but produces no synchronized lyrics:
1. **Check logs** - Run with `--log_level debug` for detailed output:
```bash
karaoke-gen --log_level debug "Artist" "Title"
```
2. **Verify environment variables** - Ensure API tokens are exported in your shell:
```bash
# Check if set
printenv | grep -E "(AUDIOSHAKE|RUNPOD|WHISPER)"
# Set in current session
export AUDIOSHAKE_API_TOKEN="your_token"
```
3. **Test API connectivity** - Verify you can reach the transcription service
### "No lyrics found from any source"
This warning means no reference lyrics were fetched from online sources (Genius, Spotify, Musixmatch). The transcription will still work, but auto-correction may be less accurate.
**To fix:**
- Set `GENIUS_API_TOKEN` for Genius lyrics
- Set `SPOTIFY_COOKIE_SP_DC` for Spotify lyrics
- Set `RAPIDAPI_KEY` for Musixmatch lyrics
- Or provide lyrics manually with `--lyrics_file /path/to/lyrics.txt`
### Video Quality Issues
If the output video has quality problems:
- Ensure FFmpeg is properly installed: `ffmpeg -version`
- 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
### Running Tests
```bash
# Run all tests
pytest tests/ backend/tests/ -v
# Run only unit tests
pytest tests/unit/ -v
# Run with coverage
pytest tests/unit/ -v --cov=karaoke_gen --cov-report=term-missing
```
### Project Structure
```
karaoke-gen/
├── karaoke_gen/ # Core CLI package
│ ├── utils/
│ │ ├── gen_cli.py # Local CLI (karaoke-gen)
│ │ └── remote_cli.py # Remote CLI (karaoke-gen-remote)
│ ├── karaoke_finalise/ # Video encoding, packaging, distribution
│ └── style_loader.py # Unified style configuration
├── backend/ # Cloud backend (FastAPI)
│ ├── api/routes/ # API endpoints
│ ├── workers/ # Background processing workers
│ └── services/ # Business logic services
├── infrastructure/ # Pulumi IaC for GCP
├── docs/ # Documentation
└── tests/ # Test suite
```
---
## 📄 License
## License
MIT
---
## 🤝 Contributing
Contributions are welcome! Please see our contributing guidelines.
-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
}
]
}
]
-20
View File
@@ -1,20 +0,0 @@
[run]
source = backend
omit =
backend/tests/*
backend/validate.py
backend/tests/emulator/*
# Workers that require external APIs are tested via integration tests
backend/workers/screens_worker.py
backend/workers/video_worker.py
[report]
exclude_lines =
pragma: no cover
def __repr__
raise NotImplementedError
if __name__ == .__main__.:
pass
show_missing = True
-37
View File
@@ -1,37 +0,0 @@
# Ignore Python cache and virtual environments
__pycache__/
*.py[cod]
*$py.class
*.so
.Python
env/
venv/
ENV/
env.bak/
venv.bak/
# Environment files
.env
.env.local
# IDE
.vscode/
.idea/
*.swp
*.swo
*~
# Temporary files
*.log
temp/
tmp/
# Google Cloud
.gcloud/
*.json
# Testing
.pytest_cache/
.coverage
htmlcov/
-43
View File
@@ -1,43 +0,0 @@
# Fast application image - uses pre-built base with all dependencies
#
# The base image (karaoke-backend-base) contains:
# - Python 3.11, ffmpeg, sox, system deps
# - All pip dependencies from requirements-frozen.txt (NO code)
#
# This Dockerfile adds the actual application code on top.
# Build time: ~1-2 minutes (deps already cached in base)
#
# If the base image doesn't exist yet, build it first:
# gcloud builds submit --config=cloudbuild-base.yaml --project=nomadkaraoke
# Use pre-built base image with all dependencies
# Override with --build-arg BASE_IMAGE=karaoke-backend-base:local for local testing
ARG BASE_IMAGE=us-central1-docker.pkg.dev/nomadkaraoke/karaoke-repo/karaoke-backend-base:latest
FROM ${BASE_IMAGE}
# Set working directory (should already exist from base)
WORKDIR /app
# Copy backend code (this is the only thing that changes frequently)
COPY backend /app/backend
# Copy and reinstall karaoke_gen from local source
# This ensures new modules (like style_loader.py) are included without rebuilding base image
# Note: lyrics_transcriber is vendored in lyrics_transcriber_temp/ and bundled via pyproject.toml
COPY karaoke_gen /app/karaoke_gen
COPY lyrics_transcriber_temp /app/lyrics_transcriber_temp
COPY pyproject.toml README.md LICENSE /app/
RUN pip install --no-cache-dir -e .
# Set environment variables
ENV PYTHONUNBUFFERED=1
ENV PORT=8080
# Expose port
EXPOSE 8080
# Run uvicorn directly
# Note: Transmission daemon removed - torrent downloads now handled by
# dedicated flacfetch VM service (see docs/00-current-plan/TORRENT-SERVICE-PLAN.md)
# Using --loop asyncio (instead of uvloop) to support nest_asyncio for remote flacfetch calls
CMD ["uvicorn", "backend.main:app", "--host", "0.0.0.0", "--port", "8080", "--loop", "asyncio"]
-74
View File
@@ -1,74 +0,0 @@
# Base image with all Python dependencies pre-installed
# This image is rebuilt only when poetry.lock changes
#
# Build with: gcloud builds submit --config=cloudbuild-base.yaml
# Or manually: docker build -f backend/Dockerfile.base -t karaoke-backend-base .
FROM python:3.11-slim
# Install system dependencies required by karaoke-gen
# 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 \
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
# Copy dependency files and source code needed for pip install
COPY pyproject.toml README.md LICENSE /app/
COPY karaoke_gen /app/karaoke_gen
COPY lyrics_transcriber_temp /app/lyrics_transcriber_temp
# Install all Python dependencies (the slow part - cached in base image)
RUN pip install --no-cache-dir --upgrade pip && \
pip install --no-cache-dir -e .
# Download spaCy language model for lyrics transcription
# This must be done at build time, not runtime (Cloud Run network restrictions)
RUN python -m spacy download en_core_web_sm
# Label with build info
ARG BUILD_DATE
ARG BUILD_ID
ARG BASE_CONTENT_HASH
LABEL org.opencontainers.image.created="${BUILD_DATE}"
LABEL org.opencontainers.image.revision="${BUILD_ID}"
LABEL org.opencontainers.image.title="karaoke-backend-base"
LABEL org.opencontainers.image.description="Base image with Python dependencies and system tools for karaoke-backend"
LABEL base.content.hash="${BASE_CONTENT_HASH}"
-242
View File
@@ -1,242 +0,0 @@
# Backend Development Setup
## One-Time Setup
### 1. Create Virtual Environment
```bash
cd /Users/andrew/Projects/karaoke-gen
python3 -m venv backend/venv
```
### 2. Activate Virtual Environment
```bash
source backend/venv/bin/activate
```
### 3. Install Dependencies
**IMPORTANT:** Use Python 3.12 (not 3.13/3.14 - pydantic has compatibility issues)
```bash
# Backend dependencies
pip install -r backend/requirements.txt
# Install karaoke_gen in development mode
pip install -e .
# Install lyrics_transcriber submodule
pip install -e lyrics_transcriber_local/
# Install Google API client (for YouTube upload)
pip install google-api-python-client google-auth-httplib2 google-auth-oauthlib
```
### 4. Add Shell Alias (Optional)
Add to `~/.zshrc`:
```bash
alias backend='cd /Users/andrew/Projects/karaoke-gen && source backend/venv/bin/activate'
```
Then you can just run:
```bash
backend
# Now you're in the project directory with venv activated!
```
---
## Daily Workflow
### Before Making Changes
```bash
# Activate venv
source backend/venv/bin/activate
# Or if you set up the alias:
backend
```
### After Making Changes
```bash
# 1. Run full validation (catches import errors!)
python3 backend/validate.py
# 2. If validation passes, deploy
./scripts/deploy.sh
```
---
## Validation Options
### Full Validation (Recommended - Requires venv)
```bash
source backend/venv/bin/activate
python3 backend/validate.py
```
**Catches:**
- ✅ Syntax errors
- ✅ **Import errors** (like the processing_service issue!)
- ✅ Configuration issues
- ✅ FastAPI app creation problems
- ✅ Missing dependencies
**This would have caught the ModuleNotFoundError!**
### Quick Check (No venv needed)
```bash
./backend/quick-check.sh
```
**Catches:**
- ✅ Syntax errors
- ✅ Missing files
- ✅ Some obvious import issues
**Good for quick checks, but won't catch all import errors**
---
## Example: Complete Development Session
```bash
# 1. Activate environment
backend # or: source backend/venv/bin/activate
# 2. Make your changes
vim backend/api/routes/jobs.py
# 3. Validate (catches import errors!)
python3 backend/validate.py
# ✅ All validations passed!
# 4. Deploy
./scripts/deploy.sh
# 5. Test
export BACKEND_URL="https://karaoke-backend-ipzqd2k4yq-uc.a.run.app"
export AUTH_TOKEN=$(gcloud auth print-identity-token)
curl -H "Authorization: Bearer $AUTH_TOKEN" $BACKEND_URL/api/health
```
---
## What About karaoke_gen Imports?
The backend imports from `karaoke_gen` (the CLI package):
```python
from karaoke_gen.karaoke_gen import KaraokePrep
from karaoke_gen.audio_processor import AudioProcessor
```
**Options:**
### Option 1: Install in development mode (Recommended)
```bash
source backend/venv/bin/activate
pip install -e .
```
This makes `karaoke_gen` available in the venv without copying files.
### Option 2: Use system Python
Your system Python already has `karaoke_gen` installed, so validation will work even if the venv doesn't have it (Python will fall back to system packages).
---
## Running the Backend Locally
```bash
# Activate venv
source backend/venv/bin/activate
# Set required environment variables
export GOOGLE_CLOUD_PROJECT="nomadkaraoke"
export GCS_BUCKET_NAME="karaoke-gen-storage-nomadkaraoke"
# Optional: Point to local credentials
export GOOGLE_APPLICATION_CREDENTIALS="/path/to/service-account-key.json"
# Run the server
cd backend
uvicorn main:app --reload --port 8080
```
Visit: http://localhost:8080/api/health
---
## Troubleshooting
### "No module named 'fastapi'"
**Fix:**
```bash
source backend/venv/bin/activate
pip install -r backend/requirements.txt
```
### "No module named 'karaoke_gen'"
**Fix:**
```bash
source backend/venv/bin/activate
cd /Users/andrew/Projects/karaoke-gen
pip install -e .
```
### Validation passes locally but fails in Cloud Run
**Check:**
1. Is `requirements.txt` up to date?
2. Did you add a new dependency without adding it to `requirements.txt`?
3. Run: `pip freeze | grep <package-name>`
---
## Updating Dependencies
When you add new packages:
```bash
# 1. Install in venv
source backend/venv/bin/activate
pip install new-package
# 2. Update requirements.txt
pip freeze > backend/requirements.txt
# 3. Or manually add just the new package:
echo "new-package==1.2.3" >> backend/requirements.txt
# 4. Validate
python3 backend/validate.py
# 5. Deploy
./scripts/deploy.sh
```
---
## Summary
**Best practice workflow:**
1. **One-time setup:** Create venv and install dependencies
2. **Daily:** Activate venv when working on backend
3. **Before deploy:** Run `python3 backend/validate.py` (catches import errors!)
4. **Deploy:** Use `./scripts/deploy.sh`
**The import error would have been caught if you ran validation in a venv!** ✅
View File
Whitespace-only changes.
View File
Whitespace-only changes.
-457
View File
@@ -1,457 +0,0 @@
"""
FastAPI dependencies for authentication and authorization.
"""
import logging
import secrets
from datetime import datetime, timedelta, UTC
from typing import Optional, Tuple, Callable, Union
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
logger = logging.getLogger(__name__)
def generate_review_token() -> str:
"""Generate a cryptographically secure review token."""
return secrets.token_urlsafe(32)
def get_review_token_expiry(hours: int = 24) -> datetime:
"""Get expiry time for a review token."""
return datetime.now(UTC) + timedelta(hours=hours)
# HTTP Bearer security scheme (Authorization: Bearer <token>)
security = HTTPBearer(auto_error=False)
async def get_token_from_request(
request: Request,
credentials: Optional[HTTPAuthorizationCredentials] = Depends(security),
token: Optional[str] = Query(None, description="Access token (alternative to Bearer header)")
) -> Optional[str]:
"""
Extract access token from request.
Supports three methods (in priority order):
1. X-Admin-Token header: Used by Cloud Tasks (since OIDC overwrites Authorization)
2. Authorization header: Authorization: Bearer <token>
3. Query parameter: ?token=<token> (for download links)
Returns:
Token string or None
"""
# Check X-Admin-Token header first (used by Cloud Tasks)
# Cloud Tasks OIDC token overwrites Authorization header, so we use a custom header
admin_token = request.headers.get("X-Admin-Token")
if admin_token:
return admin_token
# Try Authorization header
if credentials:
return credentials.credentials
# Try query parameter
if token:
return token
return None
async def require_auth(
request: Request,
auth_service: AuthService = Depends(get_auth_service),
credentials: Optional[HTTPAuthorizationCredentials] = Depends(security),
token: Optional[str] = Query(None)
) -> AuthResult:
"""
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
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
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),
}
)
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}"
)
return token_str, user_type, remaining_uses
async def require_admin(
auth_result: AuthResult = Depends(require_auth)
) -> AuthResult:
"""
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
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'})"
)
raise HTTPException(
status_code=403,
detail="Admin access required"
)
return auth_result
def optional_auth(
auth_service: AuthService = Depends(get_auth_service),
credentials: Optional[HTTPAuthorizationCredentials] = Depends(security),
token: Optional[str] = Query(None)
) -> Optional[Tuple[str, UserType, int]]:
"""
Optional authentication - doesn't fail if no token provided.
Useful for endpoints that have different behavior for authenticated users.
Returns:
(token, user_type, remaining_uses) if authenticated, None otherwise
"""
# Get token
token_str = None
if credentials:
token_str = credentials.credentials
elif token:
token_str = token
if not token_str:
return None
# Validate token
is_valid, user_type, remaining_uses, message = auth_service.validate_token(token_str)
if not is_valid:
logger.debug(f"Optional auth failed: {message}")
return None
return token_str, user_type, remaining_uses
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
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
"""
async def require_review_auth(
request: Request,
job_id: str = Path(...),
review_token: Optional[str] = Query(None, description="Job-specific review token"),
auth_service: AuthService = Depends(get_auth_service),
credentials: Optional[HTTPAuthorizationCredentials] = Depends(security),
token: Optional[str] = Query(None, alias="token", description="Full access token")
) -> 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}")
return job_id, "full"
# Try review token
if review_token:
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
if job.review_token_expires_at:
now = datetime.now(UTC)
# Handle timezone-naive datetimes from Firestore
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
# Default instance for most review endpoints
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
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
"""
async def require_instrumental_auth(
request: Request,
job_id: str = Path(...),
instrumental_token: Optional[str] = Query(None, description="Job-specific instrumental review token"),
auth_service: AuthService = Depends(get_auth_service),
credentials: Optional[HTTPAuthorizationCredentials] = Depends(security),
token: Optional[str] = Query(None, alias="token", description="Full access token")
) -> 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}")
return job_id, "full"
# Try instrumental token
if instrumental_token:
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
if job.instrumental_token_expires_at:
now = datetime.now(UTC)
# Handle timezone-naive datetimes from Firestore
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
# Default instance for most instrumental review endpoints
require_instrumental_auth = require_instrumental_auth_factory()
View File
Whitespace-only changes.
-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
-884
View File
@@ -1,884 +0,0 @@
"""
Audio search API routes for artist+title search mode.
This module provides endpoints for:
1. Creating a job with audio search (artist+title without file)
2. Getting search results for a job
3. Selecting an audio source to download
The flow is:
1. POST /api/audio-search/search - Create job and search for audio
2. GET /api/audio-search/{job_id}/results - Get search results
3. POST /api/audio-search/{job_id}/select - Select audio source
"""
import asyncio
import logging
import os
import tempfile
from typing import Optional, List, Dict, Any, Tuple
from fastapi import APIRouter, HTTPException, BackgroundTasks, Request, Depends
from pydantic import BaseModel, Field
from backend.models.job import JobCreate, JobStatus
from backend.services.job_manager import JobManager
from backend.services.storage_service import StorageService
from backend.services.worker_service import get_worker_service
from backend.services.credential_manager import get_credential_manager, CredentialStatus
from backend.services.audio_search_service import (
get_audio_search_service,
AudioSearchResult,
AudioSearchError,
NoResultsError,
DownloadError,
)
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 pathlib import Path
logger = logging.getLogger(__name__)
# Valid style file types (from file_upload.py)
STYLE_FILE_TYPES = {
'style_params': {'.json'},
'style_intro_background': {'.jpg', '.jpeg', '.png'},
'style_karaoke_background': {'.jpg', '.jpeg', '.png'},
'style_end_background': {'.jpg', '.jpeg', '.png'},
'style_font': {'.ttf', '.otf'},
'style_cdg_instrumental_background': {'.jpg', '.jpeg', '.png'},
'style_cdg_title_background': {'.jpg', '.jpeg', '.png'},
'style_cdg_outro_background': {'.jpg', '.jpeg', '.png'},
}
router = APIRouter(tags=["audio-search"])
# Initialize services
job_manager = JobManager()
storage_service = StorageService()
worker_service = get_worker_service()
# ============================================================================
# Pydantic models
# ============================================================================
class StyleFileRequest(BaseModel):
"""Information about a style file to be uploaded."""
filename: str = Field(..., description="Original filename with extension")
content_type: str = Field(..., description="MIME type of the file")
file_type: str = Field(..., description="Type of file: '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'")
class StyleUploadUrl(BaseModel):
"""Signed URL for uploading a style file."""
file_type: str = Field(..., description="Type of file being uploaded")
gcs_path: str = Field(..., description="Destination path in GCS")
upload_url: str = Field(..., description="Signed URL to PUT the file to")
class AudioSearchRequest(BaseModel):
"""Request to search for audio by artist and title."""
artist: str = Field(..., description="Artist name to search for")
title: str = Field(..., description="Song title to search for")
# 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")
# Finalisation options
brand_prefix: Optional[str] = Field(None, description="Brand code prefix (e.g., NOMAD)")
enable_youtube_upload: bool = Field(False, description="Upload to YouTube")
youtube_description: Optional[str] = Field(None, description="YouTube video description text")
discord_webhook_url: Optional[str] = Field(None, description="Discord webhook URL for notifications")
# Distribution options
dropbox_path: Optional[str] = Field(None, description="Dropbox folder path for organized output")
gdrive_folder_id: Optional[str] = Field(None, description="Google Drive folder ID for public share uploads")
# Lyrics configuration
lyrics_artist: Optional[str] = Field(None, description="Override artist name for lyrics search")
lyrics_title: Optional[str] = Field(None, description="Override title for lyrics search")
subtitle_offset_ms: int = Field(0, description="Subtitle timing offset in milliseconds")
# Audio separation model configuration
clean_instrumental_model: Optional[str] = Field(None, description="Model for clean instrumental separation")
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")
# Style file uploads (optional)
# 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.
Contains all fields needed for rich display using flacfetch's
shared formatting functions.
"""
index: int
title: str
artist: str
provider: str # Maps to source_name in Release
url: Optional[str] = None # Maps to download_url in Release (may be None for remote)
duration: Optional[int] = None # Maps to duration_seconds in Release
quality: Optional[str] = None # Stringified quality
source_id: Optional[str] = None # Maps to info_hash in Release
seeders: Optional[int] = None
target_file: Optional[str] = None
# Additional fields for rich display (from Release.to_dict())
year: Optional[int] = None
label: Optional[str] = None
edition_info: Optional[str] = None
release_type: Optional[str] = None
channel: Optional[str] = None # For YouTube
view_count: Optional[int] = None # For YouTube
size_bytes: Optional[int] = None
target_file_size: Optional[int] = None
track_pattern: Optional[str] = None
match_score: Optional[float] = None
# Pre-computed display fields
formatted_size: Optional[str] = None
formatted_duration: Optional[str] = None
formatted_views: Optional[str] = None
is_lossless: Optional[bool] = None
quality_str: Optional[str] = None
# Full quality object for Release.from_dict()
quality_data: Optional[Dict[str, Any]] = None
class AudioSearchResponse(BaseModel):
"""Response from audio search."""
status: str
job_id: str
message: str
results: Optional[List[AudioSearchResultResponse]] = None
results_count: int = 0
auto_download: bool = False
server_version: str
# Style file upload URLs (when style_files are specified in request)
style_upload_urls: Optional[List[StyleUploadUrl]] = None
class AudioSelectRequest(BaseModel):
"""Request to select an audio source."""
selection_index: int = Field(..., description="Index of the selected audio source from search results")
class AudioSelectResponse(BaseModel):
"""Response from audio source selection."""
status: str
job_id: str
message: str
selected_index: int
selected_title: str
selected_artist: str
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)
client_ip = headers.get('x-forwarded-for', '').split(',')[0].strip()
if not client_ip and request.client:
client_ip = request.client.host
user_agent = headers.get('user-agent', '')
environment = headers.get('x-environment', '')
client_id = headers.get('x-client-id', '')
custom_headers = {}
for key, value in headers.items():
if key.lower().startswith('x-') and key.lower() not in ('x-forwarded-for', 'x-forwarded-proto', 'x-forwarded-host'):
custom_headers[key] = value
return {
'client_ip': client_ip,
'user_agent': user_agent,
'environment': environment,
'client_id': client_id,
'server_version': VERSION,
'created_from': created_from,
'custom_headers': custom_headers,
}
async def _trigger_workers_parallel(job_id: str) -> None:
"""Trigger both audio and lyrics workers in parallel."""
await asyncio.gather(
worker_service.trigger_audio_worker(job_id),
worker_service.trigger_lyrics_worker(job_id)
)
async def _download_and_start_processing(
job_id: str,
selection_index: int,
audio_search_service,
background_tasks: BackgroundTasks,
) -> Dict[str, Any]:
"""
Download selected audio and start job processing.
This is called either:
- Immediately after search if auto_download=True
- When user calls the select endpoint
For remote flacfetch downloads (torrent sources), the file is downloaded
on the flacfetch VM and uploaded directly to GCS. For local downloads
(YouTube), the file is downloaded locally and then uploaded to GCS.
"""
job = job_manager.get_job(job_id)
if not job:
raise HTTPException(status_code=404, detail=f"Job {job_id} not found")
# Get search results from state_data
search_results = job.state_data.get('audio_search_results', [])
if not search_results:
raise HTTPException(status_code=400, detail="No search results available")
if selection_index < 0 or selection_index >= len(search_results):
raise HTTPException(
status_code=400,
detail=f"Invalid selection index {selection_index}. Valid range: 0-{len(search_results)-1}"
)
selected = search_results[selection_index]
# Get remote_search_id from state_data (stored during initial search)
remote_search_id = job.state_data.get('remote_search_id')
# Transition to downloading state
job_manager.transition_to_state(
job_id=job_id,
new_status=JobStatus.DOWNLOADING_AUDIO,
progress=10,
message=f"Downloading from {selected['provider']}: {selected['artist']} - {selected['title']}",
state_data_updates={
'selected_audio_index': selection_index,
'selected_audio_provider': selected['provider'],
}
)
try:
# Determine if this is a remote torrent download
is_torrent_source = selected.get('provider') in ['RED', 'OPS']
is_remote_enabled = audio_search_service.is_remote_enabled()
# Check if we can use download_by_id (preferred - avoids re-searching)
source_id = selected.get('source_id')
source_name = selected.get('provider')
target_file = selected.get('target_file')
download_url = selected.get('url')
# For remote torrent downloads, have flacfetch VM upload directly to GCS
if is_torrent_source and is_remote_enabled:
# Generate GCS path for remote upload
gcs_destination = f"uploads/{job_id}/audio/"
# Use download_by_id if we have source_id (preferred - no re-search needed)
if source_id and source_name:
logger.info(f"Using download_by_id for {source_name} ID={source_id} with GCS upload to: {gcs_destination}")
result = audio_search_service.download_by_id(
source_name=source_name,
source_id=source_id,
output_dir="", # Not used for remote
target_file=target_file,
download_url=download_url,
gcs_path=gcs_destination,
)
else:
# Fallback to search-based download (requires re-search)
logger.info(f"No source_id available, falling back to search-based download to: {gcs_destination}")
result = audio_search_service.download(
result_index=selection_index,
output_dir="", # Not used for remote
gcs_path=gcs_destination,
remote_search_id=remote_search_id,
)
# For remote downloads, filepath is already the GCS path
if result.filepath.startswith("gs://"):
# Extract the path portion after the bucket name
# Format: gs://bucket/uploads/job_id/audio/filename.flac
parts = result.filepath.replace("gs://", "").split("/", 1)
if len(parts) == 2:
audio_gcs_path = parts[1]
else:
audio_gcs_path = result.filepath
filename = os.path.basename(result.filepath)
else:
# Fallback: treat as local path (shouldn't happen for remote)
filename = os.path.basename(result.filepath)
audio_gcs_path = f"uploads/{job_id}/audio/{filename}"
logger.warning(f"Remote download returned local path: {result.filepath}, uploading manually")
with open(result.filepath, 'rb') as f:
storage_service.upload_fileobj(f, audio_gcs_path, content_type='audio/flac')
logger.info(f"Remote download complete, GCS path: {audio_gcs_path}")
else:
# Local download (YouTube or fallback)
temp_dir = tempfile.mkdtemp(prefix=f"audio_download_{job_id}_")
# Use download_by_id if we have source_id and remote is enabled
if source_id and source_name and is_remote_enabled:
logger.info(f"Using download_by_id for local download: {source_name} ID={source_id}")
result = audio_search_service.download_by_id(
source_name=source_name,
source_id=source_id,
output_dir=temp_dir,
target_file=target_file,
download_url=download_url,
)
elif source_name == 'YouTube' and download_url:
# 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")
result = audio_search_service.download(
result_index=selection_index,
output_dir=temp_dir,
remote_search_id=remote_search_id, # Pass for potential fallback scenarios
)
# Upload to GCS
filename = os.path.basename(result.filepath)
audio_gcs_path = f"uploads/{job_id}/audio/{filename}"
with open(result.filepath, 'rb') as f:
storage_service.upload_fileobj(
f,
audio_gcs_path,
content_type='audio/flac' # flacfetch typically returns FLAC
)
logger.info(f"Uploaded audio to GCS: {audio_gcs_path}")
# Clean up temp file
try:
os.remove(result.filepath)
os.rmdir(temp_dir)
except Exception as e:
logger.warning(f"Failed to clean up temp files: {e}")
# Update job with GCS path and transition to DOWNLOADING
job_manager.update_job(job_id, {
'input_media_gcs_path': audio_gcs_path,
'filename': filename,
})
job_manager.transition_to_state(
job_id=job_id,
new_status=JobStatus.DOWNLOADING,
progress=15,
message="Audio downloaded, starting processing"
)
# Trigger workers
background_tasks.add_task(_trigger_workers_parallel, job_id)
return {
'selected_index': selection_index,
'selected_title': selected['title'],
'selected_artist': selected['artist'],
'selected_provider': selected['provider'],
}
except DownloadError as e:
job_manager.fail_job(job_id, f"Audio download failed: {e}")
raise HTTPException(status_code=500, detail=f"Download failed: {e}")
except Exception as e:
job_manager.fail_job(job_id, f"Audio download failed: {e}")
raise HTTPException(status_code=500, detail=f"Download failed: {e}")
@router.post("/audio-search/search", response_model=AudioSearchResponse)
async def search_audio(
request: Request,
background_tasks: BackgroundTasks,
body: AudioSearchRequest,
auth_result: AuthResult = Depends(require_auth)
):
"""
Search for audio by artist and title, creating a new job.
This endpoint:
1. Creates a job in PENDING state
2. Searches for audio using flacfetch
3. Either returns search results for user selection, or
4. If auto_download=True, automatically selects best and starts processing
Use cases:
- Interactive mode (default): Returns results, user calls /select endpoint
- Auto mode (auto_download=True): Automatically selects and downloads best
"""
try:
# Apply default distribution settings
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
# Apply defaults for YouTube/Dropbox distribution (for web service)
effective_enable_youtube_upload = body.enable_youtube_upload or settings.default_enable_youtube_upload
effective_brand_prefix = body.brand_prefix or settings.default_brand_prefix
effective_youtube_description = body.youtube_description or settings.default_youtube_description
# Validate credentials if distribution services are requested
invalid_services = []
credential_manager = get_credential_manager()
if effective_enable_youtube_upload:
result = credential_manager.check_youtube_credentials()
if result.status != CredentialStatus.VALID:
invalid_services.append(f"youtube ({result.message})")
if effective_dropbox_path:
result = credential_manager.check_dropbox_credentials()
if result.status != CredentialStatus.VALID:
invalid_services.append(f"dropbox ({result.message})")
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,
detail={
"error": "credentials_invalid",
"message": f"Distribution services need re-authorization: {', '.join(invalid_services)}",
"invalid_services": invalid_services,
}
)
# 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,
brand_prefix=effective_brand_prefix,
enable_youtube_upload=effective_enable_youtube_upload,
youtube_description=effective_youtube_description,
youtube_description_template=effective_youtube_description, # video_worker reads this field
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,
clean_instrumental_model=body.clean_instrumental_model,
backing_vocals_models=body.backing_vocals_models,
other_stems_models=body.other_stems_models,
audio_search_artist=body.artist,
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
job_manager.update_job(job_id, {
'audio_search_artist': body.artist,
'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 = {}
if body.style_files:
logger.info(f"Processing {len(body.style_files)} style file uploads for job {job_id}")
for file_info in body.style_files:
# Validate file type
if file_info.file_type not in STYLE_FILE_TYPES:
raise HTTPException(
status_code=400,
detail=f"Invalid file type '{file_info.file_type}'. Must be one of: {', '.join(STYLE_FILE_TYPES.keys())}"
)
# Validate extension
ext = Path(file_info.filename).suffix.lower()
allowed_exts = STYLE_FILE_TYPES[file_info.file_type]
if ext not in allowed_exts:
raise HTTPException(
status_code=400,
detail=f"Invalid extension '{ext}' for {file_info.file_type}. Allowed: {', '.join(allowed_exts)}"
)
# Generate GCS path
if file_info.file_type == 'style_params':
gcs_path = f"uploads/{job_id}/style/style_params.json"
else:
# style_intro_background -> intro_background, etc.
asset_key = file_info.file_type.replace('style_', '')
gcs_path = f"uploads/{job_id}/style/{asset_key}{ext}"
# Generate signed upload URL
signed_url = storage_service.generate_signed_upload_url(
gcs_path,
content_type=file_info.content_type,
expiration_minutes=60
)
style_upload_urls.append(StyleUploadUrl(
file_type=file_info.file_type,
gcs_path=gcs_path,
upload_url=signed_url
))
# Track the expected asset paths
if file_info.file_type == 'style_params':
style_assets['style_params'] = gcs_path
else:
asset_key = file_info.file_type.replace('style_', '')
style_assets[asset_key] = gcs_path
# Update job with style asset expectations
style_update = {'style_assets': style_assets}
if 'style_params' in style_assets:
style_update['style_params_gcs_path'] = style_assets['style_params']
job_manager.update_job(job_id, style_update)
logger.info(f"Generated {len(style_upload_urls)} style upload URLs for job {job_id}")
# Transition to searching state
job_manager.transition_to_state(
job_id=job_id,
new_status=JobStatus.SEARCHING_AUDIO,
progress=5,
message=f"Searching for: {body.artist} - {body.title}"
)
# Perform search
audio_search_service = get_audio_search_service()
try:
search_results = audio_search_service.search(body.artist, body.title)
except NoResultsError as e:
job_manager.fail_job(job_id, f"No audio sources found for: {body.artist} - {body.title}")
raise HTTPException(
status_code=404,
detail={
"error": "no_results",
"message": str(e),
"job_id": job_id,
}
)
except AudioSearchError as e:
job_manager.fail_job(job_id, f"Audio search failed: {e}")
raise HTTPException(status_code=500, detail=f"Search failed: {e}")
# Store results in job state_data, including remote_search_id if available
results_dicts = [r.to_dict() for r in search_results]
state_data_update = {
'audio_search_results': results_dicts,
'audio_search_count': len(results_dicts),
}
# Store remote_search_id for use during download (important for concurrent requests)
if audio_search_service.last_remote_search_id:
state_data_update['remote_search_id'] = audio_search_service.last_remote_search_id
job_manager.update_job(job_id, {
'state_data': state_data_update
})
# If auto_download, select best and start processing
if body.auto_download:
best_index = audio_search_service.select_best(search_results)
logger.info(f"Auto-download enabled, selecting result {best_index}")
selection_info = await _download_and_start_processing(
job_id=job_id,
selection_index=best_index,
audio_search_service=audio_search_service,
background_tasks=background_tasks,
)
return AudioSearchResponse(
status="success",
job_id=job_id,
message=f"Audio found and download started: {selection_info['selected_artist']} - {selection_info['selected_title']} ({selection_info['selected_provider']})",
results=None, # Don't return results in auto mode
results_count=len(search_results),
auto_download=True,
server_version=VERSION,
style_upload_urls=style_upload_urls if style_upload_urls else None,
)
# Interactive mode: return results for user selection
job_manager.transition_to_state(
job_id=job_id,
new_status=JobStatus.AWAITING_AUDIO_SELECTION,
progress=10,
message=f"Found {len(search_results)} audio sources. Waiting for selection."
)
# Convert to response format with full Release data for rich display
result_responses = []
for r in search_results:
# Get full serialized data from raw_result if available
# raw_result can be either:
# - A dict (from remote flacfetch API)
# - A Release object (from local flacfetch)
raw_dict = {}
if r.raw_result:
if isinstance(r.raw_result, dict):
# Remote flacfetch API returns dicts directly
raw_dict = r.raw_result
else:
# Local flacfetch returns Release objects
try:
raw_dict = r.raw_result.to_dict()
except AttributeError:
pass # Not a Release object
result_responses.append(
AudioSearchResultResponse(
index=r.index,
title=r.title,
artist=r.artist,
provider=r.provider,
url=r.url,
duration=r.duration,
quality=r.quality,
source_id=r.source_id,
seeders=raw_dict.get('seeders') or r.seeders,
target_file=raw_dict.get('target_file') or r.target_file,
# Additional fields for rich display
year=raw_dict.get('year'),
label=raw_dict.get('label'),
edition_info=raw_dict.get('edition_info'),
release_type=raw_dict.get('release_type'),
channel=raw_dict.get('channel'),
view_count=raw_dict.get('view_count'),
size_bytes=raw_dict.get('size_bytes'),
target_file_size=raw_dict.get('target_file_size'),
track_pattern=raw_dict.get('track_pattern'),
match_score=raw_dict.get('match_score'),
# Pre-computed display fields
formatted_size=raw_dict.get('formatted_size'),
formatted_duration=raw_dict.get('formatted_duration'),
formatted_views=raw_dict.get('formatted_views'),
is_lossless=raw_dict.get('is_lossless'),
quality_str=raw_dict.get('quality_str'),
# Full quality object for Release.from_dict()
# Remote API uses 'quality_data', local uses 'quality' for the dict
quality_data=raw_dict.get('quality_data') or raw_dict.get('quality'),
)
)
return AudioSearchResponse(
status="awaiting_selection",
job_id=job_id,
message=f"Found {len(search_results)} audio sources. Call /api/audio-search/{job_id}/select to choose one.",
results=result_responses,
results_count=len(search_results),
auto_download=False,
server_version=VERSION,
style_upload_urls=style_upload_urls if style_upload_urls else None,
)
except HTTPException:
raise
except Exception as e:
logger.error(f"Error in audio search: {e}", exc_info=True)
raise HTTPException(status_code=500, detail=str(e))
@router.get("/audio-search/{job_id}/results")
async def get_audio_search_results(
job_id: str,
auth_result: AuthResult = Depends(require_auth)
):
"""
Get audio search results for a job.
Returns the cached search results so user can select one.
"""
job = job_manager.get_job(job_id)
if not job:
raise HTTPException(status_code=404, detail=f"Job {job_id} not found")
search_results = job.state_data.get('audio_search_results', [])
if not search_results:
raise HTTPException(
status_code=400,
detail="No search results available for this job"
)
return {
"status": "success",
"job_id": job_id,
"job_status": job.status,
"artist": job.audio_search_artist or job.artist,
"title": job.audio_search_title or job.title,
"results": search_results,
"results_count": len(search_results),
}
@router.post("/audio-search/{job_id}/select", response_model=AudioSelectResponse)
async def select_audio_source(
job_id: str,
background_tasks: BackgroundTasks,
body: AudioSelectRequest,
auth_result: AuthResult = Depends(require_auth)
):
"""
Select an audio source and start job processing.
This endpoint:
1. Validates the job is awaiting selection
2. Downloads the selected audio
3. Uploads to GCS
4. Triggers audio and lyrics workers
"""
job = job_manager.get_job(job_id)
if not job:
raise HTTPException(status_code=404, detail=f"Job {job_id} not found")
# Verify job is awaiting selection
if job.status != JobStatus.AWAITING_AUDIO_SELECTION:
raise HTTPException(
status_code=400,
detail=f"Job is not awaiting audio selection (status: {job.status})"
)
# Get search service instance
# Note: With download_by_id, we no longer need to re-search to populate the cache.
# The source_id stored in job.state_data['audio_search_results'] is sufficient.
audio_search_service = get_audio_search_service()
# Validate search results exist in job state_data
search_results = job.state_data.get('audio_search_results', [])
if not search_results:
raise HTTPException(status_code=400, detail="No search results cached for this job")
selection_info = await _download_and_start_processing(
job_id=job_id,
selection_index=body.selection_index,
audio_search_service=audio_search_service,
background_tasks=background_tasks,
)
return AudioSelectResponse(
status="success",
job_id=job_id,
message="Audio selected and download started",
selected_index=selection_info['selected_index'],
selected_title=selection_info['selected_title'],
selected_artist=selection_info['selected_artist'],
selected_provider=selection_info['selected_provider'],
)
-348
View File
@@ -1,348 +0,0 @@
"""
OAuth credential management API routes.
Provides endpoints for:
1. Checking credential status
2. Device authorization flow for re-authentication
3. Credential validation before job submission
"""
import logging
from typing import Optional
from datetime import datetime
from fastapi import APIRouter, HTTPException, BackgroundTasks
from pydantic import BaseModel
from backend.services.credential_manager import (
get_credential_manager,
CredentialStatus,
CredentialCheckResult,
)
from backend.config import get_settings
logger = logging.getLogger(__name__)
router = APIRouter(prefix="/auth", tags=["auth"])
# ===========================================================================
# Request/Response Models
# ===========================================================================
class CredentialStatusResponse(BaseModel):
"""Response model for credential status."""
service: str
status: str
message: str
last_checked: datetime
expires_at: Optional[datetime] = None
class Config:
from_attributes = True
class AllCredentialsStatusResponse(BaseModel):
"""Response model for all credentials status."""
youtube: CredentialStatusResponse
gdrive: CredentialStatusResponse
dropbox: CredentialStatusResponse
all_valid: bool
services_needing_auth: list[str]
class DeviceAuthStartRequest(BaseModel):
"""Request to start device authorization flow."""
client_id: Optional[str] = None # Optional - reads from Secret Manager if not provided
client_secret: Optional[str] = None # Optional - reads from Secret Manager if not provided
class DeviceAuthStartResponse(BaseModel):
"""Response with device authorization info."""
device_code: str
user_code: str
verification_url: str
expires_in: int
interval: int
instructions: str
class DeviceAuthPollResponse(BaseModel):
"""Response from polling device authorization."""
status: str # "pending", "complete", "expired", "error"
message: Optional[str] = None
credentials_saved: bool = False
class CredentialValidationRequest(BaseModel):
"""Request to validate credentials for specific services."""
youtube: bool = False
gdrive: bool = False
dropbox: bool = False
class CredentialValidationResponse(BaseModel):
"""Response from credential validation."""
valid: bool
invalid_services: list[str]
message: str
# ===========================================================================
# Endpoints
# ===========================================================================
@router.get("/status", response_model=AllCredentialsStatusResponse)
async def get_credentials_status():
"""
Get the status of all OAuth credentials.
Returns the validation status for YouTube, Google Drive, and Dropbox
credentials, including whether they are valid, expired, or need
re-authorization.
"""
manager = get_credential_manager()
results = manager.check_all_credentials()
def to_response(result: CredentialCheckResult) -> CredentialStatusResponse:
return CredentialStatusResponse(
service=result.service,
status=result.status.value,
message=result.message,
last_checked=result.last_checked,
expires_at=result.expires_at
)
services_needing_auth = [
name for name, result in results.items()
if result.status in (CredentialStatus.INVALID, CredentialStatus.EXPIRED, CredentialStatus.NOT_CONFIGURED)
]
return AllCredentialsStatusResponse(
youtube=to_response(results["youtube"]),
gdrive=to_response(results["gdrive"]),
dropbox=to_response(results["dropbox"]),
all_valid=len(services_needing_auth) == 0,
services_needing_auth=services_needing_auth
)
@router.get("/status/{service}", response_model=CredentialStatusResponse)
async def get_service_credential_status(service: str):
"""
Get the status of a specific service's OAuth credentials.
Args:
service: One of "youtube", "gdrive", "dropbox"
"""
manager = get_credential_manager()
if service == "youtube":
result = manager.check_youtube_credentials()
elif service == "gdrive":
result = manager.check_gdrive_credentials()
elif service == "dropbox":
result = manager.check_dropbox_credentials()
else:
raise HTTPException(status_code=400, detail=f"Unknown service: {service}")
return CredentialStatusResponse(
service=result.service,
status=result.status.value,
message=result.message,
last_checked=result.last_checked,
expires_at=result.expires_at
)
@router.post("/validate", response_model=CredentialValidationResponse)
async def validate_credentials(request: CredentialValidationRequest):
"""
Validate that credentials are available for requested services.
Use this before submitting a job to ensure all required
credentials are valid.
"""
manager = get_credential_manager()
invalid_services = []
if request.youtube:
result = manager.check_youtube_credentials()
if result.status != CredentialStatus.VALID:
invalid_services.append("youtube")
if request.gdrive:
result = manager.check_gdrive_credentials()
if result.status != CredentialStatus.VALID:
invalid_services.append("gdrive")
if request.dropbox:
result = manager.check_dropbox_credentials()
if result.status != CredentialStatus.VALID:
invalid_services.append("dropbox")
if invalid_services:
return CredentialValidationResponse(
valid=False,
invalid_services=invalid_services,
message=f"The following services need re-authorization: {', '.join(invalid_services)}"
)
return CredentialValidationResponse(
valid=True,
invalid_services=[],
message="All requested credentials are valid"
)
# ===========================================================================
# Device Authorization Flow Endpoints
# ===========================================================================
@router.post("/youtube/device", response_model=DeviceAuthStartResponse)
async def start_youtube_device_auth(request: Optional[DeviceAuthStartRequest] = None):
"""
Start YouTube device authorization flow.
This initiates a device auth flow that allows authorization
from any device. The user must visit the verification URL
and enter the user code.
Client credentials are loaded from Secret Manager ('youtube-client-credentials')
unless explicitly provided in the request body.
After starting, poll /auth/youtube/device/{device_code} to
check for completion.
"""
manager = get_credential_manager()
try:
device_info = manager.start_youtube_device_auth(
client_id=request.client_id if request else None,
client_secret=request.client_secret if request else None
)
return DeviceAuthStartResponse(
device_code=device_info.device_code,
user_code=device_info.user_code,
verification_url=device_info.verification_url,
expires_in=device_info.expires_in,
interval=device_info.interval,
instructions=f"Visit {device_info.verification_url} and enter code: {device_info.user_code}"
)
except Exception as e:
logger.error(f"Failed to start YouTube device auth: {e}")
raise HTTPException(status_code=500, detail=str(e))
@router.get("/youtube/device/{device_code}", response_model=DeviceAuthPollResponse)
async def poll_youtube_device_auth(device_code: str):
"""
Poll for YouTube device authorization completion.
Call this endpoint at the interval specified in the device auth
start response. Keep polling while status is "pending".
Status values:
- pending: User has not yet authorized
- complete: Authorization successful, credentials saved
- expired: Device code expired, start new flow
- error: An error occurred
"""
manager = get_credential_manager()
status, data = manager.poll_device_auth("youtube", device_code)
return DeviceAuthPollResponse(
status=status,
message=data.get("message") if data else None,
credentials_saved=(status == "complete")
)
@router.post("/gdrive/device", response_model=DeviceAuthStartResponse)
async def start_gdrive_device_auth(request: Optional[DeviceAuthStartRequest] = None):
"""
Start Google Drive device authorization flow.
Client credentials are loaded from Secret Manager ('gdrive-client-credentials')
unless explicitly provided in the request body.
After starting, poll /auth/gdrive/device/{device_code} to check for completion.
"""
manager = get_credential_manager()
try:
device_info = manager.start_gdrive_device_auth(
client_id=request.client_id if request else None,
client_secret=request.client_secret if request else None
)
return DeviceAuthStartResponse(
device_code=device_info.device_code,
user_code=device_info.user_code,
verification_url=device_info.verification_url,
expires_in=device_info.expires_in,
interval=device_info.interval,
instructions=f"Visit {device_info.verification_url} and enter code: {device_info.user_code}"
)
except Exception as e:
logger.error(f"Failed to start Google Drive device auth: {e}")
raise HTTPException(status_code=500, detail=str(e))
@router.get("/gdrive/device/{device_code}", response_model=DeviceAuthPollResponse)
async def poll_gdrive_device_auth(device_code: str):
"""
Poll for Google Drive device authorization completion.
"""
manager = get_credential_manager()
status, data = manager.poll_device_auth("gdrive", device_code)
return DeviceAuthPollResponse(
status=status,
message=data.get("message") if data else None,
credentials_saved=(status == "complete")
)
# ===========================================================================
# Alert Testing
# ===========================================================================
@router.post("/test-alert")
async def test_credential_alert(background_tasks: BackgroundTasks):
"""
Test the credential alert mechanism.
Sends a test alert to Discord if configured.
"""
settings = get_settings()
discord_url = settings.get_secret("discord-alert-webhook")
if not discord_url:
raise HTTPException(
status_code=400,
detail="Discord alert webhook not configured"
)
manager = get_credential_manager()
# Create a fake invalid result for testing
from backend.services.credential_manager import CredentialCheckResult
test_results = [
CredentialCheckResult(
service="test",
status=CredentialStatus.INVALID,
message="This is a test alert",
last_checked=datetime.utcnow()
)
]
background_tasks.add_task(
manager.send_credential_alert,
test_results,
discord_url
)
return {"message": "Test alert queued"}
File diff suppressed because it is too large. Load diff
-310
View File
@@ -1,310 +0,0 @@
"""
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:
import transmission_rpc
host = os.environ.get("TRANSMISSION_HOST", "localhost")
port = int(os.environ.get("TRANSMISSION_PORT", "9091"))
client = transmission_rpc.Client(host=host, port=port, timeout=5)
stats = client.session_stats()
# Get detailed torrent info
torrents = client.get_torrents()
torrent_details = []
for t in torrents:
torrent_info = {
"name": t.name,
"progress": round(t.progress, 1),
"status": str(t.status),
"peers": t.peers_connected if hasattr(t, 'peers_connected') else 0,
"download_speed": round(t.rate_download / 1024, 1) if hasattr(t, 'rate_download') else 0, # KB/s
}
# Check if stalled (downloading but no progress and no peers)
if t.status.downloading and t.progress < 100 and torrent_info['peers'] == 0:
torrent_info['stalled'] = True
torrent_details.append(torrent_info)
return {
"available": True,
"host": host,
"port": port,
"download_dir": stats.download_dir if hasattr(stats, 'download_dir') else None,
"active_torrent_count": stats.active_torrent_count if hasattr(stats, 'active_torrent_count') else 0,
"torrents": torrent_details,
}
except ImportError as e:
return {
"available": False,
"error": f"transmission_rpc not installed: {e}",
}
except Exception as e:
return {
"available": False,
"host": os.environ.get("TRANSMISSION_HOST", "localhost"),
"port": int(os.environ.get("TRANSMISSION_PORT", "9091")),
"error": str(e),
}
@router.get("/health")
async def health_check() -> Dict[str, str]:
"""Health check endpoint."""
return {
"status": "healthy",
"service": "karaoke-gen-backend"
}
async def check_flacfetch_service_status() -> Dict[str, Any]:
"""Check if remote flacfetch service is available and healthy."""
client = get_flacfetch_client()
if not client:
return {
"configured": False,
"message": "Remote flacfetch service not configured (FLACFETCH_API_URL not set)",
}
try:
health = await client.health_check()
return {
"configured": True,
"available": True,
"status": health.get("status"),
"version": health.get("version"),
"transmission": health.get("transmission", {}),
"disk": health.get("disk", {}),
"providers": health.get("providers", {}),
}
except Exception as e:
return {
"configured": True,
"available": False,
"error": str(e),
}
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,
}
}
@router.get("/readiness")
async def readiness_check() -> Dict[str, str]:
"""Readiness check endpoint for Cloud Run."""
return {
"status": "ready",
"service": "karaoke-gen-backend"
}
-330
View File
@@ -1,330 +0,0 @@
"""
Internal API routes for worker coordination.
These endpoints are for internal use only (backend → workers).
They are protected by admin authentication.
With Cloud Tasks integration, these endpoints may be called multiple times
(retry on failure). Idempotency checks prevent duplicate processing.
Observability:
- Extracts trace context from incoming requests (propagated via Cloud Tasks)
- Creates worker spans linked to the original request trace
- All logs include job_id for easy filtering in Cloud Logging
"""
import logging
import asyncio
import time
from typing import Tuple, Optional
from fastapi import APIRouter, HTTPException, BackgroundTasks, Depends, Request
from pydantic import BaseModel
from backend.workers.audio_worker import process_audio_separation
from backend.workers.lyrics_worker import process_lyrics_transcription
from backend.workers.screens_worker import generate_screens
from backend.workers.video_worker import generate_video
from backend.workers.render_video_worker import process_render_video
from backend.api.dependencies import require_admin
from backend.services.auth_service import UserType
from backend.services.job_manager import JobManager
from backend.services.tracing import (
extract_trace_context,
start_span_with_context,
add_span_attribute,
add_span_event,
)
logger = logging.getLogger(__name__)
router = APIRouter(prefix="/internal", tags=["internal"])
class WorkerRequest(BaseModel):
"""Request to trigger a worker."""
job_id: str
class WorkerResponse(BaseModel):
"""Response from worker trigger."""
status: str
job_id: str
message: str
def _check_worker_idempotency(job_id: str, worker_name: str) -> Optional[WorkerResponse]:
"""
Check if a worker is already running or completed for this job.
This provides idempotency for Cloud Tasks retries - if a task is retried
but the worker is already running or has completed, we skip processing.
Args:
job_id: Job ID to check
worker_name: Worker name (audio, lyrics, screens, render, video)
Returns:
WorkerResponse if should skip (already running/complete), None to proceed
"""
job_manager = JobManager()
job = job_manager.get_job(job_id)
if not job:
logger.warning(f"[job:{job_id}] Job not found for {worker_name} worker")
return WorkerResponse(
status="not_found",
job_id=job_id,
message=f"Job {job_id} not found"
)
# Check worker-specific progress in state_data
progress_key = f"{worker_name}_progress"
worker_progress = job.state_data.get(progress_key, {})
stage = worker_progress.get('stage')
if stage == 'running':
logger.info(f"[job:{job_id}] {worker_name.capitalize()} worker already running, skipping")
return WorkerResponse(
status="already_running",
job_id=job_id,
message=f"{worker_name.capitalize()} worker already in progress"
)
if stage == 'complete':
logger.info(f"[job:{job_id}] {worker_name.capitalize()} worker already complete, skipping")
return WorkerResponse(
status="already_complete",
job_id=job_id,
message=f"{worker_name.capitalize()} worker already completed"
)
# Mark as running before starting (for idempotency on next retry)
job_manager.update_state_data(job_id, progress_key, {'stage': 'running'})
return None
@router.post("/workers/audio", response_model=WorkerResponse)
async def trigger_audio_worker(
request: WorkerRequest,
http_request: Request,
background_tasks: BackgroundTasks,
auth_data: Tuple[str, UserType, int] = Depends(require_admin)
):
"""
Trigger audio separation worker for a job.
This endpoint is called internally after job creation to start
the audio processing track (parallel with lyrics processing).
Idempotency: If worker is already running or complete, returns early.
The worker runs in the background and updates job state as it progresses.
"""
job_id = request.job_id
# Extract trace context from incoming request (propagated via Cloud Tasks)
trace_context = extract_trace_context(dict(http_request.headers))
logger.info(f"[job:{job_id}] WORKER_TRIGGER worker=audio")
add_span_attribute("job_id", job_id)
add_span_attribute("worker", "audio")
# Idempotency check
skip_response = _check_worker_idempotency(job_id, "audio")
if skip_response:
add_span_event("worker_skipped", {"reason": skip_response.status})
return skip_response
# Add task to background tasks
# This allows the HTTP response to return immediately
# while the worker continues processing
background_tasks.add_task(process_audio_separation, job_id)
add_span_event("worker_started")
return WorkerResponse(
status="started",
job_id=job_id,
message="Audio separation worker started"
)
@router.post("/workers/lyrics", response_model=WorkerResponse)
async def trigger_lyrics_worker(
request: WorkerRequest,
http_request: Request,
background_tasks: BackgroundTasks,
auth_data: Tuple[str, UserType, int] = Depends(require_admin)
):
"""
Trigger lyrics transcription worker for a job.
This endpoint is called internally after job creation to start
the lyrics processing track (parallel with audio processing).
Idempotency: If worker is already running or complete, returns early.
The worker runs in the background and updates job state as it progresses.
"""
job_id = request.job_id
# Extract trace context from incoming request
trace_context = extract_trace_context(dict(http_request.headers))
logger.info(f"[job:{job_id}] WORKER_TRIGGER worker=lyrics")
add_span_attribute("job_id", job_id)
add_span_attribute("worker", "lyrics")
# Idempotency check
skip_response = _check_worker_idempotency(job_id, "lyrics")
if skip_response:
add_span_event("worker_skipped", {"reason": skip_response.status})
return skip_response
# Add task to background tasks
background_tasks.add_task(process_lyrics_transcription, job_id)
add_span_event("worker_started")
return WorkerResponse(
status="started",
job_id=job_id,
message="Lyrics transcription worker started"
)
@router.post("/workers/screens", response_model=WorkerResponse)
async def trigger_screens_worker(
request: WorkerRequest,
http_request: Request,
background_tasks: BackgroundTasks,
auth_data: Tuple[str, UserType, int] = Depends(require_admin)
):
"""
Trigger title/end screen generation worker.
This is called automatically when both audio and lyrics are complete.
Idempotency: If worker is already running or complete, returns early.
"""
job_id = request.job_id
# Extract trace context from incoming request
trace_context = extract_trace_context(dict(http_request.headers))
logger.info(f"[job:{job_id}] WORKER_TRIGGER worker=screens")
add_span_attribute("job_id", job_id)
add_span_attribute("worker", "screens")
# Idempotency check
skip_response = _check_worker_idempotency(job_id, "screens")
if skip_response:
add_span_event("worker_skipped", {"reason": skip_response.status})
return skip_response
# Add task to background tasks
background_tasks.add_task(generate_screens, job_id)
add_span_event("worker_started")
return WorkerResponse(
status="started",
job_id=job_id,
message="Screens generation worker started"
)
@router.post("/workers/video", response_model=WorkerResponse)
async def trigger_video_worker(
request: WorkerRequest,
http_request: Request,
background_tasks: BackgroundTasks,
auth_data: Tuple[str, UserType, int] = Depends(require_admin)
):
"""
Trigger final video generation and encoding worker.
This is called after user selects their preferred instrumental.
This is the longest-running stage (15-20 minutes).
Idempotency: If worker is already running or complete, returns early.
"""
job_id = request.job_id
# Extract trace context from incoming request
trace_context = extract_trace_context(dict(http_request.headers))
logger.info(f"[job:{job_id}] WORKER_TRIGGER worker=video")
add_span_attribute("job_id", job_id)
add_span_attribute("worker", "video")
# Idempotency check
skip_response = _check_worker_idempotency(job_id, "video")
if skip_response:
add_span_event("worker_skipped", {"reason": skip_response.status})
return skip_response
# Add task to background tasks
background_tasks.add_task(generate_video, job_id)
add_span_event("worker_started")
return WorkerResponse(
status="started",
job_id=job_id,
message="Video generation worker started"
)
@router.post("/workers/render-video", response_model=WorkerResponse)
async def trigger_render_video_worker(
request: WorkerRequest,
http_request: Request,
background_tasks: BackgroundTasks,
auth_data: Tuple[str, UserType, int] = Depends(require_admin)
):
"""
Trigger render video worker (post-review).
This is called after human review is complete.
Uses OutputGenerator from LyricsTranscriber to generate the karaoke video
with the corrected lyrics.
Idempotency: If worker is already running or complete, returns early.
Output: with_vocals.mkv in GCS
Next state: AWAITING_INSTRUMENTAL_SELECTION
"""
job_id = request.job_id
# Extract trace context from incoming request
trace_context = extract_trace_context(dict(http_request.headers))
logger.info(f"[job:{job_id}] WORKER_TRIGGER worker=render-video")
add_span_attribute("job_id", job_id)
add_span_attribute("worker", "render-video")
# Idempotency check
skip_response = _check_worker_idempotency(job_id, "render")
if skip_response:
add_span_event("worker_skipped", {"reason": skip_response.status})
return skip_response
# Add task to background tasks
background_tasks.add_task(process_render_video, job_id)
add_span_event("worker_started")
return WorkerResponse(
status="started",
job_id=job_id,
message="Render video worker started (post-review)"
)
@router.get("/health")
async def internal_health(
auth_data: Tuple[str, UserType, int] = Depends(require_admin)
):
"""
Internal health check endpoint.
Used to verify the internal API is responsive.
Requires admin authentication.
"""
return {"status": "healthy", "service": "karaoke-backend-internal"}
File diff suppressed because it is too large. Load diff
-570
View File
@@ -1,570 +0,0 @@
"""
Review API routes - Compatible with LyricsTranscriber frontend.
These endpoints match the API that the LyricsTranscriber review frontend expects,
allowing us to use the existing React review UI with our cloud backend.
Usage:
Frontend URL: http://localhost:5173/?baseApiUrl=http://localhost:8000/api/review/{job_id}
The baseApiUrl includes the job_id, and all endpoints are relative to that.
"""
import asyncio
import logging
import hashlib
import json
import os
import tempfile
from pathlib import Path
from typing import Dict, Any, Set, Tuple
from fastapi import APIRouter, HTTPException, Request, Depends
from fastapi.responses import FileResponse, StreamingResponse
from starlette.background import BackgroundTask
from backend.models.job import JobStatus
from backend.services.job_manager import JobManager
from backend.services.storage_service import StorageService
from backend.services.job_logging import job_log_context, JobLogger
from backend.services.tracing import create_span, add_span_attribute, add_span_event
from backend.api.dependencies import require_auth, require_review_auth
from backend.services.auth_service import UserType
# LyricsTranscriber imports for preview generation
from lyrics_transcriber.types import CorrectionResult
from lyrics_transcriber.core.config import OutputConfig
from lyrics_transcriber.correction.operations import CorrectionOperations
# Import from the unified style loader
from karaoke_gen.style_loader import load_styles_from_gcs
logger = logging.getLogger(__name__)
router = APIRouter(prefix="/review", tags=["review"])
# Store job context for the session
# In production, this would be handled differently (e.g., session tokens)
_job_contexts: Dict[str, Dict[str, Any]] = {}
# Store preview video paths for serving
_preview_videos: Dict[str, Dict[str, str]] = {}
# Keep references to background tasks to prevent garbage collection
_background_tasks: Set[asyncio.Task] = set()
def _get_audio_hash(job_id: str) -> str:
"""Generate a consistent audio hash for a job."""
return hashlib.md5(job_id.encode()).hexdigest()
@router.get("/{job_id}/ping")
async def ping(job_id: str):
"""Health check endpoint expected by frontend."""
return {"status": "ok"}
@router.get("/{job_id}/correction-data")
async def get_correction_data(
job_id: str,
auth_info: Tuple[str, str] = Depends(require_review_auth)
):
"""
Get correction data for the review interface.
Returns the CorrectionResult data that the frontend needs to render
the lyrics review UI.
"""
job_manager = JobManager()
storage = StorageService()
job = job_manager.get_job(job_id)
if not job:
raise HTTPException(status_code=404, detail="Job not found")
if job.status not in [JobStatus.AWAITING_REVIEW, JobStatus.IN_REVIEW]:
raise HTTPException(
status_code=400,
detail=f"Job not ready for review (current status: {job.status})"
)
# Get corrections URL from file_urls
corrections_gcs = job.file_urls.get('lyrics', {}).get('corrections')
if not corrections_gcs:
# Try direct path
corrections_gcs = f"jobs/{job_id}/lyrics/corrections.json"
if not storage.file_exists(corrections_gcs):
raise HTTPException(
status_code=404,
detail="Corrections data not found. Lyrics processing may not be complete."
)
# Download and return corrections data
try:
corrections_data = storage.download_json(corrections_gcs)
# Add audio hash for the frontend
audio_hash = _get_audio_hash(job_id)
if 'metadata' not in corrections_data:
corrections_data['metadata'] = {}
corrections_data['metadata']['audio_hash'] = audio_hash
corrections_data['metadata']['artist'] = job.artist
corrections_data['metadata']['title'] = job.title
# Store context for audio serving
_job_contexts[job_id] = {
'audio_hash': audio_hash,
'audio_gcs_path': job.input_media_gcs_path
}
# Transition to IN_REVIEW if not already
if job.status == JobStatus.AWAITING_REVIEW:
job_manager.transition_to_state(
job_id=job_id,
new_status=JobStatus.IN_REVIEW,
message="User opened review interface"
)
logger.info(f"Job {job_id}: Serving correction data for review")
return corrections_data
except Exception as e:
logger.error(f"Job {job_id}: Error loading corrections: {e}", exc_info=True)
raise HTTPException(status_code=500, detail=f"Error loading corrections: {str(e)}")
@router.get("/{job_id}/audio/{audio_hash}")
async def get_audio_with_hash(
job_id: str,
audio_hash: str,
auth_info: Tuple[str, str] = Depends(require_review_auth)
):
"""Stream the audio file for playback (with hash parameter)."""
return await _stream_audio(job_id)
@router.get("/{job_id}/audio/")
@router.get("/{job_id}/audio")
async def get_audio_no_hash(
job_id: str,
auth_info: Tuple[str, str] = Depends(require_review_auth)
):
"""Stream the audio file for playback (without hash parameter)."""
return await _stream_audio(job_id)
async def _stream_audio(job_id: str):
"""
Stream the audio file for playback in the review interface.
"""
job_manager = JobManager()
storage = StorageService()
job = job_manager.get_job(job_id)
if not job:
raise HTTPException(status_code=404, detail="Job not found")
audio_gcs_path = job.input_media_gcs_path
if not audio_gcs_path:
raise HTTPException(status_code=404, detail="Audio file not found")
# Download to temp file and stream
try:
# Create temp file
with tempfile.NamedTemporaryFile(delete=False, suffix=".flac") as tmp:
tmp_path = tmp.name
storage.download_file(audio_gcs_path, tmp_path)
# Determine content type
if audio_gcs_path.endswith('.flac'):
media_type = "audio/flac"
elif audio_gcs_path.endswith('.wav'):
media_type = "audio/wav"
elif audio_gcs_path.endswith('.mp3'):
media_type = "audio/mpeg"
else:
media_type = "audio/mpeg"
logger.info(f"Job {job_id}: Streaming audio for review")
return FileResponse(
tmp_path,
media_type=media_type,
filename=os.path.basename(audio_gcs_path),
background=BackgroundTask(os.unlink, tmp_path),
)
except Exception as e:
logger.error(f"Job {job_id}: Error streaming audio: {e}", exc_info=True)
raise HTTPException(status_code=500, detail=f"Error streaming audio: {str(e)}")
@router.post("/{job_id}/complete")
async def complete_review(
job_id: str,
updated_data: Dict[str, Any],
auth_info: Tuple[str, str] = Depends(require_review_auth)
):
"""
Complete the review and save corrected lyrics.
This endpoint receives the updated correction data from the frontend
and saves it, then triggers the render video worker.
"""
job_manager = JobManager()
storage = StorageService()
job = job_manager.get_job(job_id)
if not job:
raise HTTPException(status_code=404, detail="Job not found")
if job.status not in [JobStatus.AWAITING_REVIEW, JobStatus.IN_REVIEW]:
raise HTTPException(
status_code=400,
detail=f"Job not in review state (current status: {job.status})"
)
try:
# Save updated corrections to GCS
corrections_gcs_path = f"jobs/{job_id}/lyrics/corrections_updated.json"
storage.upload_json(corrections_gcs_path, updated_data)
job_manager.update_file_url(job_id, 'lyrics', 'corrections_updated', corrections_gcs_path)
logger.info(f"Job {job_id}: Saved updated corrections")
# Transition to REVIEW_COMPLETE
job_manager.transition_to_state(
job_id=job_id,
new_status=JobStatus.REVIEW_COMPLETE,
progress=70,
message="Review complete, rendering video with corrected lyrics"
)
# Trigger render video worker
from backend.services.worker_service import get_worker_service
worker_service = get_worker_service()
# Run in background, keep reference to prevent garbage collection
task = asyncio.create_task(worker_service.trigger_render_video_worker(job_id))
_background_tasks.add(task)
task.add_done_callback(_background_tasks.discard)
logger.info(f"Job {job_id}: Review complete, triggered render video worker")
return {"status": "success"}
except Exception as e:
logger.error(f"Job {job_id}: Error completing review: {e}", exc_info=True)
raise HTTPException(status_code=500, detail=f"Error completing review: {str(e)}")
@router.post("/{job_id}/handlers")
async def update_handlers(
job_id: str,
enabled_handlers: list,
auth_info: Tuple[str, str] = Depends(require_review_auth)
):
"""
Update enabled correction handlers (optional feature).
For now, just acknowledge the request - full handler support
would require re-running correction.
"""
logger.info(f"Job {job_id}: Handler update requested (not implemented)")
return {"status": "success", "message": "Handler updates not yet implemented"}
@router.post("/{job_id}/add-lyrics")
async def add_lyrics(
job_id: str,
data: Dict[str, str],
auth_info: Tuple[str, str] = Depends(require_review_auth)
):
"""
Add custom lyrics source and rerun correction.
Uses the LyricsTranscriber's CorrectionOperations to add a new lyrics source
and regenerate corrections with the new source included.
"""
job_manager = JobManager()
storage = StorageService()
job = job_manager.get_job(job_id)
if not job:
raise HTTPException(status_code=404, detail="Job not found")
# Job must be in review state to add lyrics
if job.status not in [JobStatus.AWAITING_REVIEW, JobStatus.IN_REVIEW]:
raise HTTPException(
status_code=400,
detail=f"Job not in review state (current status: {job.status})"
)
source = data.get("source", "").strip()
lyrics_text = data.get("lyrics", "").strip()
logger.info(f"Job {job_id}: Adding lyrics source '{source}' with {len(lyrics_text)} characters")
# Use tracing and job_log_context for full observability
with create_span("add-lyrics", {"job_id": job_id, "source": source, "lyrics_length": len(lyrics_text)}) as span:
with job_log_context(job_id, worker="add-lyrics"):
try:
# Create temp directory for this operation
with tempfile.TemporaryDirectory() as temp_dir:
# Download current corrections.json
with create_span("download-corrections") as download_span:
corrections_gcs = f"jobs/{job_id}/lyrics/corrections.json"
corrections_path = os.path.join(temp_dir, "corrections.json")
storage.download_file(corrections_gcs, corrections_path)
download_span.set_attribute("gcs_path", corrections_gcs)
with open(corrections_path, 'r', encoding='utf-8') as f:
original_data = json.load(f)
# Load as CorrectionResult
correction_result = CorrectionResult.from_dict(original_data)
add_span_event("corrections_loaded", {
"segments": len(correction_result.corrected_segments) if correction_result.corrected_segments else 0,
"reference_sources": len(correction_result.reference_lyrics) if correction_result.reference_lyrics else 0,
})
# Set up cache directory
cache_dir = os.path.join(temp_dir, "cache")
os.makedirs(cache_dir, exist_ok=True)
# Add lyrics source using CorrectionOperations (this is the heavy operation)
with create_span("correction-operations-add-lyrics") as correction_span:
correction_span.set_attribute("source_name", source)
updated_result = CorrectionOperations.add_lyrics_source(
correction_result=correction_result,
source=source,
lyrics_text=lyrics_text,
cache_dir=cache_dir,
logger=logger
)
add_span_event("correction_complete", {
"new_segments": len(updated_result.corrected_segments) if updated_result.corrected_segments else 0,
})
# Add audio hash for the frontend
audio_hash = _get_audio_hash(job_id)
if not updated_result.metadata:
updated_result.metadata = {}
updated_result.metadata['audio_hash'] = audio_hash
updated_result.metadata['artist'] = job.artist
updated_result.metadata['title'] = job.title
# Upload updated corrections back to GCS
with create_span("upload-corrections") as upload_span:
updated_data = updated_result.to_dict()
storage.upload_json(corrections_gcs, updated_data)
upload_span.set_attribute("gcs_path", corrections_gcs)
logger.info(f"Job {job_id}: Successfully added lyrics source '{source}'")
span.set_attribute("success", True)
return {"status": "success", "data": updated_data}
except ValueError as e:
# ValueError from CorrectionOperations (e.g., duplicate source name)
logger.warning(f"Job {job_id}: Invalid add lyrics request: {e}")
span.set_attribute("error", str(e))
raise HTTPException(status_code=400, detail=str(e))
except Exception as e:
logger.error(f"Job {job_id}: Failed to add lyrics: {e}", exc_info=True)
span.set_attribute("error", str(e))
raise HTTPException(status_code=500, detail=f"Failed to add lyrics: {str(e)}")
@router.post("/{job_id}/preview-video")
async def generate_preview_video(
job_id: str,
updated_data: Dict[str, Any],
auth_info: Tuple[str, str] = Depends(require_review_auth)
):
"""
Generate a preview video with the current corrections.
Uses the LyricsTranscriber's CorrectionOperations to generate a 360p preview
video with the user's current corrections applied.
"""
job_manager = JobManager()
storage = StorageService()
job = job_manager.get_job(job_id)
if not job:
raise HTTPException(status_code=404, detail="Job not found")
# Job must be in review state to generate preview
if job.status not in [JobStatus.AWAITING_REVIEW, JobStatus.IN_REVIEW]:
raise HTTPException(
status_code=400,
detail=f"Job not in review state (current status: {job.status})"
)
logger.info(f"Job {job_id}: Generating preview video")
# Use tracing and job_log_context for full observability
with create_span("generate-preview-video", {"job_id": job_id}) as span:
with job_log_context(job_id, worker="preview"):
try:
# Create temp directory for this preview operation
with tempfile.TemporaryDirectory() as temp_dir:
# 1. Download original corrections.json (has full structure)
with create_span("download-corrections-and-audio") as download_span:
corrections_gcs = f"jobs/{job_id}/lyrics/corrections.json"
corrections_path = os.path.join(temp_dir, "corrections.json")
storage.download_file(corrections_gcs, corrections_path)
with open(corrections_path, 'r', encoding='utf-8') as f:
original_data = json.load(f)
# 2. Download input audio
audio_path = os.path.join(temp_dir, "audio.flac")
storage.download_file(job.input_media_gcs_path, audio_path)
download_span.set_attribute("audio_gcs_path", job.input_media_gcs_path)
# 3. Load original as CorrectionResult
correction_result = CorrectionResult.from_dict(original_data)
add_span_event("corrections_loaded")
# 4. Get or create styles file for preview using unified style loader
with create_span("load-styles") as styles_span:
styles_path, _ = load_styles_from_gcs(
style_params_gcs_path=job.style_params_gcs_path,
style_assets=job.style_assets,
temp_dir=temp_dir,
download_func=storage.download_file,
logger=logger,
)
styles_span.set_attribute("styles_path", styles_path)
# 5. Set up output config for preview
output_dir = os.path.join(temp_dir, "output")
cache_dir = os.path.join(temp_dir, "cache")
os.makedirs(output_dir, exist_ok=True)
os.makedirs(cache_dir, exist_ok=True)
output_config = OutputConfig(
output_styles_json=styles_path,
output_dir=output_dir,
cache_dir=cache_dir,
video_resolution="360p",
)
# 6. Generate preview video using CorrectionOperations (heavy operation)
with create_span("render-preview-video") as render_span:
render_span.set_attribute("resolution", "360p")
result = CorrectionOperations.generate_preview_video(
correction_result=correction_result,
updated_data=updated_data,
output_config=output_config,
audio_filepath=audio_path,
artist=job.artist,
title=job.title,
logger=logger
)
add_span_event("render_complete")
# 7. Upload preview video to GCS for serving
preview_hash = result["preview_hash"]
video_path = result["video_path"]
with create_span("upload-preview-video") as upload_span:
preview_gcs_path = f"jobs/{job_id}/previews/{preview_hash}.mp4"
storage.upload_file(video_path, preview_gcs_path)
upload_span.set_attribute("gcs_path", preview_gcs_path)
# Store the GCS path for serving
if job_id not in _preview_videos:
_preview_videos[job_id] = {}
_preview_videos[job_id][preview_hash] = preview_gcs_path
logger.info(f"Job {job_id}: Preview video generated: {preview_hash}")
span.set_attribute("preview_hash", preview_hash)
span.set_attribute("success", True)
return {"status": "success", "preview_hash": preview_hash}
except Exception as e:
logger.error(f"Job {job_id}: Failed to generate preview video: {e}", exc_info=True)
span.set_attribute("error", str(e))
raise HTTPException(
status_code=500,
detail=f"Failed to generate preview video: {e}"
) from e
@router.get("/{job_id}/preview-video/{preview_hash}")
async def get_preview_video(
job_id: str,
preview_hash: str,
auth_info: Tuple[str, str] = Depends(require_review_auth)
):
"""Stream the generated preview video."""
storage = StorageService()
# Check in-memory cache first
preview_gcs_path = None
if job_id in _preview_videos and preview_hash in _preview_videos[job_id]:
preview_gcs_path = _preview_videos[job_id][preview_hash]
else:
# Try standard path
preview_gcs_path = f"jobs/{job_id}/previews/{preview_hash}.mp4"
if not storage.file_exists(preview_gcs_path):
raise HTTPException(status_code=404, detail="Preview video not found")
try:
# Download to temp file and stream
with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp:
tmp_path = tmp.name
storage.download_file(preview_gcs_path, tmp_path)
logger.info(f"Job {job_id}: Streaming preview video {preview_hash}")
return FileResponse(
tmp_path,
media_type="video/mp4",
filename=f"preview_{preview_hash}.mp4",
headers={
"Accept-Ranges": "bytes",
"Content-Disposition": "inline",
"Cache-Control": "no-cache",
},
background=BackgroundTask(os.unlink, tmp_path),
)
except Exception as e:
logger.error(f"Job {job_id}: Error streaming preview video: {e}", exc_info=True)
raise HTTPException(status_code=500, detail=f"Error streaming preview video: {str(e)}")
@router.post("/{job_id}/v1/annotations")
async def submit_annotation(
job_id: str,
annotation: Dict[str, Any],
auth_info: Tuple[str, str] = Depends(require_review_auth)
):
"""
Submit a correction annotation for ML training data.
For now, just log and acknowledge - full annotation support
would require a database.
"""
logger.info(f"Job {job_id}: Annotation submitted (logged but not stored)")
return {"status": "success", "annotation_id": "stub"}
@router.get("/{job_id}/v1/annotations/stats")
async def get_annotation_stats(
job_id: str,
auth_info: Tuple[str, str] = Depends(require_review_auth)
):
"""Get annotation statistics."""
return {
"total_annotations": 0,
"by_type": {},
"message": "Annotation stats not yet implemented"
}
-162
View File
@@ -1,162 +0,0 @@
"""
Theme API routes for listing and retrieving theme information.
Themes are pre-created style configurations that users can select when creating jobs.
These endpoints are public (no authentication required) to allow theme selection
before job creation.
"""
import logging
from typing import Optional
from fastapi import APIRouter, HTTPException
from backend.models.theme import ThemeDetailResponse, ThemesListResponse
from backend.services.theme_service import get_theme_service
logger = logging.getLogger(__name__)
router = APIRouter(prefix="/themes", tags=["themes"])
@router.get("", response_model=ThemesListResponse)
async def list_themes() -> ThemesListResponse:
"""
List all available themes.
Returns a list of themes with their metadata and preview image URLs.
Preview URLs are signed and valid for 60 minutes.
This endpoint is public and does not require authentication.
"""
try:
theme_service = get_theme_service()
themes = theme_service.list_themes()
return ThemesListResponse(themes=themes)
except Exception as e:
logger.error(f"Error listing themes: {e}")
raise HTTPException(
status_code=500,
detail="Failed to load themes"
)
@router.get("/{theme_id}", response_model=ThemeDetailResponse)
async def get_theme(theme_id: str) -> ThemeDetailResponse:
"""
Get detailed information about a specific theme.
Returns the full theme details including style parameters.
This can be used to preview theme settings or inspect configuration.
Args:
theme_id: The unique identifier of the theme
Returns:
ThemeDetailResponse with full theme details
Raises:
404: Theme not found
"""
try:
theme_service = get_theme_service()
theme = theme_service.get_theme(theme_id)
if theme is None:
raise HTTPException(
status_code=404,
detail=f"Theme not found: {theme_id}"
)
return ThemeDetailResponse(theme=theme)
except HTTPException:
raise
except Exception as e:
logger.error(f"Error getting theme {theme_id}: {e}")
raise HTTPException(
status_code=500,
detail="Failed to load theme"
)
@router.get("/{theme_id}/preview")
async def get_theme_preview(theme_id: str) -> dict:
"""
Get a signed URL for the theme's preview image.
This endpoint is useful when you need just the preview URL
without loading the full theme details.
Args:
theme_id: The unique identifier of the theme
Returns:
Object with preview_url field
Raises:
404: Theme not found or no preview available
"""
try:
theme_service = get_theme_service()
if not theme_service.theme_exists(theme_id):
raise HTTPException(
status_code=404,
detail=f"Theme not found: {theme_id}"
)
theme = theme_service.get_theme(theme_id)
if theme is None or theme.preview_url is None:
raise HTTPException(
status_code=404,
detail=f"No preview available for theme: {theme_id}"
)
return {"preview_url": theme.preview_url}
except HTTPException:
raise
except Exception as e:
logger.error(f"Error getting preview for theme {theme_id}: {e}")
raise HTTPException(
status_code=500,
detail="Failed to load theme preview"
)
@router.get("/{theme_id}/youtube-description")
async def get_theme_youtube_description(theme_id: str) -> dict:
"""
Get the YouTube description template for a theme.
Some themes include a default YouTube video description template
that can be used when uploading videos.
Args:
theme_id: The unique identifier of the theme
Returns:
Object with description field containing the template text,
or null if no template is available
Raises:
404: Theme not found
"""
try:
theme_service = get_theme_service()
if not theme_service.theme_exists(theme_id):
raise HTTPException(
status_code=404,
detail=f"Theme not found: {theme_id}"
)
description = theme_service.get_youtube_description(theme_id)
return {"description": description}
except HTTPException:
raise
except Exception as e:
logger.error(f"Error getting YouTube description for theme {theme_id}: {e}")
raise HTTPException(
status_code=500,
detail="Failed to load YouTube description"
)
File diff suppressed because it is too large. Load diff
-166
View File
@@ -1,166 +0,0 @@
"""
Configuration management for the karaoke generation backend.
"""
import os
import logging
from typing import Optional, Dict
from pydantic_settings import BaseSettings
from google.cloud import secretmanager
logger = logging.getLogger(__name__)
class Settings(BaseSettings):
"""Application settings."""
# Google Cloud
google_cloud_project: str = os.getenv("GOOGLE_CLOUD_PROJECT", "")
gcs_bucket_name: str = os.getenv("GCS_BUCKET_NAME", "karaoke-gen-storage")
gcs_temp_bucket: str = os.getenv("GCS_TEMP_BUCKET", "karaoke-gen-temp")
gcs_output_bucket: str = os.getenv("GCS_OUTPUT_BUCKET", "karaoke-gen-outputs")
firestore_collection: str = os.getenv("FIRESTORE_COLLECTION", "jobs")
# Audio Separator API (for GPU processing)
audio_separator_api_url: Optional[str] = os.getenv("AUDIO_SEPARATOR_API_URL")
# External APIs (can be set via env or Secret Manager)
audioshake_api_key: Optional[str] = os.getenv("AUDIOSHAKE_API_KEY")
genius_api_key: Optional[str] = os.getenv("GENIUS_API_KEY")
spotify_cookie: Optional[str] = os.getenv("SPOTIFY_COOKIE_SP_DC")
rapidapi_key: Optional[str] = os.getenv("RAPIDAPI_KEY")
# Authentication
admin_tokens: Optional[str] = os.getenv("ADMIN_TOKENS") # Comma-separated list
# Application
environment: str = os.getenv("ENVIRONMENT", "development")
log_level: str = os.getenv("LOG_LEVEL", "INFO")
# 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)
enable_cloud_tasks: bool = os.getenv("ENABLE_CLOUD_TASKS", "false").lower() in ("true", "1", "yes")
gcp_region: str = os.getenv("GCP_REGION", "us-central1")
# Cloud Run Jobs (for long-running video encoding)
# When enabled AND enable_cloud_tasks is true, video worker uses Cloud Run Jobs
# 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")
# Worker logs storage mode
# When enabled, worker logs are stored in a Firestore subcollection (jobs/{job_id}/logs)
# instead of an embedded array. This avoids the 1MB document size limit.
# Default is true for new deployments.
use_log_subcollection: bool = os.getenv("USE_LOG_SUBCOLLECTION", "true").lower() in ("true", "1", "yes")
# Flacfetch remote service (for torrent downloads)
# When configured, audio search uses the remote flacfetch HTTP API instead of local flacfetch.
# This is required for torrent downloads since Cloud Run doesn't support BitTorrent.
flacfetch_api_url: Optional[str] = os.getenv("FLACFETCH_API_URL") # e.g., http://10.0.0.5:8080
flacfetch_api_key: Optional[str] = os.getenv("FLACFETCH_API_KEY")
# Default distribution settings (can be overridden per-request)
default_dropbox_path: Optional[str] = os.getenv("DEFAULT_DROPBOX_PATH")
default_gdrive_folder_id: Optional[str] = os.getenv("DEFAULT_GDRIVE_FOLDER_ID")
# Strip whitespace/newlines from webhook URL - common issue when env vars are set with trailing newlines
default_discord_webhook_url: Optional[str] = (
os.getenv("DEFAULT_DISCORD_WEBHOOK_URL", "").strip() or None
)
# Default values for web service jobs (YouTube/Dropbox distribution)
default_enable_youtube_upload: bool = os.getenv("DEFAULT_ENABLE_YOUTUBE_UPLOAD", "false").lower() in ("true", "1", "yes")
default_brand_prefix: Optional[str] = os.getenv("DEFAULT_BRAND_PREFIX")
default_youtube_description: str = os.getenv(
"DEFAULT_YOUTUBE_DESCRIPTION",
"Karaoke video created with Nomad Karaoke (https://nomadkaraoke.com)\n\n"
"AI-powered vocal separation and synchronized lyrics.\n\n"
"#karaoke #music #singing #instrumental #lyrics"
)
# Secret Manager cache
_secret_cache: Dict[str, str] = {}
class Config:
env_file = ".env"
case_sensitive = False
def get_secret(self, secret_id: str) -> Optional[str]:
"""
Get a secret from Google Secret Manager.
Caches secrets in memory to avoid repeated API calls.
Falls back to environment variables if Secret Manager unavailable.
Args:
secret_id: Secret name (e.g., "audioshake-api-key")
Returns:
Secret value or None if not found
"""
# Check cache first
if secret_id in self._secret_cache:
return self._secret_cache[secret_id]
# Check environment variable (development mode)
env_var = secret_id.upper().replace('-', '_')
env_value = os.getenv(env_var)
if env_value:
logger.debug(f"Using {secret_id} from environment variable")
self._secret_cache[secret_id] = env_value
return env_value
# Try Secret Manager (production mode)
if not self.google_cloud_project:
logger.warning(f"Cannot fetch secret {secret_id}: No GCP project configured")
return None
try:
client = secretmanager.SecretManagerServiceClient()
name = f"projects/{self.google_cloud_project}/secrets/{secret_id}/versions/latest"
response = client.access_secret_version(request={"name": name})
# Strip whitespace/newlines - common issue when secrets are created with trailing newlines
secret_value = response.payload.data.decode('UTF-8').strip()
# Cache it
self._secret_cache[secret_id] = secret_value
logger.info(f"Loaded secret {secret_id} from Secret Manager")
return secret_value
except Exception as e:
logger.error(f"Failed to load secret {secret_id} from Secret Manager: {e}")
return None
# Global settings instance
settings = Settings()
def get_settings() -> Settings:
"""Get the global settings instance."""
return settings
-133
View File
@@ -1,133 +0,0 @@
"""
FastAPI application entry point for karaoke generation backend.
"""
import logging
from contextlib import asynccontextmanager
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.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
# Configure structured logging (JSON in Cloud Run, human-readable locally)
# This must happen before any logging calls
setup_structured_logging()
logger = logging.getLogger(__name__)
# Initialize OpenTelemetry tracing (must happen before app creation)
tracing_enabled = setup_tracing(
service_name="karaoke-backend",
service_version=VERSION,
enable_in_dev=False, # Set to True to enable tracing locally
)
async def validate_credentials_on_startup():
"""Validate OAuth credentials on startup and send alerts if needed."""
try:
from backend.services.credential_manager import get_credential_manager, CredentialStatus
manager = get_credential_manager()
results = manager.check_all_credentials()
invalid_services = [
result for result in results.values()
if result.status in (CredentialStatus.INVALID, CredentialStatus.EXPIRED)
]
if invalid_services:
logger.warning(f"Some OAuth credentials need attention:")
for result in invalid_services:
logger.warning(f" - {result.service}: {result.message}")
# Try to send Discord alert
discord_url = settings.get_secret("discord-alert-webhook") if hasattr(settings, 'get_secret') else None
if discord_url:
manager.send_credential_alert(invalid_services, discord_url)
logger.info("Sent credential alert to Discord")
else:
logger.info("All OAuth credentials validated successfully")
except Exception as e:
logger.error(f"Failed to validate credentials on startup: {e}")
@asynccontextmanager
async def lifespan(app: FastAPI):
"""Lifespan event handler for startup and shutdown."""
# Startup
logger.info("Starting karaoke generation backend")
logger.info(f"Environment: {settings.environment}")
logger.info(f"GCS Bucket: {settings.gcs_bucket_name}")
logger.info(f"Tracing enabled: {tracing_enabled}")
# Validate OAuth credentials (non-blocking)
try:
await validate_credentials_on_startup()
except Exception as e:
logger.error(f"Credential validation failed: {e}")
yield
# Shutdown
logger.info("Shutting down karaoke generation backend")
# Create FastAPI app
app = FastAPI(
title="Karaoke Generator API",
description="Backend API for web-based karaoke video generation",
version=VERSION,
lifespan=lifespan
)
# Instrument FastAPI with OpenTelemetry (adds automatic spans for all requests)
if tracing_enabled:
instrument_app(app)
# Configure CORS
app.add_middleware(
CORSMiddleware,
allow_origins=["*"], # Configure this properly for production
allow_credentials=True,
allow_methods=["*"],
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")
app.include_router(file_upload.router, prefix="/api") # File upload endpoint
app.include_router(internal.router, prefix="/api") # Internal worker endpoints
app.include_router(review.router, prefix="/api") # Review UI compatibility endpoints
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("/")
async def root():
"""Root endpoint."""
return {
"service": "karaoke-gen-backend",
"version": VERSION,
"status": "running"
}
if __name__ == "__main__":
import uvicorn
uvicorn.run(app, host="0.0.0.0", port=8080)
-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"
View File
Whitespace-only changes.
-501
View File
@@ -1,501 +0,0 @@
"""
Job data models for karaoke generation.
This module defines the complete state machine for karaoke generation jobs,
mirroring the 8-stage CLI workflow with human-in-the-loop interaction points.
"""
from typing import Optional, Dict, Any, List
from datetime import datetime
from enum import Enum
from pydantic import BaseModel, Field, validator
class JobStatus(str, Enum):
"""
Job status enumeration - Complete state machine.
The workflow has 8 main stages with 3 human interaction points:
1. Input & Setup (may include audio source selection)
2. Parallel Processing (audio + lyrics)
3. Title/End Screen Generation
4. Countdown Padding Synchronization
5. Human Review (BLOCKING)
6. Instrumental Selection (BLOCKING)
7. Video Finalization
8. Distribution
"""
# Initial states
PENDING = "pending" # Job created, queued for processing
# Audio search states (for artist+title search mode)
SEARCHING_AUDIO = "searching_audio" # Searching for audio sources via flacfetch
AWAITING_AUDIO_SELECTION = "awaiting_audio_selection" # ⚠️ WAITING FOR USER - select audio source
DOWNLOADING_AUDIO = "downloading_audio" # Downloading selected audio from source
DOWNLOADING = "downloading" # Downloading from URL or processing upload
# Stage 2a: Audio separation (parallel track 1)
SEPARATING_STAGE1 = "separating_stage1" # Clean instrumental separation (Modal API)
SEPARATING_STAGE2 = "separating_stage2" # Backing vocals separation (Modal API)
AUDIO_COMPLETE = "audio_complete" # All audio stems ready
# Stage 2b: Lyrics processing (parallel track 2)
TRANSCRIBING = "transcribing" # AudioShake API transcription
CORRECTING = "correcting" # Automatic lyrics correction
LYRICS_COMPLETE = "lyrics_complete" # Corrections JSON ready
# Stage 3: Title/End screens
GENERATING_SCREENS = "generating_screens" # Creating title and end screen videos
# Stage 4: Countdown padding (automatic)
APPLYING_PADDING = "applying_padding" # Synchronizing countdown padding
# Stage 5: Human review (BLOCKING)
AWAITING_REVIEW = "awaiting_review" # ⚠️ WAITING FOR USER - lyrics review needed
IN_REVIEW = "in_review" # User is actively reviewing lyrics
REVIEW_COMPLETE = "review_complete" # User submitted corrected lyrics
# Stage 5.5: Render video with corrected lyrics (post-review)
RENDERING_VIDEO = "rendering_video" # Using OutputGenerator to create with_vocals.mkv
# Stage 6: Instrumental selection (BLOCKING)
AWAITING_INSTRUMENTAL_SELECTION = "awaiting_instrumental_selection" # ⚠️ WAITING FOR USER
INSTRUMENTAL_SELECTED = "instrumental_selected" # User made selection
# Stage 7: Video generation and finalization
GENERATING_VIDEO = "generating_video" # Creating initial karaoke video
ENCODING = "encoding" # Multi-format video encoding (Cloud Build)
PACKAGING = "packaging" # CDG/TXT ZIP generation
# Stage 8: Distribution (optional)
UPLOADING = "uploading" # YouTube/Dropbox upload
NOTIFYING = "notifying" # Discord/Email notifications
# Terminal states
COMPLETE = "complete" # All processing finished successfully
PREP_COMPLETE = "prep_complete" # Prep-only job completed (stops after review)
FAILED = "failed" # Unrecoverable error occurred
CANCELLED = "cancelled" # User cancelled the job
# Legacy compatibility (will be removed)
QUEUED = "queued" # Deprecated: use PENDING
PROCESSING = "processing" # Deprecated: use specific states
READY_FOR_FINALIZATION = "ready_for_finalization" # Deprecated
FINALIZING = "finalizing" # Deprecated: use ENCODING/PACKAGING
ERROR = "error" # Deprecated: use FAILED
# Valid state transitions
STATE_TRANSITIONS = {
# PENDING can go to DOWNLOADING (file upload), SEARCHING_AUDIO (artist+title search), or AWAITING_INSTRUMENTAL_SELECTION (finalise-only)
JobStatus.PENDING: [JobStatus.DOWNLOADING, JobStatus.SEARCHING_AUDIO, JobStatus.AWAITING_INSTRUMENTAL_SELECTION, JobStatus.FAILED, JobStatus.CANCELLED],
# Audio search flow (for artist+title search mode)
JobStatus.SEARCHING_AUDIO: [JobStatus.AWAITING_AUDIO_SELECTION, JobStatus.DOWNLOADING_AUDIO, JobStatus.FAILED],
JobStatus.AWAITING_AUDIO_SELECTION: [JobStatus.DOWNLOADING_AUDIO, JobStatus.FAILED, JobStatus.CANCELLED],
JobStatus.DOWNLOADING_AUDIO: [JobStatus.DOWNLOADING, JobStatus.FAILED],
# DOWNLOADING allows parallel processing (audio + lyrics) and then screens when both complete
JobStatus.DOWNLOADING: [JobStatus.SEPARATING_STAGE1, JobStatus.TRANSCRIBING, JobStatus.GENERATING_SCREENS, JobStatus.FAILED],
# Audio separation flow
JobStatus.SEPARATING_STAGE1: [JobStatus.SEPARATING_STAGE2, JobStatus.FAILED],
JobStatus.SEPARATING_STAGE2: [JobStatus.AUDIO_COMPLETE, JobStatus.FAILED],
JobStatus.AUDIO_COMPLETE: [JobStatus.GENERATING_SCREENS, JobStatus.FAILED],
# Lyrics flow
JobStatus.TRANSCRIBING: [JobStatus.CORRECTING, JobStatus.FAILED],
JobStatus.CORRECTING: [JobStatus.LYRICS_COMPLETE, JobStatus.FAILED],
JobStatus.LYRICS_COMPLETE: [JobStatus.GENERATING_SCREENS, JobStatus.FAILED],
# Post-parallel processing
JobStatus.GENERATING_SCREENS: [JobStatus.APPLYING_PADDING, JobStatus.AWAITING_REVIEW, JobStatus.AWAITING_INSTRUMENTAL_SELECTION, JobStatus.FAILED],
JobStatus.APPLYING_PADDING: [JobStatus.AWAITING_REVIEW, JobStatus.FAILED],
# Human review flow
# AWAITING_REVIEW can go directly to REVIEW_COMPLETE (quick review) or to IN_REVIEW (editing)
JobStatus.AWAITING_REVIEW: [JobStatus.IN_REVIEW, JobStatus.REVIEW_COMPLETE, JobStatus.FAILED, JobStatus.CANCELLED],
JobStatus.IN_REVIEW: [JobStatus.REVIEW_COMPLETE, JobStatus.AWAITING_REVIEW, JobStatus.FAILED],
JobStatus.REVIEW_COMPLETE: [JobStatus.RENDERING_VIDEO, JobStatus.PREP_COMPLETE, JobStatus.FAILED], # PREP_COMPLETE for prep-only jobs
# Video rendering (post-review)
JobStatus.RENDERING_VIDEO: [JobStatus.AWAITING_INSTRUMENTAL_SELECTION, JobStatus.PREP_COMPLETE, JobStatus.FAILED],
# Instrumental selection flow
JobStatus.AWAITING_INSTRUMENTAL_SELECTION: [JobStatus.INSTRUMENTAL_SELECTED, JobStatus.FAILED, JobStatus.CANCELLED],
JobStatus.INSTRUMENTAL_SELECTED: [JobStatus.GENERATING_VIDEO, JobStatus.FAILED],
# Video generation flow
JobStatus.GENERATING_VIDEO: [JobStatus.ENCODING, JobStatus.FAILED],
JobStatus.ENCODING: [JobStatus.PACKAGING, JobStatus.COMPLETE, JobStatus.FAILED],
JobStatus.PACKAGING: [JobStatus.UPLOADING, JobStatus.COMPLETE, JobStatus.FAILED],
# Distribution flow
JobStatus.UPLOADING: [JobStatus.NOTIFYING, JobStatus.COMPLETE, JobStatus.FAILED],
JobStatus.NOTIFYING: [JobStatus.COMPLETE, JobStatus.FAILED],
# Terminal states - COMPLETE, PREP_COMPLETE have no transitions
# FAILED and CANCELLED allow retry transitions to resume from checkpoints
# PREP_COMPLETE allows finalise-only continuation
JobStatus.COMPLETE: [],
JobStatus.PREP_COMPLETE: [JobStatus.AWAITING_INSTRUMENTAL_SELECTION, JobStatus.FAILED], # Finalise-only continues from here
JobStatus.FAILED: [
JobStatus.DOWNLOADING, # Retry from beginning (if input audio exists)
JobStatus.INSTRUMENTAL_SELECTED, # Retry from video generation
JobStatus.REVIEW_COMPLETE, # Retry from render stage
JobStatus.LYRICS_COMPLETE, # Retry from screens generation
],
JobStatus.CANCELLED: [
JobStatus.DOWNLOADING, # Retry from beginning (if input audio exists)
JobStatus.INSTRUMENTAL_SELECTED, # Retry from video generation
JobStatus.REVIEW_COMPLETE, # Retry from render stage
JobStatus.LYRICS_COMPLETE, # Retry from screens generation
],
# Legacy states (for backward compatibility)
JobStatus.QUEUED: [JobStatus.PENDING],
JobStatus.PROCESSING: [JobStatus.SEPARATING_STAGE1, JobStatus.TRANSCRIBING],
JobStatus.READY_FOR_FINALIZATION: [JobStatus.GENERATING_VIDEO],
JobStatus.FINALIZING: [JobStatus.ENCODING],
JobStatus.ERROR: [JobStatus.FAILED],
}
class TimelineEvent(BaseModel):
"""Timeline event for job progress tracking."""
status: str
timestamp: str
progress: Optional[int] = None
message: Optional[str] = None
class LogEntry(BaseModel):
"""Worker log entry for debugging and monitoring."""
timestamp: str
level: str # DEBUG, INFO, WARNING, ERROR
worker: str # audio, lyrics, screens, video, render
message: str
class Job(BaseModel):
"""
Complete job data model.
Tracks the full lifecycle of a karaoke generation job from submission
through all 8 stages to completion or failure.
"""
job_id: str
status: JobStatus
progress: int = 0 # 0-100 percentage for UI display
created_at: datetime
updated_at: datetime
# Input data
url: Optional[str] = None # YouTube URL (if provided)
artist: Optional[str] = None
title: Optional[str] = None
filename: Optional[str] = None # Original uploaded filename
input_media_gcs_path: Optional[str] = None # GCS path to uploaded file
# User preferences
enable_cdg: bool = False # Generate CDG+MP3 package (requires style config)
enable_txt: bool = False # Generate TXT+MP3 package (requires style config)
enable_youtube_upload: bool = False # Upload to YouTube
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")
color_overrides: Dict[str, str] = Field(default_factory=dict)
"""
User color overrides applied on top of theme. Keys:
- artist_color: Hex color for artist name (#RRGGBB)
- title_color: Hex color for song title
- sung_lyrics_color: Hex color for highlighted lyrics
- unsung_lyrics_color: Hex color for unhighlighted lyrics
"""
# Style configuration (uploaded files - used when theme_id is not set)
style_params_gcs_path: Optional[str] = None # GCS path to style_params.json
style_assets: Dict[str, str] = Field(default_factory=dict)
"""
GCS paths to style asset files:
{
"intro_background": "gs://bucket/jobs/{job_id}/style/intro_bg.png",
"karaoke_background": "gs://bucket/jobs/{job_id}/style/karaoke_bg.png",
"end_background": "gs://bucket/jobs/{job_id}/style/end_bg.png",
"font": "gs://bucket/jobs/{job_id}/style/font.ttf",
"cdg_instrumental_background": "gs://bucket/jobs/{job_id}/style/cdg_instr.png",
"cdg_title_background": "gs://bucket/jobs/{job_id}/style/cdg_title.png",
"cdg_outro_background": "gs://bucket/jobs/{job_id}/style/cdg_outro.png"
}
"""
# Finalisation configuration
brand_prefix: Optional[str] = None # Brand code prefix (e.g., "NOMAD")
discord_webhook_url: Optional[str] = None # Discord notification webhook
youtube_description_template: Optional[str] = None # YouTube description template text
# Distribution configuration (native API - for remote CLI)
dropbox_path: Optional[str] = None # Dropbox folder path for organized output (e.g., "/Karaoke/Tracks-Organized")
gdrive_folder_id: Optional[str] = None # Google Drive folder ID for public share uploads
# Legacy distribution configuration (rclone - for local CLI backward compat)
organised_dir_rclone_root: Optional[str] = None # Deprecated: use dropbox_path instead
# Lyrics configuration (overrides for search/transcription)
lyrics_artist: Optional[str] = None # Override artist name for lyrics search
lyrics_title: Optional[str] = None # Override title for lyrics search
lyrics_file_gcs_path: Optional[str] = None # GCS path to user-provided lyrics file
subtitle_offset_ms: int = 0 # Offset for subtitle timing (positive = delay)
# Audio separation model configuration
clean_instrumental_model: Optional[str] = None # Model for clean instrumental separation
backing_vocals_models: Optional[List[str]] = None # Models for backing vocals separation
other_stems_models: Optional[List[str]] = None # Models for other stems (bass, drums, etc.)
# Existing instrumental configuration (Batch 3)
existing_instrumental_gcs_path: Optional[str] = None # GCS path to user-provided instrumental file
# Audio search configuration (Batch 5 - artist+title search mode)
audio_search_artist: Optional[str] = None # Artist name used for audio search
audio_search_title: Optional[str] = None # Title used for audio search
auto_download: bool = False # Auto-select best audio source (skip selection)
# Two-phase workflow configuration (Batch 6)
prep_only: bool = False # Stop after review, don't run finalisation
finalise_only: bool = False # Skip prep, run only finalisation (requires uploaded prep outputs)
keep_brand_code: Optional[str] = None # Preserve existing brand code instead of generating new one
# Review authentication (Batch 7)
review_token: Optional[str] = None # Job-scoped token for lyrics review UI access (generated when entering AWAITING_REVIEW)
review_token_expires_at: Optional[datetime] = None # Token expiry time (optional, for extra security)
instrumental_token: Optional[str] = None # Job-scoped token for instrumental review UI access (generated when entering AWAITING_INSTRUMENTAL_SELECTION)
instrumental_token_expires_at: Optional[datetime] = None # Token expiry time
# Processing state
track_output_dir: Optional[str] = None # Local output directory (temp)
audio_hash: Optional[str] = None # Hash for deduplication
# State-specific data (JSON field for stage-specific metadata)
state_data: Dict[str, Any] = Field(default_factory=dict)
"""
Stage-specific metadata. Examples:
- audio_complete: {"stems": {"clean": "gs://...", "backing": "gs://..."}}
- lyrics_complete: {"corrections_url": "gs://...", "audio_url": "gs://..."}
- review_complete: {"corrected_lyrics": {...}}
- instrumental_selected: {"selection": "clean" | "with_backing"}
- encoding: {"build_id": "...", "progress": 45}
"""
# Timeline tracking
timeline: List[TimelineEvent] = Field(default_factory=list)
# Worker logs for debugging (limited to last N entries to avoid document size issues)
worker_logs: List[LogEntry] = Field(default_factory=list)
# File URLs (GCS storage)
file_urls: Dict[str, Any] = Field(default_factory=dict)
"""
File storage URLs. Structure:
{
"input": "gs://bucket/jobs/{job_id}/input.flac",
"stems": {
"instrumental_clean": "gs://...",
"instrumental_with_backing": "gs://...",
"vocals": "gs://...",
"backing_vocals": "gs://...",
"lead_vocals": "gs://...",
"bass": "gs://...",
"drums": "gs://...",
"guitar": "gs://...",
"piano": "gs://...",
"other": "gs://..."
},
"lyrics": {
"corrections": "gs://bucket/jobs/{job_id}/lyrics/corrections.json",
"audio": "gs://bucket/jobs/{job_id}/lyrics/audio.flac",
"lrc": "gs://...",
"ass": "gs://..."
},
"screens": {
"title": "gs://bucket/jobs/{job_id}/screens/title.mov",
"end": "gs://bucket/jobs/{job_id}/screens/end.mov"
},
"videos": {
"with_vocals": "gs://bucket/jobs/{job_id}/videos/with_vocals.mkv"
},
"finals": {
"lossless_4k_mp4": "gs://...",
"lossless_4k_mkv": "gs://...",
"lossy_4k_mp4": "gs://...",
"lossy_720p_mp4": "gs://..."
},
"packages": {
"cdg_zip": "gs://...",
"txt_zip": "gs://..."
},
"youtube": {
"url": "https://youtube.com/watch?v=...",
"video_id": "..."
}
}
"""
# Results (for backward compatibility, will be deprecated)
output_files: Dict[str, str] = Field(default_factory=dict)
download_urls: Dict[str, str] = Field(default_factory=dict)
# Error handling
error_message: Optional[str] = None
error_details: Optional[Dict[str, Any]] = None # Structured error information
retry_count: int = 0 # Number of retry attempts
# Worker tracking
worker_ids: Dict[str, str] = Field(default_factory=dict)
"""
IDs of background workers/jobs:
{
"audio_worker": "cloud-run-request-id",
"lyrics_worker": "cloud-run-request-id",
"video_encoder": "cloud-build-id",
"distribution": "cloud-run-request-id"
}
"""
# Request metadata (captured at job creation for tracking and filtering)
request_metadata: Dict[str, Any] = Field(default_factory=dict)
"""
Metadata captured from the original API request.
Used for tracking, filtering, and operational management.
Standard fields:
{
"client_ip": "192.168.1.1", # IP address of the client
"user_agent": "karaoke-gen-remote/0.71.0", # User-Agent header
"environment": "test", # From X-Environment header (test/production/development)
"client_id": "cli-user-123", # From X-Client-ID header (customer/user identifier)
"server_version": "0.71.0", # Server version at job creation
"created_from": "upload", # "upload" (file) or "url" (YouTube URL)
"custom_headers": { # All X-* headers for extensibility
"X-Environment": "test",
"X-Client-ID": "cli-user-123",
"X-Request-ID": "abc-123"
}
}
Use cases:
- Filter test vs production jobs
- Track jobs by customer/client
- Debug issues with specific clients
- Bulk cleanup of test jobs
"""
# Note: Status transition validation is handled by JobManager.validate_state_transition()
# which is called before status updates. The Job model does not validate transitions
# because Firestore updates happen directly without reconstructing the model.
class Config:
use_enum_values = True
class JobCreate(BaseModel):
"""
Job creation request.
Either `url` OR file upload is required (file upload handled separately).
Artist and title are optional - will be auto-detected from YouTube if not provided.
"""
url: Optional[str] = None
artist: Optional[str] = None
title: Optional[str] = None
filename: Optional[str] = None # Original uploaded filename
# Optional preferences
enable_cdg: bool = False # Requires style config
enable_txt: bool = False # Requires style config
enable_youtube_upload: bool = False
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")
color_overrides: Dict[str, str] = Field(default_factory=dict)
"""
User color overrides applied on top of theme. Keys:
- artist_color: Hex color for artist name (#RRGGBB)
- title_color: Hex color for song title
- sung_lyrics_color: Hex color for highlighted lyrics
- unsung_lyrics_color: Hex color for unhighlighted lyrics
"""
# Style configuration (will be populated after file upload, or from theme)
style_params_gcs_path: Optional[str] = None
style_assets: Dict[str, str] = Field(default_factory=dict)
# Finalisation configuration
brand_prefix: Optional[str] = None
discord_webhook_url: Optional[str] = None
youtube_description_template: Optional[str] = None
# Distribution configuration (native API - for remote CLI)
dropbox_path: Optional[str] = None # Dropbox folder path for organized output
gdrive_folder_id: Optional[str] = None # Google Drive folder ID for public share uploads
# Legacy (rclone - deprecated, use dropbox_path instead)
organised_dir_rclone_root: Optional[str] = None
# Lyrics configuration (overrides for search/transcription)
lyrics_artist: Optional[str] = None # Override artist name for lyrics search
lyrics_title: Optional[str] = None # Override title for lyrics search
lyrics_file_gcs_path: Optional[str] = None # GCS path to user-provided lyrics file
subtitle_offset_ms: int = 0 # Offset for subtitle timing (positive = delay)
# Audio separation model configuration
clean_instrumental_model: Optional[str] = None # Model for clean instrumental separation
backing_vocals_models: Optional[List[str]] = None # Models for backing vocals separation
other_stems_models: Optional[List[str]] = None # Models for other stems (bass, drums, etc.)
# Existing instrumental configuration (Batch 3)
existing_instrumental_gcs_path: Optional[str] = None # GCS path to user-provided instrumental file
# Audio search configuration (Batch 5 - artist+title search mode)
audio_search_artist: Optional[str] = None # Artist name used for audio search
audio_search_title: Optional[str] = None # Title used for audio search
auto_download: bool = False # Auto-select best audio source (skip selection)
# Two-phase workflow configuration (Batch 6)
prep_only: bool = False # Stop after review, don't run finalisation
finalise_only: bool = False # Skip prep, run only finalisation
keep_brand_code: Optional[str] = None # Preserve existing brand code instead of generating new one
# Request metadata (set by API endpoint from request headers)
request_metadata: Dict[str, Any] = Field(default_factory=dict)
"""
Populated by the API endpoint with request context:
- client_ip: Client IP address
- user_agent: User-Agent header
- environment: From X-Environment header (test/production/development)
- client_id: From X-Client-ID header
- server_version: Current server version
- custom_headers: All X-* headers
"""
@validator('url', 'artist', 'title')
def validate_inputs(cls, v):
"""Validate string inputs are not empty."""
if v is not None and isinstance(v, str) and not v.strip():
raise ValueError("Field cannot be empty string")
return v.strip() if isinstance(v, str) else v
class JobResponse(BaseModel):
"""Job response model."""
status: str
job_id: str
message: str
-123
View File
@@ -1,123 +0,0 @@
"""
API request models for karaoke generation endpoints.
"""
from typing import Optional, Dict, Any, List
from pydantic import BaseModel, HttpUrl, validator
class URLSubmissionRequest(BaseModel):
"""Request to submit a job from a URL (YouTube, etc.)."""
url: HttpUrl
artist: Optional[str] = None # Auto-detected if not provided
title: Optional[str] = None # Auto-detected if not provided
# Optional preferences
enable_cdg: bool = False # Requires style config
enable_txt: bool = False # Requires style config
enable_youtube_upload: bool = False
youtube_description: Optional[str] = None
webhook_url: Optional[str] = None
user_email: Optional[str] = None
class UploadSubmissionRequest(BaseModel):
"""Request to submit a job from an uploaded file."""
artist: str
title: str
# Optional preferences
enable_cdg: bool = False # Requires style config
enable_txt: bool = False # Requires style config
enable_youtube_upload: bool = False
youtube_description: Optional[str] = None
webhook_url: Optional[str] = None
user_email: Optional[str] = None
class CorrectionsSubmission(BaseModel):
"""
Request to submit corrected lyrics after human review.
This is the critical human-in-the-loop interaction point.
The corrections data comes from the lyrics-transcriber review interface.
"""
corrections: Dict[str, Any] # Full corrections JSON from frontend
user_notes: Optional[str] = None # Optional notes from reviewer
@validator('corrections')
def validate_corrections_format(cls, v):
"""Validate corrections has required fields."""
required_fields = ['lines', 'metadata']
for field in required_fields:
if field not in v:
raise ValueError(f"Corrections must include '{field}' field")
return v
class InstrumentalSelection(BaseModel):
"""
Request to select instrumental audio option.
This is the second critical human-in-the-loop interaction point.
User chooses between clean instrumental, instrumental with backing vocals,
or a custom instrumental (created via create-custom-instrumental endpoint).
"""
selection: str # "clean", "with_backing", or "custom"
@validator('selection')
def validate_selection(cls, v):
"""Validate selection is a valid option."""
valid_options = ['clean', 'with_backing', 'custom']
if v not in valid_options:
raise ValueError(f"Selection must be one of: {valid_options}")
return v
class MuteRegionRequest(BaseModel):
"""A region to mute in the backing vocals."""
start_seconds: float
end_seconds: float
@validator('start_seconds')
def validate_start(cls, v):
if v < 0:
raise ValueError("start_seconds must be non-negative")
return v
@validator('end_seconds')
def validate_end(cls, v, values):
if 'start_seconds' in values and v <= values['start_seconds']:
raise ValueError("end_seconds must be greater than start_seconds")
return v
class CreateCustomInstrumentalRequest(BaseModel):
"""
Request to create a custom instrumental with muted backing vocal regions.
The mute_regions specify time ranges in the backing vocals track that
should be silenced before mixing with the clean instrumental.
"""
mute_regions: List[MuteRegionRequest]
@validator('mute_regions')
def validate_regions(cls, v):
if not v:
raise ValueError("At least one mute region is required")
return v
class StartReviewRequest(BaseModel):
"""Request to mark job as in-review (user opened interface)."""
pass # No body needed, just triggers state transition
class CancelJobRequest(BaseModel):
"""Request to cancel a job."""
reason: Optional[str] = None
class RetryJobRequest(BaseModel):
"""Request to retry a failed job."""
from_stage: Optional[str] = None # Optional: restart from specific stage
-153
View File
@@ -1,153 +0,0 @@
"""
Theme data models for karaoke-gen.
Themes are pre-created style configurations stored in GCS that users can select
when creating karaoke jobs. Each theme includes:
- Style parameters (fonts, colors, backgrounds, layouts)
- Asset files (images, fonts)
- Preview images
- Optional YouTube description template
"""
from datetime import datetime
from typing import Any, Dict, List, Optional
from pydantic import BaseModel, Field
class ThemeSummary(BaseModel):
"""Summary of a theme for listing purposes."""
id: str = Field(..., description="Unique theme identifier (e.g., 'nomad', 'default')")
name: str = Field(..., description="Human-readable theme name")
description: str = Field(..., description="Brief description of the theme style")
preview_url: Optional[str] = Field(None, description="Signed URL for preview image")
thumbnail_url: Optional[str] = Field(None, description="Signed URL for smaller thumbnail")
is_default: bool = Field(False, description="Whether this is the default theme")
class ThemeMetadata(BaseModel):
"""Metadata for a single theme in the registry."""
id: str
name: str
description: str
is_default: bool = False
created_at: Optional[datetime] = None
class ThemeRegistry(BaseModel):
"""Registry of all available themes, stored as _metadata.json in GCS."""
version: int = 1
themes: List[ThemeMetadata] = Field(default_factory=list)
class ThemeDetail(BaseModel):
"""Full theme details including style parameters."""
id: str
name: str
description: str
preview_url: Optional[str] = None
is_default: bool = False
style_params: Dict[str, Any] = Field(default_factory=dict)
has_youtube_description: bool = False
class ColorOverrides(BaseModel):
"""
User-customizable color overrides that can be applied on top of a theme.
All colors are hex format (#RRGGBB). When applied:
- artist_color: Applied to intro.artist_color, end.artist_color, cdg.artist_color
- title_color: Applied to intro.title_color, end.title_color, cdg.title_color
- sung_lyrics_color: Applied to karaoke.primary_color (converted to RGBA), cdg.active_fill
- unsung_lyrics_color: Applied to karaoke.secondary_color (converted to RGBA), cdg.inactive_fill
"""
artist_color: Optional[str] = Field(
None,
pattern=r"^#[0-9A-Fa-f]{6}$",
description="Hex color for artist name on intro/end screens",
)
title_color: Optional[str] = Field(
None,
pattern=r"^#[0-9A-Fa-f]{6}$",
description="Hex color for song title on intro/end screens",
)
sung_lyrics_color: Optional[str] = Field(
None,
pattern=r"^#[0-9A-Fa-f]{6}$",
description="Hex color for lyrics being sung (highlighted)",
)
unsung_lyrics_color: Optional[str] = Field(
None,
pattern=r"^#[0-9A-Fa-f]{6}$",
description="Hex color for lyrics not yet sung",
)
def has_overrides(self) -> bool:
"""Check if any color overrides are set."""
return any(
[
self.artist_color,
self.title_color,
self.sung_lyrics_color,
self.unsung_lyrics_color,
]
)
def to_dict(self) -> Dict[str, str]:
"""Convert to dict, excluding None values."""
return {k: v for k, v in self.model_dump().items() if v is not None}
class ThemesListResponse(BaseModel):
"""Response from GET /api/themes endpoint."""
themes: List[ThemeSummary]
class ThemeDetailResponse(BaseModel):
"""Response from GET /api/themes/{theme_id} endpoint."""
theme: ThemeDetail
# Utility functions for color conversion
def hex_to_rgba(hex_color: str, alpha: int = 255) -> str:
"""
Convert hex color (#RRGGBB) to RGBA format for ASS subtitles.
ASS subtitle format uses "R, G, B, A" string format.
Args:
hex_color: Hex color string like "#7070F7"
alpha: Alpha value 0-255 (default 255 = opaque)
Returns:
RGBA string like "112, 112, 247, 255"
"""
hex_color = hex_color.lstrip("#")
r = int(hex_color[0:2], 16)
g = int(hex_color[2:4], 16)
b = int(hex_color[4:6], 16)
return f"{r}, {g}, {b}, {alpha}"
def rgba_to_hex(rgba_str: str) -> str:
"""
Convert RGBA format to hex color.
Args:
rgba_str: RGBA string like "112, 112, 247, 255"
Returns:
Hex color string like "#7070F7"
"""
parts = [int(x.strip()) for x in rgba_str.split(",")]
r, g, b = parts[0], parts[1], parts[2]
return f"#{r:02x}{g:02x}{b:02x}"
-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
-164
View File
@@ -1,164 +0,0 @@
"""
Worker log entry model for subcollection storage.
This module defines the LogEntry model for storing worker logs in a Firestore
subcollection instead of an embedded array. This avoids the 1MB document size
limit that caused job 501258e1 to fail when logs reached 1.26 MB.
"""
from dataclasses import dataclass, field
from datetime import datetime, timezone, timedelta
from typing import Optional, Dict, Any
import uuid
# Default TTL for log entries (30 days)
DEFAULT_LOG_TTL_DAYS = 30
@dataclass
class WorkerLogEntry:
"""
Worker log entry for Firestore subcollection storage.
Stored at: jobs/{job_id}/logs/{log_id}
This model is separate from the legacy LogEntry (in job.py) which is
stored as an embedded array in the job document. This new model supports
the subcollection approach with TTL and richer metadata.
"""
# Core fields (required)
timestamp: datetime
level: str # "DEBUG", "INFO", "WARNING", "ERROR"
worker: str # "audio", "lyrics", "screens", "video", "render", "distribution"
message: str
# Identifiers
id: str = field(default_factory=lambda: str(uuid.uuid4()))
job_id: str = "" # Set when writing to Firestore
# TTL for automatic cleanup
ttl_expiry: datetime = field(
default_factory=lambda: datetime.now(timezone.utc) + timedelta(days=DEFAULT_LOG_TTL_DAYS)
)
# Optional metadata for debugging
metadata: Optional[Dict[str, Any]] = None
@classmethod
def create(
cls,
job_id: str,
worker: str,
level: str,
message: str,
metadata: Optional[Dict[str, Any]] = None,
ttl_days: int = DEFAULT_LOG_TTL_DAYS
) -> "WorkerLogEntry":
"""
Factory method to create a new log entry.
Args:
job_id: Job ID this log belongs to
worker: Worker name (audio, lyrics, screens, video, render, distribution)
level: Log level (DEBUG, INFO, WARNING, ERROR)
message: Log message (truncated to 1000 chars)
metadata: Optional additional metadata
ttl_days: Days until log expires (default 30)
Returns:
New WorkerLogEntry instance
"""
now = datetime.now(timezone.utc)
return cls(
id=str(uuid.uuid4()),
job_id=job_id,
timestamp=now,
level=level.upper(),
worker=worker,
message=message[:1000], # Truncate long messages
metadata=metadata,
ttl_expiry=now + timedelta(days=ttl_days)
)
def to_dict(self) -> Dict[str, Any]:
"""
Convert to dictionary for Firestore storage.
Returns:
Dictionary representation for Firestore
"""
result = {
"id": self.id,
"job_id": self.job_id,
"timestamp": self.timestamp,
"level": self.level,
"worker": self.worker,
"message": self.message,
"ttl_expiry": self.ttl_expiry
}
if self.metadata:
result["metadata"] = self.metadata
return result
def to_legacy_dict(self) -> Dict[str, Any]:
"""
Convert to legacy format for backward compatibility with API responses.
The existing API returns logs in this format:
{"timestamp": "...", "level": "INFO", "worker": "audio", "message": "..."}
Returns:
Dictionary in legacy format
"""
# Format timestamp: use "Z" suffix for UTC, isoformat() for others
if self.timestamp.tzinfo is None:
# Naive datetime - use as-is
timestamp_str = self.timestamp.isoformat()
elif self.timestamp.utcoffset() == timedelta(0):
# UTC datetime - replace +00:00 with Z for cleaner format
timestamp_str = self.timestamp.replace(tzinfo=None).isoformat() + "Z"
else:
# Non-UTC timezone-aware - use full isoformat with offset
timestamp_str = self.timestamp.isoformat()
return {
"timestamp": timestamp_str,
"level": self.level,
"worker": self.worker,
"message": self.message
}
@classmethod
def from_dict(cls, data: Dict[str, Any]) -> "WorkerLogEntry":
"""
Create from Firestore document data.
Args:
data: Dictionary from Firestore document
Returns:
WorkerLogEntry instance
"""
# Handle timestamp conversion (Firestore returns datetime objects)
timestamp = data.get("timestamp")
if isinstance(timestamp, str):
# Parse ISO format string
timestamp = datetime.fromisoformat(timestamp.rstrip("Z")).replace(tzinfo=timezone.utc)
ttl_expiry = data.get("ttl_expiry")
if isinstance(ttl_expiry, str):
ttl_expiry = datetime.fromisoformat(ttl_expiry.rstrip("Z")).replace(tzinfo=timezone.utc)
elif ttl_expiry is None:
# Default TTL if not set
ttl_expiry = datetime.now(timezone.utc) + timedelta(days=DEFAULT_LOG_TTL_DAYS)
return cls(
id=data.get("id", str(uuid.uuid4())),
job_id=data.get("job_id", ""),
timestamp=timestamp or datetime.now(timezone.utc),
level=data.get("level", "INFO"),
worker=data.get("worker", "unknown"),
message=data.get("message", ""),
metadata=data.get("metadata"),
ttl_expiry=ttl_expiry
)
-29
View File
@@ -1,29 +0,0 @@
[tool.pytest.ini_options]
testpaths = ["tests"]
python_files = ["test_*.py"]
python_classes = ["Test*"]
python_functions = ["test_*"]
addopts = [
"-v",
"--tb=short",
"--strict-markers",
"-ra",
]
markers = [
"slow: marks tests as slow (deselect with '-m \"not slow\"')",
"integration: marks tests as integration tests requiring live service",
]
# Timeout for slow tests (in seconds)
timeout = 300
[tool.coverage.run]
source = ["backend"]
omit = ["*/tests/*", "*/test_*"]
[tool.coverage.report]
precision = 2
show_missing = true
skip_covered = false
-93
View File
@@ -1,93 +0,0 @@
#!/bin/bash
# Quick syntax and structure check (no dependencies required)
# Run this before every deployment!
set -e
echo "🔍 Quick Backend Check (no dependencies required)"
echo "=================================================="
echo ""
# Change to backend directory
cd "$(dirname "$0")"
# Colors
RED='\033[0;31m'
GREEN='\033[0;32m'
NC='\033[0m'
ERRORS=0
# Check 1: Python syntax
echo "1. Checking Python syntax..."
for file in $(find . -name "*.py" -not -path "./__pycache__/*" -not -path "./venv/*"); do
if ! python3 -m py_compile "$file" 2>/dev/null; then
echo -e " ${RED}❌ Syntax error in $file${NC}"
python3 -m py_compile "$file"
ERRORS=$((ERRORS+1))
fi
done
if [ $ERRORS -eq 0 ]; then
echo -e " ${GREEN}✅ All Python files have valid syntax${NC}"
fi
# Check 2: No missing imports (basic check)
echo ""
echo "2. Checking for obvious import issues..."
# Check that we don't import deleted modules
if grep -r "from backend.services.processing_service import" --include="*.py" . 2>/dev/null; then
echo -e " ${RED}❌ Found import of deleted processing_service${NC}"
ERRORS=$((ERRORS+1))
else
echo -e " ${GREEN}✅ No imports of deleted modules${NC}"
fi
# Check 3: Required files exist
echo ""
echo "3. Checking required files exist..."
REQUIRED_FILES=(
"main.py"
"config.py"
"requirements.txt"
"Dockerfile"
"api/routes/health.py"
"api/routes/jobs.py"
"api/routes/internal.py"
"api/routes/file_upload.py"
"services/job_manager.py"
"services/firestore_service.py"
"services/storage_service.py"
"services/worker_service.py"
"services/auth_service.py"
"workers/audio_worker.py"
"workers/lyrics_worker.py"
"workers/screens_worker.py"
"workers/video_worker.py"
"models/job.py"
"models/requests.py"
)
for file in "${REQUIRED_FILES[@]}"; do
if [ ! -f "$file" ]; then
echo -e " ${RED}❌ Missing required file: $file${NC}"
ERRORS=$((ERRORS+1))
fi
done
if [ $ERRORS -eq 0 ]; then
echo -e " ${GREEN}✅ All required files exist${NC}"
fi
# Summary
echo ""
echo "=================================================="
if [ $ERRORS -eq 0 ]; then
echo -e "${GREEN}✅ All checks passed! Safe to deploy.${NC}"
exit 0
else
echo -e "${RED}❌ $ERRORS error(s) found. Fix before deploying!${NC}"
exit 1
fi
-29
View File
@@ -1,29 +0,0 @@
# DEPRECATED: This file is no longer used for Docker builds or CI.
# Docker and CI both use poetry/pyproject.toml directly.
# This file is kept for reference only.
fastapi>=0.104.0,<1.0.0
uvicorn[standard]>=0.24.0,<1.0.0
pydantic>=2.5.0,<3.0.0
pydantic-settings>=2.1.0,<3.0.0
python-multipart>=0.0.6,<1.0.0
httpx>=0.25.0,<1.0.0
google-cloud-firestore>=2.14.0,<3.0.0
google-cloud-storage>=2.14.0,<3.0.0
google-cloud-secret-manager>=2.18.0,<3.0.0
google-cloud-tasks>=2.14.0,<3.0.0
google-cloud-run>=0.10.0,<1.0.0
python-dotenv>=1.0.0,<2.0.0
# Audio processing (reuses karaoke_gen library)
audio-separator[remote]>=0.18.0 # Remote Modal API client
pydub>=0.25.1 # Audio manipulation (used by karaoke_gen)
yt-dlp>=2024.0.0 # YouTube downloads (future use)
# Cloud storage native APIs
dropbox>=11.0.0 # Dropbox Python SDK for native API access
# google-api-python-client already installed via karaoke_gen for YouTube
# karaoke-gen dependencies (will be installed from parent dir in Dockerfile)
# Using explicit dependencies instead of -e ../
-60
View File
@@ -1,60 +0,0 @@
#!/bin/bash
# Backend Test Runner
# Runs integration tests against the deployed Cloud Run service
set -e
echo "🧪 Backend Integration Test Suite"
echo "=================================="
echo ""
# Check prerequisites
echo "Checking prerequisites..."
if ! command -v gcloud &> /dev/null; then
echo "❌ gcloud CLI not found. Please install Google Cloud SDK."
exit 1
fi
if ! command -v pytest &> /dev/null; then
echo "❌ pytest not found. Installing test dependencies..."
pip install -r tests/requirements.txt
fi
# Verify authentication
echo "Verifying authentication..."
if ! gcloud auth print-identity-token &> /dev/null; then
echo "❌ Not authenticated with gcloud. Run: gcloud auth login"
exit 1
fi
echo "✅ Prerequisites met"
echo ""
# Run tests
echo "Running integration tests..."
echo ""
# Run fast tests (no slow marker)
echo "📝 Running fast tests..."
pytest tests/test_api_integration.py -v -m "not slow" --tb=short
echo ""
echo "✅ Fast tests complete!"
echo ""
# Ask if user wants to run slow tests
read -p "Run slow/integration tests? These test actual job processing (5-10 min). [y/N] " -n 1 -r
echo
if [[ $REPLY =~ ^[Yy]$ ]]; then
echo "🐌 Running slow integration tests..."
pytest tests/test_api_integration.py -v -m "slow" --tb=short
echo ""
echo "✅ All tests complete!"
else
echo "⏭️ Skipping slow tests"
fi
echo ""
echo "=================================="
echo "Test run complete! 🎉"
View File
Whitespace-only changes.
-243
View File
@@ -1,243 +0,0 @@
"""
Audio analysis service for analyzing backing vocals.
This service wraps the shared karaoke_gen.instrumental_review module
to provide GCS-integrated audio analysis capabilities.
"""
import logging
import os
import tempfile
from typing import Optional
from backend.services.storage_service import StorageService
from karaoke_gen.instrumental_review import (
AudioAnalyzer,
AnalysisResult,
WaveformGenerator,
)
logger = logging.getLogger(__name__)
class AudioAnalysisService:
"""
Service for analyzing backing vocals audio files stored in GCS.
This service acts as a thin wrapper around the shared AudioAnalyzer
and WaveformGenerator classes, handling GCS download/upload operations.
The actual analysis logic is in the shared karaoke_gen.instrumental_review
module, ensuring feature parity between local and remote workflows.
"""
def __init__(
self,
storage_service: Optional[StorageService] = None,
silence_threshold_db: float = -40.0,
min_segment_duration_ms: int = 100,
):
"""
Initialize the audio analysis service.
Args:
storage_service: GCS storage service. If not provided, a new
instance will be created.
silence_threshold_db: Threshold for considering audio as silent.
Default is -40.0 dB.
min_segment_duration_ms: Minimum duration for audible segments.
Default is 100ms.
"""
self.storage_service = storage_service or StorageService()
self.analyzer = AudioAnalyzer(
silence_threshold_db=silence_threshold_db,
min_segment_duration_ms=min_segment_duration_ms,
)
self.waveform_generator = WaveformGenerator()
def analyze_backing_vocals(
self,
gcs_audio_path: str,
job_id: str,
) -> AnalysisResult:
"""
Analyze a backing vocals audio file from GCS.
This method:
1. Downloads the audio file from GCS to a temp file
2. Runs the analysis using the shared AudioAnalyzer
3. Returns the analysis result
Args:
gcs_audio_path: Path to the audio file in GCS
job_id: Job ID for logging
Returns:
AnalysisResult containing analysis data
"""
logger.info(f"[{job_id}] Analyzing backing vocals: {gcs_audio_path}")
with tempfile.TemporaryDirectory() as temp_dir:
# Download audio file
local_audio_path = os.path.join(temp_dir, "backing_vocals.flac")
self.storage_service.download_file(gcs_audio_path, local_audio_path)
# Run analysis
result = self.analyzer.analyze(local_audio_path)
logger.info(
f"[{job_id}] Analysis complete: "
f"has_audible={result.has_audible_content}, "
f"segments={result.segment_count}, "
f"recommendation={result.recommended_selection.value}"
)
return result
def analyze_and_generate_waveform(
self,
gcs_audio_path: str,
job_id: str,
gcs_waveform_destination: str,
) -> tuple[AnalysisResult, str]:
"""
Analyze backing vocals and generate a waveform image.
This method:
1. Downloads the audio file from GCS
2. Runs analysis using AudioAnalyzer
3. Generates waveform image using WaveformGenerator
4. Uploads the waveform image to GCS
5. Returns analysis result and waveform GCS path
Args:
gcs_audio_path: Path to the audio file in GCS
job_id: Job ID for logging
gcs_waveform_destination: Where to upload the waveform image in GCS
Returns:
Tuple of (AnalysisResult, waveform_gcs_path)
"""
logger.info(f"[{job_id}] Analyzing and generating waveform: {gcs_audio_path}")
with tempfile.TemporaryDirectory() as temp_dir:
# Download audio file
local_audio_path = os.path.join(temp_dir, "backing_vocals.flac")
self.storage_service.download_file(gcs_audio_path, local_audio_path)
# Run analysis
result = self.analyzer.analyze(local_audio_path)
# Generate waveform
local_waveform_path = os.path.join(temp_dir, "waveform.png")
self.waveform_generator.generate(
audio_path=local_audio_path,
output_path=local_waveform_path,
segments=result.audible_segments,
show_time_axis=True,
silence_threshold_db=self.analyzer.silence_threshold_db,
)
# Upload waveform to GCS
self.storage_service.upload_file(
local_waveform_path,
gcs_waveform_destination
)
logger.info(
f"[{job_id}] Analysis and waveform generation complete. "
f"Waveform uploaded to: {gcs_waveform_destination}"
)
return result, gcs_waveform_destination
def get_waveform_data(
self,
gcs_audio_path: str,
job_id: str,
num_points: int = 500,
) -> tuple[list[float], float]:
"""
Get waveform data (amplitude envelope) for client-side rendering.
This is useful when the frontend wants to render the waveform
itself using Canvas or SVG, rather than displaying a pre-generated
image.
Args:
gcs_audio_path: Path to the audio file in GCS
job_id: Job ID for logging
num_points: Number of data points to return
Returns:
Tuple of (amplitude_values, duration_seconds)
"""
logger.info(f"[{job_id}] Getting waveform data: {gcs_audio_path}")
with tempfile.TemporaryDirectory() as temp_dir:
# Download audio file
local_audio_path = os.path.join(temp_dir, "backing_vocals.flac")
self.storage_service.download_file(gcs_audio_path, local_audio_path)
# Generate waveform data
amplitudes, duration = self.waveform_generator.generate_data_only(
audio_path=local_audio_path,
num_points=num_points,
)
return amplitudes, duration
def generate_waveform_with_mutes(
self,
gcs_audio_path: str,
job_id: str,
gcs_waveform_destination: str,
mute_regions: list,
) -> str:
"""
Generate a waveform image with mute regions highlighted.
This is useful for showing the user which regions will be muted
in the custom instrumental.
Args:
gcs_audio_path: Path to the audio file in GCS
job_id: Job ID for logging
gcs_waveform_destination: Where to upload the waveform image
mute_regions: List of MuteRegion objects to highlight
Returns:
GCS path to the uploaded waveform image
"""
from karaoke_gen.instrumental_review import MuteRegion
logger.info(
f"[{job_id}] Generating waveform with {len(mute_regions)} mute regions"
)
with tempfile.TemporaryDirectory() as temp_dir:
# Download audio file
local_audio_path = os.path.join(temp_dir, "backing_vocals.flac")
self.storage_service.download_file(gcs_audio_path, local_audio_path)
# First run analysis to get segments
result = self.analyzer.analyze(local_audio_path)
# Generate waveform with mute regions
local_waveform_path = os.path.join(temp_dir, "waveform_with_mutes.png")
self.waveform_generator.generate(
audio_path=local_audio_path,
output_path=local_waveform_path,
segments=result.audible_segments,
mute_regions=mute_regions,
show_time_axis=True,
)
# Upload to GCS
self.storage_service.upload_file(
local_waveform_path,
gcs_waveform_destination
)
return gcs_waveform_destination
-278
View File
@@ -1,278 +0,0 @@
"""
Audio editing service for creating custom instrumentals.
This service wraps the shared karaoke_gen.instrumental_review module
to provide GCS-integrated audio editing capabilities.
"""
import logging
import os
import tempfile
from typing import List, Optional
from backend.services.storage_service import StorageService
from karaoke_gen.instrumental_review import (
AudioEditor,
MuteRegion,
)
from karaoke_gen.instrumental_review.models import CustomInstrumentalResult
logger = logging.getLogger(__name__)
class AudioEditingService:
"""
Service for creating custom instrumental tracks with GCS integration.
This service acts as a thin wrapper around the shared AudioEditor
class, handling GCS download/upload operations.
The actual editing logic is in the shared karaoke_gen.instrumental_review
module, ensuring feature parity between local and remote workflows.
"""
def __init__(
self,
storage_service: Optional[StorageService] = None,
output_format: str = "flac",
):
"""
Initialize the audio editing service.
Args:
storage_service: GCS storage service. If not provided, a new
instance will be created.
output_format: Output audio format. Default is "flac".
"""
self.storage_service = storage_service or StorageService()
self.editor = AudioEditor(output_format=output_format)
def create_custom_instrumental(
self,
gcs_clean_instrumental_path: str,
gcs_backing_vocals_path: str,
mute_regions: List[MuteRegion],
gcs_output_path: str,
job_id: str,
) -> CustomInstrumentalResult:
"""
Create a custom instrumental by muting regions of backing vocals.
This method:
1. Downloads clean instrumental and backing vocals from GCS
2. Applies mute regions to backing vocals
3. Combines with clean instrumental
4. Uploads result to GCS
Args:
gcs_clean_instrumental_path: Path to clean instrumental in GCS
gcs_backing_vocals_path: Path to backing vocals in GCS
mute_regions: List of regions to mute in backing vocals
gcs_output_path: Where to upload the custom instrumental in GCS
job_id: Job ID for logging
Returns:
CustomInstrumentalResult with details about the created file
"""
logger.info(
f"[{job_id}] Creating custom instrumental with "
f"{len(mute_regions)} mute regions"
)
with tempfile.TemporaryDirectory() as temp_dir:
# Download input files
local_clean_path = os.path.join(temp_dir, "clean_instrumental.flac")
local_backing_path = os.path.join(temp_dir, "backing_vocals.flac")
local_output_path = os.path.join(temp_dir, "custom_instrumental.flac")
logger.debug(f"[{job_id}] Downloading clean instrumental")
self.storage_service.download_file(
gcs_clean_instrumental_path,
local_clean_path
)
logger.debug(f"[{job_id}] Downloading backing vocals")
self.storage_service.download_file(
gcs_backing_vocals_path,
local_backing_path
)
# Create custom instrumental using shared editor
result = self.editor.create_custom_instrumental(
clean_instrumental_path=local_clean_path,
backing_vocals_path=local_backing_path,
mute_regions=mute_regions,
output_path=local_output_path,
)
# Upload result to GCS
logger.debug(f"[{job_id}] Uploading custom instrumental to GCS")
self.storage_service.upload_file(local_output_path, gcs_output_path)
# Update result with GCS path
result.output_path = gcs_output_path
logger.info(
f"[{job_id}] Custom instrumental created: {gcs_output_path}, "
f"muted {result.total_muted_duration_seconds:.1f}s across "
f"{len(result.mute_regions_applied)} regions"
)
return result
def create_preview(
self,
gcs_clean_instrumental_path: str,
gcs_backing_vocals_path: str,
mute_regions: List[MuteRegion],
gcs_preview_path: str,
job_id: str,
preview_duration_seconds: Optional[float] = None,
) -> str:
"""
Create a preview of the custom instrumental.
This is similar to create_custom_instrumental but optimized for
quick preview generation (optionally truncated duration).
Args:
gcs_clean_instrumental_path: Path to clean instrumental in GCS
gcs_backing_vocals_path: Path to backing vocals in GCS
mute_regions: List of regions to mute
gcs_preview_path: Where to upload the preview in GCS
job_id: Job ID for logging
preview_duration_seconds: Optional max duration for preview
Returns:
GCS path to the uploaded preview
"""
logger.info(f"[{job_id}] Creating preview with {len(mute_regions)} mute regions")
with tempfile.TemporaryDirectory() as temp_dir:
# Download input files
local_clean_path = os.path.join(temp_dir, "clean_instrumental.flac")
local_backing_path = os.path.join(temp_dir, "backing_vocals.flac")
local_preview_path = os.path.join(temp_dir, "preview.flac")
self.storage_service.download_file(
gcs_clean_instrumental_path,
local_clean_path
)
self.storage_service.download_file(
gcs_backing_vocals_path,
local_backing_path
)
# Generate preview
from pydub import AudioSegment
preview = self.editor.preview_with_mutes(
clean_instrumental_path=local_clean_path,
backing_vocals_path=local_backing_path,
mute_regions=mute_regions,
)
# Optionally truncate
if preview_duration_seconds:
max_ms = int(preview_duration_seconds * 1000)
preview = preview[:max_ms]
# Export and upload
preview.export(local_preview_path, format="flac")
self.storage_service.upload_file(local_preview_path, gcs_preview_path)
logger.info(f"[{job_id}] Preview created: {gcs_preview_path}")
return gcs_preview_path
def mute_backing_vocals_only(
self,
gcs_backing_vocals_path: str,
mute_regions: List[MuteRegion],
gcs_output_path: str,
job_id: str,
) -> str:
"""
Apply mute regions to backing vocals without combining with instrumental.
This is useful for creating an edited backing vocals track that
can be combined with the instrumental later.
Args:
gcs_backing_vocals_path: Path to backing vocals in GCS
mute_regions: List of regions to mute
gcs_output_path: Where to upload the edited backing vocals
job_id: Job ID for logging
Returns:
GCS path to the uploaded edited backing vocals
"""
logger.info(
f"[{job_id}] Muting backing vocals with {len(mute_regions)} regions"
)
with tempfile.TemporaryDirectory() as temp_dir:
local_backing_path = os.path.join(temp_dir, "backing_vocals.flac")
local_output_path = os.path.join(temp_dir, "muted_backing.flac")
self.storage_service.download_file(
gcs_backing_vocals_path,
local_backing_path
)
self.editor.apply_mute_to_single_track(
audio_path=local_backing_path,
mute_regions=mute_regions,
output_path=local_output_path,
)
self.storage_service.upload_file(local_output_path, gcs_output_path)
logger.info(f"[{job_id}] Muted backing vocals: {gcs_output_path}")
return gcs_output_path
def validate_mute_regions(
self,
mute_regions: List[MuteRegion],
total_duration_seconds: float,
) -> List[str]:
"""
Validate mute regions for consistency.
Args:
mute_regions: List of mute regions to validate
total_duration_seconds: Total duration of the audio
Returns:
List of validation error messages (empty if valid)
"""
errors = []
for i, region in enumerate(mute_regions):
if region.start_seconds < 0:
errors.append(
f"Region {i}: start_seconds ({region.start_seconds}) cannot be negative"
)
if region.end_seconds <= region.start_seconds:
errors.append(
f"Region {i}: end_seconds ({region.end_seconds}) must be after "
f"start_seconds ({region.start_seconds})"
)
if region.start_seconds > total_duration_seconds:
errors.append(
f"Region {i}: start_seconds ({region.start_seconds}) exceeds "
f"audio duration ({total_duration_seconds})"
)
if region.end_seconds > total_duration_seconds:
# Not an error, but log a warning - the region will be clamped
logger.warning(
f"Region {i}: end_seconds ({region.end_seconds}) exceeds "
f"audio duration ({total_duration_seconds}), will be clamped"
)
return errors
-702
View File
@@ -1,702 +0,0 @@
"""
Audio search service for finding and downloading audio files.
This service integrates with karaoke_gen.audio_fetcher (which wraps flacfetch)
to search for audio from various sources (YouTube, music trackers, etc.)
and download the selected audio file.
This is a thin wrapper that adds backend-specific functionality:
- Caching raw results for API-based selection flow
- Firestore-compatible serialization
- Singleton pattern for service lifecycle
- Remote flacfetch service integration for torrent downloads
When FLACFETCH_API_URL is configured, this service uses the remote flacfetch
HTTP API for search and download operations. This is required for torrent
downloads since Cloud Run doesn't support BitTorrent peer connections.
"""
import asyncio
import logging
import os
from typing import List, Optional
import nest_asyncio
# Import shared classes from karaoke_gen.audio_fetcher - single source of truth
# Note: Import directly from audio_fetcher module, not karaoke_gen.__init__
# to avoid pulling in heavier dependencies like lyrics_transcriber
from karaoke_gen.audio_fetcher import (
FlacFetcher,
AudioSearchResult,
AudioFetchResult,
AudioFetcherError,
NoResultsError,
DownloadError,
)
from .flacfetch_client import get_flacfetch_client, FlacfetchServiceError
logger = logging.getLogger(__name__)
# Re-export exception under backend's naming convention for compatibility
AudioSearchError = AudioFetcherError
# Also alias AudioFetchResult as AudioDownloadResult for backwards compatibility
AudioDownloadResult = AudioFetchResult
class AudioSearchService:
"""
Service for searching and downloading audio files.
This is a thin wrapper around karaoke_gen.audio_fetcher.FlacFetcher that adds
backend-specific functionality:
- Caches raw results for API-based selection (client picks by index)
- Provides Firestore-compatible serialization
- Manages service lifecycle as singleton
- Remote flacfetch service integration for torrent downloads
When FLACFETCH_API_URL is configured, this service uses the remote flacfetch
HTTP API for search and download operations. This enables torrent downloads
which are not possible in Cloud Run due to network restrictions.
The actual flacfetch integration is in karaoke_gen.audio_fetcher.FlacFetcher,
which is shared between local CLI and cloud backend.
"""
# Sentinel value to indicate "use environment variable"
_USE_ENV = object()
def __init__(
self,
red_api_key: Optional[str] = _USE_ENV,
red_api_url: Optional[str] = _USE_ENV,
ops_api_key: Optional[str] = _USE_ENV,
ops_api_url: Optional[str] = _USE_ENV,
):
"""
Initialize the audio search service.
Args:
red_api_key: API key for RED tracker (optional, uses env if not provided)
red_api_url: Base URL for RED tracker API (optional, uses env if not provided)
ops_api_key: API key for OPS tracker (optional, uses env if not provided)
ops_api_url: Base URL for OPS tracker API (optional, uses env if not provided)
"""
# Use environment variables if not explicitly provided
if red_api_key is self._USE_ENV:
red_api_key = os.environ.get("RED_API_KEY")
if red_api_url is self._USE_ENV:
red_api_url = os.environ.get("RED_API_URL")
if ops_api_key is self._USE_ENV:
ops_api_key = os.environ.get("OPS_API_KEY")
if ops_api_url is self._USE_ENV:
ops_api_url = os.environ.get("OPS_API_URL")
# Check for remote flacfetch client
self._remote_client = get_flacfetch_client()
# Log which mode we're using
if self._remote_client:
logger.info("AudioSearchService using REMOTE flacfetch service (torrent downloads enabled)")
else:
logger.info("AudioSearchService using LOCAL flacfetch (YouTube only in Cloud Run)")
# Delegate to shared FlacFetcher implementation (for local mode or fallback)
self._fetcher = FlacFetcher(
red_api_key=red_api_key,
red_api_url=red_api_url,
ops_api_key=ops_api_key,
ops_api_url=ops_api_url,
)
# Cache search results for API-based selection flow
# Key: index, Value: AudioSearchResult (with raw_result)
self._cached_results: List[AudioSearchResult] = []
# Cache for remote search results (search_id -> results)
self._remote_search_id: Optional[str] = None
def search(self, artist: str, title: str) -> List[AudioSearchResult]:
"""
Search for audio matching the given artist and title.
Results are cached internally for later download via download().
If a remote flacfetch service is configured (FLACFETCH_API_URL), uses that
for better torrent download support. Otherwise falls back to local flacfetch.
Args:
artist: The artist name to search for
title: The track title to search for
Returns:
List of AudioSearchResult objects
Raises:
NoResultsError: If no results are found
AudioSearchError: For other errors (e.g., flacfetch not installed)
"""
try:
# Try remote flacfetch service first if configured
if self._remote_client:
return self._search_remote(artist, title)
# Fallback to local flacfetch
results = self._fetcher.search(artist, title)
# Cache results for later download
self._cached_results = results
self._remote_search_id = None
logger.info(f"Found {len(results)} results for: {artist} - {title}")
return results
except (NoResultsError, AudioFetcherError):
# Re-raise these as-is
raise
except Exception as e:
logger.error(f"Search failed: {e}")
raise AudioSearchError(f"Search failed: {e}") from e
def _search_remote(self, artist: str, title: str) -> List[AudioSearchResult]:
"""
Search using the remote flacfetch service.
Runs async code in a sync context for compatibility with existing API.
"""
try:
# Enable nested event loops (needed when called from FastAPI async context)
# Apply to the current loop if one exists, otherwise it's a no-op
try:
loop = asyncio.get_running_loop()
nest_asyncio.apply(loop)
except RuntimeError:
pass # No running loop, nest_asyncio not needed
# Run async search in sync context
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
try:
response = loop.run_until_complete(
self._remote_client.search(artist, title)
)
finally:
loop.close()
# Check for empty results
if not response.get("results"):
raise NoResultsError(f"No results found for: {artist} - {title}")
# Store search_id for download
self._remote_search_id = response.get("search_id")
# Convert remote results to AudioSearchResult objects
results = []
for item in response.get("results", []):
result = AudioSearchResult(
title=item.get("title", "Unknown"),
artist=item.get("artist", "Unknown"),
url=item.get("download_url", ""), # May be empty for remote
provider=item.get("provider", "Unknown"),
duration=item.get("duration_seconds"),
quality=item.get("quality", ""),
source_id=item.get("info_hash"),
index=item.get("index", 0),
seeders=item.get("seeders"),
target_file=item.get("target_file"),
# Store full remote data in raw_result for rich display
raw_result=item,
)
results.append(result)
# Cache results
self._cached_results = results
logger.info(f"Found {len(results)} results from remote flacfetch for: {artist} - {title}")
return results
except FlacfetchServiceError as e:
logger.warning(f"Remote flacfetch search failed, falling back to local: {e}")
# Fallback to local search
self._remote_search_id = None
results = self._fetcher.search(artist, title)
self._cached_results = results
return results
def select_best(self, results: List[AudioSearchResult]) -> int:
"""
Select the best result from a list of search results.
Uses flacfetch's built-in quality ranking to select the best source.
Args:
results: List of search results
Returns:
Index of the best result
"""
return self._fetcher.select_best(results)
def download(
self,
result_index: int,
output_dir: str,
output_filename: Optional[str] = None,
gcs_path: Optional[str] = None,
remote_search_id: Optional[str] = None,
) -> AudioDownloadResult:
"""
Download audio from a cached search result.
This method uses the cached results from the last search() call.
The API flow is:
1. Client calls search() -> gets list of results
2. Client picks an index
3. Client calls download(index) -> gets downloaded file
If a remote flacfetch service is configured and the search was performed
remotely (for torrent sources), uses the remote service for download.
Args:
result_index: Index of the result to download (from search results)
output_dir: Directory to save the downloaded file
output_filename: Optional filename (without extension)
gcs_path: Optional GCS path for remote uploads (e.g., "uploads/job123/audio/")
remote_search_id: Optional search_id for remote downloads. If provided,
uses this instead of the cached _remote_search_id. This is important
for concurrent requests where the service-level cache may be stale.
Returns:
AudioDownloadResult with the downloaded file path
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."
)
result = self._cached_results[result_index]
logger.info(f"Downloading: {result.artist} - {result.title} from {result.provider}")
# 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
is_torrent = result.provider in ["RED", "OPS"]
if is_torrent:
return self._download_remote(result_index, output_dir, output_filename, gcs_path, effective_search_id)
# Delegate to shared FlacFetcher (local download)
fetch_result = self._fetcher.download(result, output_dir, output_filename)
logger.info(f"Downloaded to: {fetch_result.filepath}")
return fetch_result
def download_by_id(
self,
source_name: str,
source_id: str,
output_dir: str,
output_filename: Optional[str] = None,
target_file: Optional[str] = None,
download_url: Optional[str] = None,
gcs_path: Optional[str] = None,
) -> AudioDownloadResult:
"""
Download audio directly by source ID (no prior search required).
This is the preferred method when you have stored the source_id from a
previous search and want to download later without re-searching. This
avoids unnecessary API calls to private trackers.
Args:
source_name: Provider name (RED, OPS, YouTube, Spotify)
source_id: Source-specific ID (torrent ID, video ID, track ID)
output_dir: Directory to save the downloaded file
output_filename: Optional filename (without extension)
target_file: For torrents, specific file to extract from the torrent
download_url: For YouTube/Spotify, direct URL (optional)
gcs_path: Optional GCS path for remote uploads
Returns:
AudioDownloadResult with the downloaded file path
Raises:
DownloadError: If download fails
"""
logger.info(f"Download by ID: {source_name} ID={source_id}")
# For torrent sources, must use remote client
if source_name in ["RED", "OPS"]:
if not self._remote_client:
raise DownloadError(
f"Cannot download from {source_name} without remote flacfetch service"
)
return self._download_by_id_remote(
source_name=source_name,
source_id=source_id,
output_dir=output_dir,
output_filename=output_filename,
target_file=target_file,
download_url=download_url,
gcs_path=gcs_path,
)
# For YouTube/Spotify, can use local flacfetch via FetchManager.download_by_id
# But we currently only have remote support, so use remote if available
if self._remote_client:
return self._download_by_id_remote(
source_name=source_name,
source_id=source_id,
output_dir=output_dir,
output_filename=output_filename,
target_file=target_file,
download_url=download_url,
gcs_path=gcs_path,
)
# Local download for YouTube/Spotify (fallback)
# Use the local fetcher's download_by_id if available
raise DownloadError(
f"Local download_by_id not yet implemented for {source_name}. "
"Configure FLACFETCH_API_URL for remote downloads."
)
def _download_by_id_remote(
self,
source_name: str,
source_id: str,
output_dir: str, # Not used for remote downloads (files go to GCS or remote server)
output_filename: Optional[str] = None,
target_file: Optional[str] = None,
download_url: Optional[str] = None,
gcs_path: Optional[str] = None,
) -> AudioDownloadResult:
"""
Download by ID using the remote flacfetch service.
Note: output_dir is accepted for API compatibility but ignored for remote
downloads. Remote downloads either go to GCS (if gcs_path is set) or to
the remote server's download directory.
"""
# output_dir is intentionally unused - remote downloads don't use local paths
_ = output_dir
try:
# Enable nested event loops
try:
running_loop = asyncio.get_running_loop()
nest_asyncio.apply(running_loop)
except RuntimeError:
pass
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
try:
# Start download
download_id = loop.run_until_complete(
self._remote_client.download_by_id(
source_name=source_name,
source_id=source_id,
output_filename=output_filename,
target_file=target_file,
download_url=download_url,
gcs_path=gcs_path,
)
)
logger.info(f"Remote download by ID started: {download_id}")
# Wait for completion
def log_progress(status):
progress = status.get("progress", 0)
speed = status.get("download_speed_kbps", 0)
logger.debug(f"Download progress: {progress:.1f}% ({speed:.1f} KB/s)")
final_status = loop.run_until_complete(
self._remote_client.wait_for_download(
download_id,
timeout=600,
progress_callback=log_progress,
)
)
finally:
loop.close()
# Determine file path
filepath = final_status.get("gcs_path") or final_status.get("output_path")
if not filepath:
raise DownloadError("Remote download completed but no file path returned")
logger.info(f"Remote download by ID complete: {filepath}")
return AudioDownloadResult(
filepath=filepath,
artist="", # Not available without search
title="", # Not available without search
provider=source_name,
quality="", # Not available without search
)
except FlacfetchServiceError as e:
raise DownloadError(f"Remote download by ID failed: {e}") from e
except Exception as e:
logger.error(f"Remote download by ID error: {e}")
raise DownloadError(f"Remote download by ID failed: {e}") from e
def _download_remote(
self,
result_index: int,
output_dir: str,
output_filename: Optional[str] = None,
gcs_path: Optional[str] = None,
search_id: Optional[str] = None,
) -> AudioDownloadResult:
"""
Download using the remote flacfetch service.
The remote service downloads via torrent and optionally uploads to GCS.
Args:
result_index: Index of the result to download
output_dir: Directory to save downloaded file
output_filename: Optional filename
gcs_path: Optional GCS path for remote uploads
search_id: Remote search ID to use (overrides self._remote_search_id)
"""
effective_search_id = search_id or self._remote_search_id
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]
try:
# Enable nested event loops (needed when called from FastAPI async context)
try:
running_loop = asyncio.get_running_loop()
nest_asyncio.apply(running_loop)
except RuntimeError:
pass # No running loop, nest_asyncio not needed
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
try:
# Start download
download_id = loop.run_until_complete(
self._remote_client.download(
search_id=effective_search_id,
result_index=result_index,
output_filename=output_filename,
gcs_path=gcs_path,
)
)
logger.info(f"Remote download started: {download_id}")
# Wait for completion with progress logging
def log_progress(status):
progress = status.get("progress", 0)
speed = status.get("download_speed_kbps", 0)
logger.debug(f"Download progress: {progress:.1f}% ({speed:.1f} KB/s)")
final_status = loop.run_until_complete(
self._remote_client.wait_for_download(
download_id,
timeout=600, # 10 minute timeout
progress_callback=log_progress,
)
)
finally:
loop.close()
# Determine file path
filepath = final_status.get("gcs_path") or final_status.get("output_path")
if not filepath:
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 "",
)
except FlacfetchServiceError as e:
raise DownloadError(f"Remote download failed: {e}") from e
except Exception as e:
logger.error(f"Remote download error: {e}")
raise DownloadError(f"Remote download failed: {e}") from e
def search_and_download_auto(
self,
artist: str,
title: str,
output_dir: str,
output_filename: Optional[str] = None,
gcs_path: Optional[str] = None,
) -> AudioDownloadResult:
"""
Search for audio and automatically download the best result.
This is a convenience method that combines search(), select_best(),
and download() for automated/non-interactive usage.
Args:
artist: The artist name to search for
title: The track title to search for
output_dir: Directory to save the downloaded file
output_filename: Optional filename (without extension)
gcs_path: Optional GCS path for remote uploads
Returns:
AudioDownloadResult with the downloaded file path
Raises:
NoResultsError: If no results are found
DownloadError: If download fails
"""
# Search
results = self.search(artist, title)
# Select best
best_index = self.select_best(results)
best_result = results[best_index]
logger.info(
f"Auto-selected result {best_index}: "
f"{best_result.artist} - {best_result.title} ({best_result.provider})"
)
# Download
return self.download(best_index, output_dir, output_filename, gcs_path)
async def search_async(self, artist: str, title: str) -> List[AudioSearchResult]:
"""
Async version of search for use in async routes.
Note: Currently wraps sync search in executor. Future optimization
could make this fully async.
"""
loop = asyncio.get_event_loop()
return await loop.run_in_executor(None, self.search, artist, title)
async def download_async(
self,
result_index: int,
output_dir: str,
output_filename: Optional[str] = None,
gcs_path: Optional[str] = None,
remote_search_id: Optional[str] = None,
) -> AudioDownloadResult:
"""
Async version of download for use in async routes.
Note: Currently wraps sync download in executor. Future optimization
could make this fully async.
"""
loop = asyncio.get_event_loop()
return await loop.run_in_executor(
None,
lambda: self.download(result_index, output_dir, output_filename, gcs_path, remote_search_id)
)
async def download_by_id_async(
self,
source_name: str,
source_id: str,
output_dir: str,
output_filename: Optional[str] = None,
target_file: Optional[str] = None,
download_url: Optional[str] = None,
gcs_path: Optional[str] = None,
) -> AudioDownloadResult:
"""
Async version of download_by_id for use in async routes.
"""
loop = asyncio.get_event_loop()
return await loop.run_in_executor(
None,
lambda: self.download_by_id(
source_name, source_id, output_dir, output_filename,
target_file, download_url, gcs_path
)
)
def is_remote_enabled(self) -> bool:
"""Check if remote flacfetch service is configured."""
return self._remote_client is not None
@property
def last_remote_search_id(self) -> Optional[str]:
"""Get the search_id from the last remote search.
This should be stored in job state_data after search and passed
back to download() to ensure correct remote download handling.
"""
return self._remote_search_id
async def check_remote_health(self) -> Optional[dict]:
"""
Check health of remote flacfetch service.
Returns:
Health status dict if remote service is configured and healthy,
None if not configured or unhealthy.
"""
if not self._remote_client:
return None
try:
return await self._remote_client.health_check()
except Exception as e:
logger.warning(f"Remote flacfetch health check failed: {e}")
return None
# Singleton instance
_audio_search_service: Optional[AudioSearchService] = None
def get_audio_search_service() -> AudioSearchService:
"""Get the singleton AudioSearchService instance."""
global _audio_search_service
if _audio_search_service is None:
_audio_search_service = AudioSearchService()
return _audio_search_service
-630
View File
@@ -1,630 +0,0 @@
"""
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
- Usage tracking and limits
- Token management API
"""
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 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)
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:
logger.warning("No admin tokens configured! Set ADMIN_TOKENS environment variable.")
def validate_token(self, token: str) -> Tuple[bool, UserType, int, str]:
"""
Validate an access token.
Returns:
(is_valid, user_type, remaining_uses, message)
remaining_uses: -1 = unlimited, 0 = exhausted, >0 = remaining count
"""
if not token:
return False, UserType.LIMITED, 0, "No token provided"
# Check for admin tokens (highest priority)
if token in self.admin_tokens:
logger.info("Admin token validated")
return True, UserType.ADMIN, -1, "Admin access granted"
# Debug: Log token comparison info (only first/last few chars for security)
if self.admin_tokens:
expected_prefix = self.admin_tokens[0][:8] if len(self.admin_tokens[0]) >= 8 else self.admin_tokens[0]
provided_prefix = token[:8] if len(token) >= 8 else token
logger.debug(
f"Token mismatch: expected prefix '{expected_prefix}...', "
f"got '{provided_prefix}...', "
f"expected len={len(self.admin_tokens[0])}, got len={len(token)}"
)
# 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)
# 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
if not token_data.get("active", True):
return False, UserType(token_data["type"]), 0, "Token has been revoked"
token_type = UserType(token_data["type"])
max_uses = token_data.get("max_uses", -1)
# UNLIMITED tokens: no usage limits
if token_type == UserType.UNLIMITED:
return True, token_type, -1, "Unlimited access granted"
# LIMITED tokens: check usage count
if token_type == UserType.LIMITED:
if max_uses <= 0: # -1 means unlimited
return True, token_type, -1, "Limited token with unlimited uses"
current_uses = token_data.get("usage_count", 0)
remaining = max_uses - current_uses
if remaining <= 0:
return False, token_type, 0, "Token usage limit exceeded"
return True, token_type, remaining, f"Limited token: {remaining} uses remaining"
# STRIPE tokens: check expiration and usage
if token_type == UserType.STRIPE:
expires_at = token_data.get("expires_at")
if expires_at:
# expires_at is stored as timestamp
if time.time() > expires_at:
return False, token_type, 0, "Token has expired"
if max_uses > 0:
current_uses = token_data.get("usage_count", 0)
remaining = max_uses - current_uses
if remaining <= 0:
return False, token_type, 0, "Token usage limit exceeded"
return True, token_type, remaining, f"Stripe token: {remaining} uses remaining"
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
try:
self.firestore.increment_token_usage(token, job_id)
logger.info(f"Incremented usage for token (remaining: {remaining_uses - 1})")
return True
except Exception as e:
logger.error(f"Failed to increment token usage: {e}")
return False
def create_token(
self,
token_value: str,
token_type: UserType,
max_uses: int = -1,
expires_at: Optional[float] = None,
created_by: Optional[str] = None
) -> Dict[str, Any]:
"""
Create a new access token.
Args:
token_value: The actual token string (should be secure random string)
token_type: Type of access (admin, unlimited, limited, stripe)
max_uses: Maximum number of uses (-1 = unlimited)
expires_at: Expiration timestamp (None = no expiration)
created_by: Admin token that created this token
Returns:
Token data dictionary
"""
token_data = {
"token": token_value,
"type": token_type.value,
"max_uses": max_uses,
"usage_count": 0,
"active": True,
"created_at": time.time(),
"created_by": created_by,
"expires_at": expires_at,
"jobs": []
}
self.firestore.create_token(token_value, token_data)
logger.info(f"Created new {token_type} token with max_uses={max_uses}")
return token_data
def revoke_token(self, token: str, revoked_by: Optional[str] = None) -> bool:
"""
Revoke an access token.
Args:
token: The token to revoke
revoked_by: Admin token that revoked this token
Returns:
True if revoked, False if token not found
"""
try:
self.firestore.update_token(token, {
"active": False,
"revoked_at": time.time(),
"revoked_by": revoked_by
})
logger.info(f"Revoked token")
return True
except Exception as e:
logger.error(f"Failed to revoke token: {e}")
return False
def list_tokens(self, include_inactive: bool = False) -> list:
"""
List all tokens (admin only).
Args:
include_inactive: Whether to include revoked tokens
Returns:
List of token data dictionaries (with sensitive data masked)
"""
try:
tokens = self.firestore.list_tokens()
# Filter inactive if requested
if not include_inactive:
tokens = [t for t in tokens if t.get("active", True)]
# Mask token values for security (show only first 8 chars)
for token in tokens:
if "token" in token and len(token["token"]) > 8:
token["token"] = token["token"][:8] + "..."
return tokens
except Exception as e:
logger.error(f"Failed to list tokens: {e}")
return []
def get_token_info(self, token: str) -> Optional[Dict[str, Any]]:
"""
Get information about a token (for admin dashboard).
Returns:
Token data or None if not found
"""
# Check if it's an admin token (not stored in Firestore)
if token in self.admin_tokens:
return {
"token": token[:8] + "...",
"type": UserType.ADMIN.value,
"max_uses": -1,
"usage_count": 0,
"active": True,
"source": "environment"
}
# Get from Firestore
token_data = self.firestore.get_token(token)
if token_data and "token" in token_data:
# Mask the full token value
token_data["token"] = token_data["token"][:8] + "..."
return token_data
# Global instance
_auth_service = None
def get_auth_service() -> AuthService:
"""Get the global auth service instance."""
global _auth_service
if _auth_service is None:
_auth_service = AuthService()
return _auth_service
-792
View File
@@ -1,792 +0,0 @@
"""
OAuth Credential Manager for validating and refreshing credentials.
This service provides:
1. Credential validation for YouTube, Dropbox, and Google Drive
2. Device Authorization Flow for re-authentication
3. Proactive monitoring with alerts when credentials expire
"""
import json
import logging
import time
from typing import Optional, Dict, Any, Tuple
from dataclasses import dataclass
from enum import Enum
from datetime import datetime
from google.oauth2.credentials import Credentials as GoogleCredentials
from google.auth.transport.requests import Request as GoogleAuthRequest
from backend.config import get_settings
logger = logging.getLogger(__name__)
class CredentialStatus(str, Enum):
"""Status of OAuth credentials."""
VALID = "valid"
EXPIRED = "expired" # Token expired but refresh may work
INVALID = "invalid" # Refresh failed, re-auth needed
NOT_CONFIGURED = "not_configured" # No credentials stored
ERROR = "error" # Unknown error during validation
@dataclass
class CredentialCheckResult:
"""Result of a credential validation check."""
service: str
status: CredentialStatus
message: str
last_checked: datetime
expires_at: Optional[datetime] = None
@dataclass
class DeviceAuthInfo:
"""Information for device authorization flow."""
device_code: str
user_code: str
verification_url: str
expires_in: int
interval: int
started_at: datetime
class CredentialManager:
"""
Manages OAuth credentials for all external services.
Provides validation, refresh, and device authorization flow for:
- YouTube (Google OAuth)
- Google Drive (Google OAuth)
- Dropbox
"""
# Secret names in Secret Manager
YOUTUBE_SECRET = "youtube-oauth-credentials"
GDRIVE_SECRET = "gdrive-oauth-credentials"
DROPBOX_SECRET = "dropbox-oauth-credentials"
# OAuth client credentials (for device auth flow)
YOUTUBE_CLIENT_SECRET = "youtube-client-credentials"
GDRIVE_CLIENT_SECRET = "gdrive-client-credentials"
# Google OAuth endpoints
GOOGLE_TOKEN_URI = "https://oauth2.googleapis.com/token"
GOOGLE_DEVICE_AUTH_URI = "https://oauth2.googleapis.com/device/code"
# Dropbox OAuth endpoints
DROPBOX_TOKEN_URI = "https://api.dropboxapi.com/oauth2/token"
# Scopes for each service
YOUTUBE_SCOPES = ["https://www.googleapis.com/auth/youtube"]
GDRIVE_SCOPES = ["https://www.googleapis.com/auth/drive.file"]
def __init__(self):
self.settings = get_settings()
self._pending_device_auths: Dict[str, DeviceAuthInfo] = {}
def _get_client_credentials(self, secret_name: str) -> Optional[Dict[str, str]]:
"""
Load OAuth client credentials from Secret Manager.
The secret should contain:
{
"client_id": "...",
"client_secret": "..."
}
"""
try:
creds_json = self.settings.get_secret(secret_name)
if not creds_json:
return None
creds = json.loads(creds_json)
if creds.get("client_id") and creds.get("client_secret"):
return creds
logger.warning(f"{secret_name} missing client_id or client_secret")
return None
except Exception as e:
logger.error(f"Failed to load {secret_name}: {e}")
return None
def get_youtube_client_credentials(self) -> Optional[Dict[str, str]]:
"""Get YouTube OAuth client credentials from Secret Manager."""
return self._get_client_credentials(self.YOUTUBE_CLIENT_SECRET)
def get_gdrive_client_credentials(self) -> Optional[Dict[str, str]]:
"""Get Google Drive OAuth client credentials from Secret Manager."""
return self._get_client_credentials(self.GDRIVE_CLIENT_SECRET)
# =========================================================================
# Credential Validation
# =========================================================================
def check_all_credentials(self) -> Dict[str, CredentialCheckResult]:
"""
Check validity of all OAuth credentials.
Returns:
Dictionary mapping service name to check result
"""
results = {}
results["youtube"] = self.check_youtube_credentials()
results["gdrive"] = self.check_gdrive_credentials()
results["dropbox"] = self.check_dropbox_credentials()
return results
def check_youtube_credentials(self) -> CredentialCheckResult:
"""Check if YouTube credentials are valid and can be refreshed."""
return self._check_google_credentials(
secret_name=self.YOUTUBE_SECRET,
service_name="youtube",
scopes=self.YOUTUBE_SCOPES,
test_api_call=self._test_youtube_api
)
def check_gdrive_credentials(self) -> CredentialCheckResult:
"""Check if Google Drive credentials are valid and can be refreshed."""
return self._check_google_credentials(
secret_name=self.GDRIVE_SECRET,
service_name="gdrive",
scopes=self.GDRIVE_SCOPES,
test_api_call=self._test_gdrive_api
)
def check_dropbox_credentials(self) -> CredentialCheckResult:
"""Check if Dropbox credentials are valid."""
try:
creds_json = self.settings.get_secret(self.DROPBOX_SECRET)
if not creds_json:
return CredentialCheckResult(
service="dropbox",
status=CredentialStatus.NOT_CONFIGURED,
message="Dropbox credentials not configured",
last_checked=datetime.utcnow()
)
creds = json.loads(creds_json)
if not creds.get("access_token"):
return CredentialCheckResult(
service="dropbox",
status=CredentialStatus.INVALID,
message="Dropbox credentials missing access_token",
last_checked=datetime.utcnow()
)
# Test the credentials with a simple API call
if self._test_dropbox_api(creds):
return CredentialCheckResult(
service="dropbox",
status=CredentialStatus.VALID,
message="Dropbox credentials are valid",
last_checked=datetime.utcnow()
)
else:
# Try to refresh if we have refresh token
if creds.get("refresh_token") and creds.get("app_key") and creds.get("app_secret"):
if self._refresh_dropbox_token(creds):
return CredentialCheckResult(
service="dropbox",
status=CredentialStatus.VALID,
message="Dropbox credentials refreshed successfully",
last_checked=datetime.utcnow()
)
return CredentialCheckResult(
service="dropbox",
status=CredentialStatus.INVALID,
message="Dropbox credentials invalid and refresh failed",
last_checked=datetime.utcnow()
)
except Exception as e:
logger.error(f"Error checking Dropbox credentials: {e}")
return CredentialCheckResult(
service="dropbox",
status=CredentialStatus.ERROR,
message=f"Error checking credentials: {str(e)}",
last_checked=datetime.utcnow()
)
def _check_google_credentials(
self,
secret_name: str,
service_name: str,
scopes: list,
test_api_call: callable
) -> CredentialCheckResult:
"""Generic Google OAuth credential check."""
try:
creds_json = self.settings.get_secret(secret_name)
if not creds_json:
return CredentialCheckResult(
service=service_name,
status=CredentialStatus.NOT_CONFIGURED,
message=f"{service_name} credentials not configured",
last_checked=datetime.utcnow()
)
creds_data = json.loads(creds_json)
# Check for required fields
required = ["refresh_token", "client_id", "client_secret"]
missing = [f for f in required if not creds_data.get(f)]
if missing:
return CredentialCheckResult(
service=service_name,
status=CredentialStatus.INVALID,
message=f"Missing required fields: {missing}",
last_checked=datetime.utcnow()
)
# Create credentials object
credentials = GoogleCredentials(
token=creds_data.get("token"),
refresh_token=creds_data.get("refresh_token"),
token_uri=creds_data.get("token_uri", self.GOOGLE_TOKEN_URI),
client_id=creds_data.get("client_id"),
client_secret=creds_data.get("client_secret"),
scopes=creds_data.get("scopes", scopes)
)
# Try to refresh if expired
if credentials.expired or not credentials.token:
try:
credentials.refresh(GoogleAuthRequest())
# Update stored credentials with new token
self._update_google_credentials(secret_name, creds_data, credentials)
except Exception as e:
logger.error(f"Failed to refresh {service_name} credentials: {e}")
return CredentialCheckResult(
service=service_name,
status=CredentialStatus.INVALID,
message=f"Token refresh failed: {str(e)}",
last_checked=datetime.utcnow()
)
# Test with API call
if test_api_call(credentials):
return CredentialCheckResult(
service=service_name,
status=CredentialStatus.VALID,
message=f"{service_name} credentials are valid",
last_checked=datetime.utcnow(),
expires_at=credentials.expiry
)
else:
return CredentialCheckResult(
service=service_name,
status=CredentialStatus.INVALID,
message=f"{service_name} API test failed",
last_checked=datetime.utcnow()
)
except json.JSONDecodeError as e:
return CredentialCheckResult(
service=service_name,
status=CredentialStatus.INVALID,
message=f"Invalid JSON in credentials: {str(e)}",
last_checked=datetime.utcnow()
)
except Exception as e:
logger.error(f"Error checking {service_name} credentials: {e}")
return CredentialCheckResult(
service=service_name,
status=CredentialStatus.ERROR,
message=f"Error: {str(e)}",
last_checked=datetime.utcnow()
)
def _update_google_credentials(
self,
secret_name: str,
original_data: dict,
credentials: GoogleCredentials
) -> bool:
"""Update stored Google credentials with refreshed token."""
try:
from google.cloud import secretmanager
updated_data = original_data.copy()
updated_data["token"] = credentials.token
if credentials.expiry:
updated_data["expiry"] = credentials.expiry.isoformat()
# Add new secret version
client = secretmanager.SecretManagerServiceClient()
project_id = self.settings.google_cloud_project
secret_path = f"projects/{project_id}/secrets/{secret_name}"
client.add_secret_version(
parent=secret_path,
payload={"data": json.dumps(updated_data).encode("utf-8")}
)
logger.info(f"Updated {secret_name} with refreshed token")
return True
except Exception as e:
logger.error(f"Failed to update {secret_name}: {e}")
return False
# =========================================================================
# API Test Methods
# =========================================================================
def _test_youtube_api(self, credentials: GoogleCredentials) -> bool:
"""Test YouTube credentials with a simple API call."""
try:
from googleapiclient.discovery import build
youtube = build("youtube", "v3", credentials=credentials)
# Just get channel info - minimal API call
request = youtube.channels().list(part="id", mine=True)
response = request.execute()
return "items" in response
except Exception as e:
logger.error(f"YouTube API test failed: {e}")
return False
def _test_gdrive_api(self, credentials: GoogleCredentials) -> bool:
"""Test Google Drive credentials with a simple API call."""
try:
from googleapiclient.discovery import build
drive = build("drive", "v3", credentials=credentials)
# Just get about info - minimal API call
request = drive.about().get(fields="user")
response = request.execute()
return "user" in response
except Exception as e:
logger.error(f"Google Drive API test failed: {e}")
return False
def _test_dropbox_api(self, creds: dict) -> bool:
"""Test Dropbox credentials with a simple API call."""
try:
import dropbox
dbx = dropbox.Dropbox(creds["access_token"])
# Just get account info - minimal API call
dbx.users_get_current_account()
return True
except Exception as e:
logger.error(f"Dropbox API test failed: {e}")
return False
def _refresh_dropbox_token(self, creds: dict) -> bool:
"""Try to refresh Dropbox token."""
try:
import requests
response = requests.post(
self.DROPBOX_TOKEN_URI,
data={
"grant_type": "refresh_token",
"refresh_token": creds["refresh_token"],
"client_id": creds["app_key"],
"client_secret": creds["app_secret"],
},
timeout=30
)
if response.status_code == 200:
token_data = response.json()
creds["access_token"] = token_data["access_token"]
# Update in Secret Manager
self._update_dropbox_credentials(creds)
return True
return False
except Exception as e:
logger.error(f"Dropbox token refresh failed: {e}")
return False
def _update_dropbox_credentials(self, creds: dict) -> bool:
"""Update stored Dropbox credentials."""
try:
from google.cloud import secretmanager
client = secretmanager.SecretManagerServiceClient()
project_id = self.settings.google_cloud_project
secret_path = f"projects/{project_id}/secrets/{self.DROPBOX_SECRET}"
client.add_secret_version(
parent=secret_path,
payload={"data": json.dumps(creds).encode("utf-8")}
)
logger.info("Updated Dropbox credentials with refreshed token")
return True
except Exception as e:
logger.error(f"Failed to update Dropbox credentials: {e}")
return False
# =========================================================================
# Device Authorization Flow
# =========================================================================
def start_youtube_device_auth(
self,
client_id: Optional[str] = None,
client_secret: Optional[str] = None
) -> DeviceAuthInfo:
"""
Start YouTube device authorization flow.
Args:
client_id: Google OAuth client ID (optional, reads from Secret Manager if not provided)
client_secret: Google OAuth client secret (optional, reads from Secret Manager if not provided)
Returns:
DeviceAuthInfo with user code and verification URL
"""
# Load from Secret Manager if not provided
if not client_id or not client_secret:
stored_creds = self.get_youtube_client_credentials()
if not stored_creds:
raise Exception(
"YouTube client credentials not found. Either pass client_id/client_secret "
"or create the 'youtube-client-credentials' secret in Secret Manager."
)
client_id = stored_creds["client_id"]
client_secret = stored_creds["client_secret"]
return self._start_google_device_auth(
client_id=client_id,
client_secret=client_secret,
scopes=self.YOUTUBE_SCOPES,
service_name="youtube"
)
def start_gdrive_device_auth(
self,
client_id: Optional[str] = None,
client_secret: Optional[str] = None
) -> DeviceAuthInfo:
"""
Start Google Drive device authorization flow.
Args:
client_id: Google OAuth client ID (optional, reads from Secret Manager if not provided)
client_secret: Google OAuth client secret (optional, reads from Secret Manager if not provided)
Returns:
DeviceAuthInfo with user code and verification URL
"""
# Load from Secret Manager if not provided
if not client_id or not client_secret:
stored_creds = self.get_gdrive_client_credentials()
if not stored_creds:
raise Exception(
"Google Drive client credentials not found. Either pass client_id/client_secret "
"or create the 'gdrive-client-credentials' secret in Secret Manager."
)
client_id = stored_creds["client_id"]
client_secret = stored_creds["client_secret"]
return self._start_google_device_auth(
client_id=client_id,
client_secret=client_secret,
scopes=self.GDRIVE_SCOPES,
service_name="gdrive"
)
def _start_google_device_auth(
self,
client_id: str,
client_secret: str,
scopes: list,
service_name: str
) -> DeviceAuthInfo:
"""Start Google device authorization flow."""
import requests
logger.info(f"[{service_name}] Starting device auth flow with scopes: {scopes}")
response = requests.post(
self.GOOGLE_DEVICE_AUTH_URI,
data={
"client_id": client_id,
"scope": " ".join(scopes),
},
timeout=30
)
if response.status_code != 200:
logger.error(f"[{service_name}] Device auth request failed: {response.status_code} - {response.text}")
raise Exception(f"Device auth request failed: {response.text}")
logger.info(f"[{service_name}] Device auth initiated successfully")
data = response.json()
# Google uses 'verification_uri' but some docs show 'verification_url'
verification_url = data.get("verification_uri") or data.get("verification_url")
device_info = DeviceAuthInfo(
device_code=data["device_code"],
user_code=data["user_code"],
verification_url=verification_url,
expires_in=data["expires_in"],
interval=data.get("interval", 5),
started_at=datetime.utcnow()
)
# Store for polling, include client secret for token exchange
self._pending_device_auths[f"{service_name}:{data['device_code']}"] = {
"info": device_info,
"client_id": client_id,
"client_secret": client_secret,
"scopes": scopes,
"service_name": service_name
}
return device_info
def poll_device_auth(self, service_name: str, device_code: str) -> Tuple[str, Optional[dict]]:
"""
Poll for device authorization completion.
This method is STATELESS - it fetches client credentials from Secret Manager
and polls Google directly. This works correctly in serverless environments
like Cloud Run where in-memory state is not preserved between requests.
Args:
service_name: "youtube" or "gdrive"
device_code: The device code from start_*_device_auth
Returns:
Tuple of (status, token_data)
status: "pending", "complete", "expired", "error"
token_data: Token data if complete, None otherwise
"""
import requests
logger.info(f"[{service_name}] Polling device auth for code: {device_code[:20]}...")
# Get client credentials from Secret Manager (stateless approach)
if service_name == "youtube":
client_creds = self.get_youtube_client_credentials()
scopes = self.YOUTUBE_SCOPES
secret_name = self.YOUTUBE_SECRET
elif service_name == "gdrive":
client_creds = self.get_gdrive_client_credentials()
scopes = self.GDRIVE_SCOPES
secret_name = self.GDRIVE_SECRET
else:
logger.error(f"[{service_name}] Unknown service")
return ("error", {"message": f"Unknown service: {service_name}"})
if not client_creds:
logger.error(f"[{service_name}] Client credentials not found in Secret Manager")
return ("error", {"message": f"Client credentials not found in Secret Manager for {service_name}"})
client_id = client_creds.get("client_id")
client_secret = client_creds.get("client_secret")
if not client_id or not client_secret:
logger.error(f"[{service_name}] Invalid client credentials (missing client_id or client_secret)")
return ("error", {"message": f"Invalid client credentials for {service_name}"})
logger.info(f"[{service_name}] Got client credentials, polling Google token endpoint...")
# Poll Google token endpoint
response = requests.post(
self.GOOGLE_TOKEN_URI,
data={
"client_id": client_id,
"client_secret": client_secret,
"device_code": device_code,
"grant_type": "urn:ietf:params:oauth:grant-type:device_code",
},
timeout=30
)
data = response.json()
logger.info(f"[{service_name}] Token endpoint response: status={response.status_code}")
if response.status_code == 200:
logger.info(f"[{service_name}] Token exchange successful! Got access token and refresh_token={bool(data.get('refresh_token'))}")
# Success! Store the credentials
token_data = {
"token": data["access_token"],
"refresh_token": data.get("refresh_token"),
"token_uri": self.GOOGLE_TOKEN_URI,
"client_id": client_id,
"client_secret": client_secret,
"scopes": scopes,
}
# Save to Secret Manager
logger.info(f"[{service_name}] Saving credentials to secret: {secret_name}")
saved = self._save_credentials_to_secret(secret_name, token_data)
if not saved:
logger.error(f"[{service_name}] Failed to save credentials to Secret Manager!")
return ("error", {"message": "Token exchange succeeded but failed to save credentials to Secret Manager"})
logger.info(f"[{service_name}] Device auth flow COMPLETE - credentials saved successfully")
return ("complete", token_data)
elif "error" in data:
error = data["error"]
logger.info(f"[{service_name}] Token endpoint returned error: {error}")
if error == "authorization_pending":
return ("pending", {"message": "Waiting for user to authorize. Please visit the verification URL and enter the code."})
elif error == "slow_down":
return ("pending", {"message": "Please wait a few more seconds before polling again."})
elif error == "expired_token":
logger.warning(f"[{service_name}] Device code expired")
return ("expired", {"message": "Device code expired. Please start a new device auth flow."})
elif error == "access_denied":
logger.warning(f"[{service_name}] User denied access")
return ("error", {"message": "User denied access"})
else:
logger.error(f"[{service_name}] Unexpected error: {data}")
return ("error", {"message": data.get("error_description", error)})
logger.error(f"[{service_name}] Unknown response from token endpoint: {data}")
return ("error", {"message": "Unknown response from token endpoint"})
def _save_credentials_to_secret(self, secret_name: str, token_data: dict) -> bool:
"""Save credentials to Secret Manager, creating the secret if needed."""
logger.info(f"[SecretManager] Attempting to save credentials to: {secret_name}")
try:
from google.cloud import secretmanager
from google.api_core import exceptions as gcp_exceptions
client = secretmanager.SecretManagerServiceClient()
project_id = self.settings.google_cloud_project
if not project_id:
logger.error(f"[SecretManager] No GCP project configured!")
return False
parent = f"projects/{project_id}"
secret_path = f"{parent}/secrets/{secret_name}"
logger.info(f"[SecretManager] Using project: {project_id}, secret path: {secret_path}")
# Try to add a version to existing secret
try:
client.add_secret_version(
parent=secret_path,
payload={"data": json.dumps(token_data).encode("utf-8")}
)
logger.info(f"[SecretManager] SUCCESS - Added new version to existing secret: {secret_name}")
return True
except gcp_exceptions.NotFound:
# Secret doesn't exist, create it first
logger.info(f"[SecretManager] Secret {secret_name} not found, creating new secret...")
client.create_secret(
parent=parent,
secret_id=secret_name,
secret={"replication": {"automatic": {}}}
)
logger.info(f"[SecretManager] Created secret: {secret_name}")
# Now add the version
client.add_secret_version(
parent=secret_path,
payload={"data": json.dumps(token_data).encode("utf-8")}
)
logger.info(f"[SecretManager] SUCCESS - Created secret and saved credentials to: {secret_name}")
return True
except Exception as e:
logger.error(f"[SecretManager] FAILED to save credentials to {secret_name}: {type(e).__name__}: {e}")
import traceback
logger.error(f"[SecretManager] Traceback: {traceback.format_exc()}")
return False
# =========================================================================
# Alerts
# =========================================================================
def send_credential_alert(
self,
invalid_services: list[CredentialCheckResult],
discord_webhook_url: Optional[str] = None
) -> bool:
"""
Send alert about invalid credentials.
Args:
invalid_services: List of services with invalid credentials
discord_webhook_url: Discord webhook URL for notifications
Returns:
True if alert was sent successfully
"""
if not discord_webhook_url:
logger.warning("No Discord webhook URL configured for alerts")
return False
try:
import requests
services_list = "\n".join([
f"• **{r.service}**: {r.message}"
for r in invalid_services
])
# Get the API base URL for re-auth links
api_url = self.settings.api_base_url if hasattr(self.settings, 'api_base_url') else "https://your-api-url"
message = {
"embeds": [{
"title": "⚠️ OAuth Credentials Need Attention",
"description": f"The following service credentials need re-authorization:\n\n{services_list}",
"color": 16744256, # Orange
"fields": [
{
"name": "Re-authorize",
"value": f"Visit `{api_url}/api/auth/status` to start re-authorization flow",
"inline": False
}
],
"footer": {
"text": "karaoke-gen backend"
},
"timestamp": datetime.utcnow().isoformat()
}]
}
response = requests.post(discord_webhook_url, json=message, timeout=30)
return response.status_code in (200, 204)
except Exception as e:
logger.error(f"Failed to send credential alert: {e}")
return False
# Singleton instance
_credential_manager: Optional[CredentialManager] = None
def get_credential_manager() -> CredentialManager:
"""Get the singleton credential manager instance."""
global _credential_manager
if _credential_manager is None:
_credential_manager = CredentialManager()
return _credential_manager
-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
-301
View File
@@ -1,301 +0,0 @@
"""Native Dropbox API service for cloud backend.
This service provides Dropbox operations using the native Python SDK,
replacing rclone for server-side operations. It handles:
- Folder listing for brand code calculation
- File and folder uploads
- Shared link generation
Credentials are loaded from Google Cloud Secret Manager.
"""
import json
import logging
import os
import re
from typing import Optional
from google.cloud import secretmanager
logger = logging.getLogger(__name__)
class DropboxService:
"""Dropbox operations using native Python SDK."""
def __init__(self):
self._client = None
self._is_configured = False
def _load_credentials(self) -> Optional[dict]:
"""Load OAuth credentials from Secret Manager."""
try:
client = secretmanager.SecretManagerServiceClient()
# Try to get the project ID from environment or use default
project_id = os.environ.get("GOOGLE_CLOUD_PROJECT", "karaoke-gen")
name = f"projects/{project_id}/secrets/dropbox-oauth-credentials/versions/latest"
response = client.access_secret_version(request={"name": name})
return json.loads(response.payload.data.decode("UTF-8"))
except Exception as e:
logger.warning(f"Failed to load Dropbox credentials from Secret Manager: {e}")
return None
@property
def is_configured(self) -> bool:
"""Check if Dropbox credentials are available."""
if self._is_configured:
return True
creds = self._load_credentials()
self._is_configured = creds is not None and "access_token" in creds
return self._is_configured
@property
def client(self):
"""Get or create Dropbox client."""
if self._client is None:
# Import here to avoid import errors if dropbox is not installed
try:
from dropbox import Dropbox
except ImportError:
raise ImportError(
"dropbox package is not installed. "
"Install it with: pip install dropbox"
)
creds = self._load_credentials()
if not creds:
raise RuntimeError("Dropbox credentials not configured in Secret Manager")
self._client = Dropbox(
oauth2_access_token=creds["access_token"],
oauth2_refresh_token=creds.get("refresh_token"),
app_key=creds.get("app_key"),
app_secret=creds.get("app_secret"),
)
return self._client
def list_folders(self, path: str) -> list[str]:
"""
List folder names at path for brand code calculation.
Args:
path: Dropbox path to list (e.g., "/Karaoke/Tracks-Organized")
Returns:
List of folder names in the path
"""
from dropbox.files import FolderMetadata
# Ensure path starts with /
if not path.startswith("/"):
path = f"/{path}"
logger.info(f"Listing folders at Dropbox path: {path}")
result = self.client.files_list_folder(path)
folders = []
# Get all entries (handling pagination)
while True:
for entry in result.entries:
if isinstance(entry, FolderMetadata):
folders.append(entry.name)
if not result.has_more:
break
result = self.client.files_list_folder_continue(result.cursor)
logger.info(f"Found {len(folders)} folders in {path}")
return folders
def get_next_brand_code(self, path: str, brand_prefix: str) -> str:
"""
Calculate next brand code from existing folders.
Scans the folder for existing brand codes like "NOMAD-0001" and
returns the next sequential code.
Args:
path: Dropbox path containing organized folders
brand_prefix: Brand prefix (e.g., "NOMAD")
Returns:
Next brand code (e.g., "NOMAD-1164")
"""
folders = self.list_folders(path)
pattern = re.compile(rf"^{re.escape(brand_prefix)}-(\d{{4}})")
max_num = 0
for folder in folders:
match = pattern.match(folder)
if match:
num = int(match.group(1))
max_num = max(max_num, num)
next_code = f"{brand_prefix}-{max_num + 1:04d}"
logger.info(f"Next brand code for {brand_prefix}: {next_code} (max existing: {max_num})")
return next_code
def upload_file(self, local_path: str, remote_path: str) -> None:
"""
Upload a single file to Dropbox.
Args:
local_path: Local file path
remote_path: Dropbox destination path (must start with /)
"""
from dropbox.files import WriteMode
# Ensure remote path starts with /
if not remote_path.startswith("/"):
remote_path = f"/{remote_path}"
file_size = os.path.getsize(local_path)
logger.info(f"Uploading {local_path} ({file_size / 1024 / 1024:.1f} MB) to {remote_path}")
# For large files (>150MB), use upload sessions
CHUNK_SIZE = 150 * 1024 * 1024 # 150 MB
with open(local_path, "rb") as f:
if file_size <= CHUNK_SIZE:
# Simple upload for smaller files
self.client.files_upload(f.read(), remote_path, mode=WriteMode.overwrite)
else:
# Chunked upload for large files
self._upload_large_file(f, remote_path, file_size)
logger.info(f"Successfully uploaded to {remote_path}")
def _upload_large_file(self, file_obj, remote_path: str, file_size: int) -> None:
"""Upload a large file using upload sessions."""
from dropbox.files import CommitInfo, UploadSessionCursor, WriteMode
CHUNK_SIZE = 150 * 1024 * 1024 # 150 MB
# Start upload session
session_start = self.client.files_upload_session_start(file_obj.read(CHUNK_SIZE))
cursor = UploadSessionCursor(
session_id=session_start.session_id,
offset=file_obj.tell(),
)
commit = CommitInfo(path=remote_path, mode=WriteMode.overwrite)
# Upload remaining chunks
while file_obj.tell() < file_size:
remaining = file_size - file_obj.tell()
if remaining <= CHUNK_SIZE:
# Final chunk
self.client.files_upload_session_finish(
file_obj.read(CHUNK_SIZE),
cursor,
commit,
)
else:
# Intermediate chunk
self.client.files_upload_session_append_v2(
file_obj.read(CHUNK_SIZE),
cursor,
)
cursor.offset = file_obj.tell()
def upload_folder(self, local_dir: str, remote_path: str) -> None:
"""
Recursively upload all files and subdirectories to Dropbox folder.
Args:
local_dir: Local directory to upload
remote_path: Dropbox destination folder path
"""
# Ensure remote path starts with /
if not remote_path.startswith("/"):
remote_path = f"/{remote_path}"
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}"
self.upload_file(local_file, remote_file)
uploaded_count += 1
logger.info(f"Uploaded {uploaded_count} files to {remote_path}")
def create_shared_link(self, path: str) -> str:
"""
Create and return a shared link for the path.
Args:
path: Dropbox path to share
Returns:
Shared link URL
"""
from dropbox.exceptions import ApiError
from dropbox.sharing import SharedLinkSettings
# Ensure path starts with /
if not path.startswith("/"):
path = f"/{path}"
logger.info(f"Creating shared link for: {path}")
try:
# Try to create a new shared link
settings = SharedLinkSettings(requested_visibility=None)
link = self.client.sharing_create_shared_link_with_settings(path, settings)
logger.info(f"Created new shared link: {link.url}")
return link.url
except ApiError as e:
# Link may already exist - try to get existing link
if e.error.is_shared_link_already_exists():
logger.info("Shared link already exists, retrieving existing link")
links = self.client.sharing_list_shared_links(path=path, direct_only=True)
if links.links:
logger.info(f"Found existing shared link: {links.links[0].url}")
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."""
return DropboxService()
-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
-451
View File
@@ -1,451 +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 = {}
raw_output_files = result.get("output_files", {})
# Convert output_files from list of paths to dict if needed
# GCE worker returns list like: ["path/output_4k_lossless.mp4", "path/output_720p.mp4"]
# We need dict like: {"mp4_4k_lossless": "path/...", "mp4_720p": "path/..."}
if isinstance(raw_output_files, list):
output_files = {}
for path in raw_output_files:
if not isinstance(path, str):
continue
filename = path.split("/")[-1] if "/" in path else path
# Map filename patterns to output format keys
if "4k_lossless" in filename:
output_files["mp4_4k_lossless"] = path
elif "4k_lossy" in filename:
output_files["mp4_4k_lossy"] = path
elif "720p" in filename:
output_files["mp4_720p"] = path
elif filename.endswith(".mkv"):
output_files["mkv_4k"] = path
self.logger.info(f"Converted output_files list to dict: {output_files}")
else:
output_files = raw_output_files if isinstance(raw_output_files, dict) else {}
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}")
-279
View File
@@ -1,279 +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)
# Handle case where GCE worker returns a list instead of dict
if isinstance(status, list):
logger.warning(f"[job:{job_id}] GCE returned list instead of dict: {status}")
status = status[0] if status and isinstance(status[0], dict) else {}
if not isinstance(status, dict):
logger.error(f"[job:{job_id}] Unexpected status type: {type(status)}")
status = {}
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
-512
View File
@@ -1,512 +0,0 @@
"""
Firestore database operations for job management.
"""
import logging
from typing import Optional, Dict, Any, List
from datetime import datetime
from google.cloud import firestore
from google.cloud.firestore_v1 import FieldFilter
from backend.config import settings
from backend.models.job import Job, JobStatus, TimelineEvent
from backend.models.worker_log import WorkerLogEntry
logger = logging.getLogger(__name__)
class FirestoreService:
"""Service for Firestore database operations."""
def __init__(self):
"""Initialize Firestore client."""
self.db = firestore.Client(project=settings.google_cloud_project)
self.collection = settings.firestore_collection
self.tokens_collection = "auth_tokens" # Collection for access tokens
def create_job(self, job: Job) -> None:
"""Create a new job in Firestore."""
try:
doc_ref = self.db.collection(self.collection).document(job.job_id)
doc_ref.set(job.model_dump(mode='json'))
logger.info(f"Created job {job.job_id} in Firestore")
except Exception as e:
logger.error(f"Error creating job {job.job_id}: {e}")
raise
def get_job(self, job_id: str) -> Optional[Job]:
"""Get a job by ID."""
try:
doc_ref = self.db.collection(self.collection).document(job_id)
doc = doc_ref.get()
logger.debug(f"Fetching job {job_id} from collection {self.collection}")
logger.debug(f"Document exists: {doc.exists}")
if not doc.exists:
return None
data = doc.to_dict()
logger.debug(f"Document data keys: {list(data.keys()) if data else 'None'}")
logger.debug(f"Document data: {data}")
return Job(**data)
except Exception as e:
logger.error(f"Error getting job {job_id}: {e}")
raise
def update_job(self, job_id: str, updates: Dict[str, Any]) -> None:
"""Update a job with partial data."""
try:
doc_ref = self.db.collection(self.collection).document(job_id)
# Add updated_at timestamp
updates['updated_at'] = datetime.utcnow()
doc_ref.update(updates)
logger.info(f"Updated job {job_id} in Firestore")
except Exception as e:
logger.error(f"Error updating job {job_id}: {e}")
raise
def update_job_status(
self,
job_id: str,
status: JobStatus,
progress: Optional[int] = None,
message: Optional[str] = None,
**additional_fields
) -> None:
"""Update job status and add timeline event."""
try:
doc_ref = self.db.collection(self.collection).document(job_id)
# Create timeline event
timeline_event = TimelineEvent(
status=status.value,
timestamp=datetime.utcnow().isoformat(),
progress=progress,
message=message
)
# Prepare updates
updates = {
'status': status.value,
'updated_at': datetime.utcnow(),
'timeline': firestore.ArrayUnion([timeline_event.model_dump(mode='json')])
}
if progress is not None:
updates['progress'] = progress
# Add any additional fields
updates.update(additional_fields)
doc_ref.update(updates)
logger.info(f"Updated job {job_id} status to {status.value}")
except Exception as e:
logger.error(f"Error updating job status {job_id}: {e}")
raise
def list_jobs(
self,
status: Optional[JobStatus] = None,
environment: Optional[str] = None,
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}")
raise
def delete_jobs_by_filter(
self,
environment: Optional[str] = None,
client_id: Optional[str] = None,
status: Optional[JobStatus] = None,
created_before: Optional[datetime] = None,
) -> int:
"""
Delete multiple jobs matching filter criteria.
CAUTION: This is a destructive operation. Use carefully.
Args:
environment: Delete jobs with this environment (e.g., "test")
client_id: Delete jobs from this client
status: Delete jobs with this status
created_before: Delete jobs created before this datetime
Returns:
Number of jobs deleted
"""
try:
query = self.db.collection(self.collection)
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))
if status:
query = query.where(filter=FieldFilter('status', '==', status.value))
if created_before:
query = query.where(filter=FieldFilter('created_at', '<=', created_before))
# Get matching documents
docs = list(query.stream())
deleted_count = 0
# Delete in batches
batch = self.db.batch()
batch_count = 0
for doc in docs:
batch.delete(doc.reference)
batch_count += 1
deleted_count += 1
# Firestore batch limit is 500
if batch_count >= 500:
batch.commit()
batch = self.db.batch()
batch_count = 0
# Commit any remaining deletes
if batch_count > 0:
batch.commit()
logger.info(f"Deleted {deleted_count} jobs matching filter criteria")
return deleted_count
except Exception as e:
logger.error(f"Error deleting jobs by filter: {e}")
raise
def delete_job(self, job_id: str) -> None:
"""Delete a job from Firestore."""
try:
doc_ref = self.db.collection(self.collection).document(job_id)
doc_ref.delete()
logger.info(f"Deleted job {job_id} from Firestore")
except Exception as e:
logger.error(f"Error deleting job {job_id}: {e}")
raise
def append_worker_log(self, job_id: str, log_entry: Dict[str, Any]) -> None:
"""
Atomically append a log entry to worker_logs using ArrayUnion.
This avoids the race condition of read-modify-write when multiple
workers are logging concurrently.
DEPRECATED: Use append_log_to_subcollection() instead to avoid
the 1MB document size limit.
Args:
job_id: Job ID
log_entry: Log entry dict with timestamp, level, worker, message
"""
try:
doc_ref = self.db.collection(self.collection).document(job_id)
doc_ref.update({
'worker_logs': firestore.ArrayUnion([log_entry]),
'updated_at': datetime.utcnow()
})
# Don't log every append - too spammy
except Exception as e:
# Log but don't raise - logging shouldn't break workers
logger.debug(f"Error appending worker log for job {job_id}: {e}")
# ============================================
# Worker Log Subcollection Methods
# ============================================
# These methods store logs in a subcollection (jobs/{job_id}/logs)
# instead of an embedded array to avoid the 1MB document size limit.
def append_log_to_subcollection(self, job_id: str, log_entry: WorkerLogEntry) -> None:
"""
Append a log entry to the logs subcollection.
Stores logs at: jobs/{job_id}/logs/{log_id}
This approach avoids the 1MB document size limit by storing each
log entry as a separate document in a subcollection.
Args:
job_id: Job ID
log_entry: WorkerLogEntry instance
"""
try:
# Ensure job_id is set on the log entry
log_entry.job_id = job_id
# Get subcollection reference
logs_ref = self.db.collection(self.collection).document(job_id).collection("logs")
# Add document with auto-generated ID or use log_entry.id
doc_ref = logs_ref.document(log_entry.id)
doc_ref.set(log_entry.to_dict())
# Don't log every append - too spammy
except Exception as e:
# Log but don't raise - logging shouldn't break workers
logger.debug(f"Error appending log to subcollection for job {job_id}: {e}")
def get_logs_from_subcollection(
self,
job_id: str,
limit: int = 500,
since_timestamp: Optional[datetime] = None,
worker: Optional[str] = None,
offset: int = 0
) -> List[WorkerLogEntry]:
"""
Get log entries from the logs subcollection.
Args:
job_id: Job ID
limit: Maximum number of logs to return (default 500)
since_timestamp: Return only logs after this timestamp
worker: Filter by worker name (optional)
offset: Number of logs to skip (for pagination)
Returns:
List of WorkerLogEntry instances, ordered by timestamp ascending
"""
try:
# Get subcollection reference
logs_ref = self.db.collection(self.collection).document(job_id).collection("logs")
# Build query
query = logs_ref.order_by("timestamp", direction=firestore.Query.ASCENDING)
if since_timestamp:
query = query.where(filter=FieldFilter("timestamp", ">", since_timestamp))
if worker:
query = query.where(filter=FieldFilter("worker", "==", worker))
# Apply offset and limit
if offset > 0:
query = query.offset(offset)
query = query.limit(limit)
# Execute query
docs = query.stream()
logs = [WorkerLogEntry.from_dict(doc.to_dict()) for doc in docs]
return logs
except Exception as e:
logger.error(f"Error getting logs from subcollection for job {job_id}: {e}")
return []
def get_logs_count_from_subcollection(self, job_id: str) -> int:
"""
Get the total count of log entries in the subcollection.
Args:
job_id: Job ID
Returns:
Total count of log entries
"""
try:
# Get subcollection reference
logs_ref = self.db.collection(self.collection).document(job_id).collection("logs")
# Use aggregation query for efficient counting
count_query = logs_ref.count()
result = count_query.get()
# Result is a list of AggregationResult, we want the first one's count
if result and len(result) > 0:
return result[0][0].value
return 0
except Exception as e:
logger.error(f"Error counting logs for job {job_id}: {e}")
return 0
def delete_logs_subcollection(self, job_id: str, batch_size: int = 500) -> int:
"""
Delete all log entries in the logs subcollection.
This is used when deleting a job to clean up its logs.
Args:
job_id: Job ID
batch_size: Number of documents to delete per batch
Returns:
Number of logs deleted
"""
try:
logs_ref = self.db.collection(self.collection).document(job_id).collection("logs")
deleted_count = 0
while True:
# Get a batch of documents
docs = logs_ref.limit(batch_size).stream()
deleted_in_batch = 0
# Delete in a batch
batch = self.db.batch()
for doc in docs:
batch.delete(doc.reference)
deleted_in_batch += 1
if deleted_in_batch == 0:
break
batch.commit()
deleted_count += deleted_in_batch
# If we deleted less than batch_size, we're done
if deleted_in_batch < batch_size:
break
if deleted_count > 0:
logger.info(f"Deleted {deleted_count} logs for job {job_id}")
return deleted_count
except Exception as e:
logger.error(f"Error deleting logs subcollection for job {job_id}: {e}")
return 0
# ============================================
# Token Management Methods
# ============================================
def create_token(self, token: str, token_data: Dict[str, Any]) -> None:
"""Create a new access token in Firestore."""
try:
doc_ref = self.db.collection(self.tokens_collection).document(token)
doc_ref.set(token_data)
logger.info(f"Created token in Firestore")
except Exception as e:
logger.error(f"Error creating token: {e}")
raise
def get_token(self, token: str) -> Optional[Dict[str, Any]]:
"""Get token data by token string."""
try:
doc_ref = self.db.collection(self.tokens_collection).document(token)
doc = doc_ref.get()
if not doc.exists:
return None
return doc.to_dict()
except Exception as e:
logger.error(f"Error getting token: {e}")
return None
def update_token(self, token: str, updates: Dict[str, Any]) -> None:
"""Update token data."""
try:
doc_ref = self.db.collection(self.tokens_collection).document(token)
doc_ref.update(updates)
logger.info(f"Updated token in Firestore")
except Exception as e:
logger.error(f"Error updating token: {e}")
raise
def increment_token_usage(self, token: str, job_id: str) -> None:
"""Increment token usage count and add job to history."""
try:
doc_ref = self.db.collection(self.tokens_collection).document(token)
# Use Firestore transaction to ensure atomic increment
@firestore.transactional
def update_in_transaction(transaction, doc_ref):
snapshot = doc_ref.get(transaction=transaction)
if not snapshot.exists:
raise ValueError("Token not found")
data = snapshot.to_dict()
current_usage = data.get("usage_count", 0)
jobs = data.get("jobs", [])
# Increment usage
transaction.update(doc_ref, {
"usage_count": current_usage + 1,
"last_used": datetime.utcnow(),
"jobs": firestore.ArrayUnion([{
"job_id": job_id,
"created_at": datetime.utcnow()
}])
})
transaction = self.db.transaction()
update_in_transaction(transaction, doc_ref)
logger.info(f"Incremented token usage for job {job_id}")
except Exception as e:
logger.error(f"Error incrementing token usage: {e}")
raise
def list_tokens(self) -> List[Dict[str, Any]]:
"""List all tokens (admin only)."""
try:
docs = self.db.collection(self.tokens_collection).stream()
tokens = [doc.to_dict() for doc in docs]
logger.info(f"Retrieved {len(tokens)} tokens from Firestore")
return tokens
except Exception as e:
logger.error(f"Error listing tokens: {e}")
return []
-573
View File
@@ -1,573 +0,0 @@
"""
Client for the remote flacfetch HTTP API service.
This client communicates with a dedicated flacfetch VM that handles:
- BitTorrent downloads from private trackers (RED, OPS)
- YouTube downloads
- GCS uploads of downloaded files
The flacfetch service provides:
- Full peer connectivity for torrents (not possible in Cloud Run)
- Indefinite seeding of completed torrents
- Automatic disk cleanup
Usage:
client = get_flacfetch_client()
if client:
# Search for audio
search_result = await client.search("ABBA", "Waterloo")
# Download the best result
download_id = await client.download(
search_id=search_result["search_id"],
result_index=0,
gcs_path="uploads/job123/audio/",
)
# Wait for completion
result = await client.wait_for_download(download_id)
print(f"Downloaded to: {result['gcs_path']}")
"""
import asyncio
import logging
from typing import Any, Dict, List, Optional
import httpx
logger = logging.getLogger(__name__)
class FlacfetchServiceError(Exception):
"""Error communicating with or returned from flacfetch service."""
pass
class FlacfetchClient:
"""
Client for remote flacfetch HTTP API.
All endpoints require authentication via X-API-Key header.
"""
def __init__(
self,
base_url: str,
api_key: str,
timeout: int = 60,
):
"""
Initialize flacfetch client.
Args:
base_url: Base URL of flacfetch service (e.g., http://10.0.0.5:8080)
api_key: API key for authentication
timeout: Default request timeout in seconds
"""
self.base_url = base_url.rstrip('/')
self.api_key = api_key
self.timeout = timeout
logger.info(f"FlacfetchClient initialized with base_url={self.base_url}")
def _headers(self) -> Dict[str, str]:
"""Get request headers with authentication."""
return {
"X-API-Key": self.api_key,
"Content-Type": "application/json",
}
async def health_check(self) -> Dict[str, Any]:
"""
Check if flacfetch service is healthy.
Returns:
Health status dict with transmission, disk, and provider info
Raises:
FlacfetchServiceError: If service is unhealthy or unreachable
"""
try:
async with httpx.AsyncClient() as client:
resp = await client.get(
f"{self.base_url}/health",
headers=self._headers(),
timeout=10,
)
resp.raise_for_status()
data = resp.json()
if data.get("status") not in ["healthy", "degraded"]:
raise FlacfetchServiceError(f"Service unhealthy: {data}")
return data
except httpx.RequestError as e:
raise FlacfetchServiceError(f"Cannot reach flacfetch service: {e}")
except httpx.HTTPStatusError as e:
raise FlacfetchServiceError(f"Health check failed: {e.response.status_code}")
async def search(
self,
artist: str,
title: str,
) -> Dict[str, Any]:
"""
Search for audio matching artist and title.
Args:
artist: Artist name
title: Track title
Returns:
Search response dict with search_id and results list
Raises:
FlacfetchServiceError: On search failure
"""
try:
async with httpx.AsyncClient() as client:
resp = await client.post(
f"{self.base_url}/search",
headers=self._headers(),
json={"artist": artist, "title": title},
timeout=self.timeout,
)
if resp.status_code == 404:
# No results found - return empty results
return {
"search_id": None,
"artist": artist,
"title": title,
"results": [],
"results_count": 0,
}
resp.raise_for_status()
return resp.json()
except httpx.RequestError as e:
raise FlacfetchServiceError(f"Search request failed: {e}")
except httpx.HTTPStatusError as e:
raise FlacfetchServiceError(f"Search failed: {e.response.status_code} - {e.response.text}")
async def download(
self,
search_id: str,
result_index: int,
output_filename: Optional[str] = None,
gcs_path: Optional[str] = None,
) -> str:
"""
Start downloading an audio file.
Args:
search_id: Search ID from previous search
result_index: Index of result to download
output_filename: Optional custom filename (without extension)
gcs_path: GCS path for upload (e.g., "uploads/job123/audio/")
Returns:
Download ID for tracking progress
Raises:
FlacfetchServiceError: On download start failure
"""
try:
async with httpx.AsyncClient() as client:
payload = {
"search_id": search_id,
"result_index": result_index,
}
if output_filename:
payload["output_filename"] = output_filename
if gcs_path:
payload["upload_to_gcs"] = True
payload["gcs_path"] = gcs_path
resp = await client.post(
f"{self.base_url}/download",
headers=self._headers(),
json=payload,
timeout=self.timeout,
)
resp.raise_for_status()
data = resp.json()
return data["download_id"]
except httpx.RequestError as e:
raise FlacfetchServiceError(f"Download request failed: {e}")
except httpx.HTTPStatusError as e:
raise FlacfetchServiceError(f"Download start failed: {e.response.status_code} - {e.response.text}")
async def download_by_id(
self,
source_name: str,
source_id: str,
output_filename: Optional[str] = None,
target_file: Optional[str] = None,
download_url: Optional[str] = None,
gcs_path: Optional[str] = None,
) -> str:
"""
Start downloading directly by source ID (no prior search required).
This is useful when you have stored the source_id from a previous search
and want to download later without re-searching.
Args:
source_name: Provider name (RED, OPS, YouTube, Spotify)
source_id: Source-specific ID (torrent ID, video ID, track ID)
output_filename: Optional custom filename (without extension)
target_file: For torrents, specific file to extract
download_url: For YouTube/Spotify, direct URL (optional)
gcs_path: GCS path for upload (e.g., "uploads/job123/audio/")
Returns:
Download ID for tracking progress
Raises:
FlacfetchServiceError: On download start failure
"""
try:
async with httpx.AsyncClient() as client:
payload = {
"source_name": source_name,
"source_id": source_id,
}
if output_filename:
payload["output_filename"] = output_filename
if target_file:
payload["target_file"] = target_file
if download_url:
payload["download_url"] = download_url
if gcs_path:
payload["upload_to_gcs"] = True
payload["gcs_path"] = gcs_path
resp = await client.post(
f"{self.base_url}/download-by-id",
headers=self._headers(),
json=payload,
timeout=self.timeout,
)
resp.raise_for_status()
data = resp.json()
return data["download_id"]
except httpx.RequestError as e:
raise FlacfetchServiceError(f"Download by ID request failed: {e}")
except httpx.HTTPStatusError as e:
raise FlacfetchServiceError(f"Download by ID failed: {e.response.status_code} - {e.response.text}")
async def get_download_status(self, download_id: str) -> Dict[str, Any]:
"""
Get the current status of a download.
Args:
download_id: Download ID from start_download
Returns:
Status dict with progress, speed, path info
Raises:
FlacfetchServiceError: On status check failure
"""
try:
async with httpx.AsyncClient() as client:
resp = await client.get(
f"{self.base_url}/download/{download_id}/status",
headers=self._headers(),
timeout=10,
)
resp.raise_for_status()
return resp.json()
except httpx.RequestError as e:
raise FlacfetchServiceError(f"Status request failed: {e}")
except httpx.HTTPStatusError as e:
if e.response.status_code == 404:
raise FlacfetchServiceError(f"Download not found: {download_id}")
raise FlacfetchServiceError(f"Status check failed: {e.response.status_code}")
async def wait_for_download(
self,
download_id: str,
timeout: int = 600,
poll_interval: float = 2.0,
progress_callback: Optional[callable] = None,
) -> Dict[str, Any]:
"""
Wait for a download to complete.
Args:
download_id: Download ID to wait for
timeout: Maximum wait time in seconds
poll_interval: Time between status checks
progress_callback: Optional callback(status_dict) for progress updates
Returns:
Final status dict with output_path or gcs_path
Raises:
FlacfetchServiceError: On download failure or timeout
"""
elapsed = 0.0
while elapsed < timeout:
status = await self.get_download_status(download_id)
if progress_callback:
try:
progress_callback(status)
except Exception as e:
logger.warning(f"Progress callback error: {e}")
download_status = status.get("status")
if download_status in ["complete", "seeding"]:
logger.info(f"Download {download_id} complete: {status.get('gcs_path') or status.get('output_path')}")
return status
elif download_status == "failed":
error = status.get("error", "Unknown error")
raise FlacfetchServiceError(f"Download failed: {error}")
elif download_status == "cancelled":
raise FlacfetchServiceError("Download was cancelled")
# Log progress
progress = status.get("progress", 0)
speed = status.get("download_speed_kbps", 0)
peers = status.get("peers", 0)
logger.debug(
f"Download {download_id}: {progress:.1f}% "
f"({speed:.1f} KB/s, {peers} peers)"
)
await asyncio.sleep(poll_interval)
elapsed += poll_interval
raise FlacfetchServiceError(f"Download timed out after {timeout}s")
async def list_torrents(self) -> Dict[str, Any]:
"""
List all torrents in Transmission.
Returns:
Torrent list response with torrent info and totals
"""
try:
async with httpx.AsyncClient() as client:
resp = await client.get(
f"{self.base_url}/torrents",
headers=self._headers(),
timeout=30,
)
resp.raise_for_status()
return resp.json()
except httpx.RequestError as e:
raise FlacfetchServiceError(f"List torrents failed: {e}")
except httpx.HTTPStatusError as e:
raise FlacfetchServiceError(f"List torrents failed: {e.response.status_code}")
async def delete_torrent(
self,
torrent_id: int,
delete_data: bool = True,
) -> Dict[str, Any]:
"""
Delete a torrent from Transmission.
Args:
torrent_id: Transmission torrent ID
delete_data: Also delete downloaded files
Returns:
Delete response
"""
try:
async with httpx.AsyncClient() as client:
resp = await client.delete(
f"{self.base_url}/torrents/{torrent_id}",
headers=self._headers(),
params={"delete_data": str(delete_data).lower()},
timeout=30,
)
resp.raise_for_status()
return resp.json()
except httpx.RequestError as e:
raise FlacfetchServiceError(f"Delete torrent failed: {e}")
except httpx.HTTPStatusError as e:
raise FlacfetchServiceError(f"Delete torrent failed: {e.response.status_code}")
async def cleanup_torrents(
self,
strategy: str = "oldest",
target_free_gb: float = 10.0,
) -> 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
"""
try:
async with httpx.AsyncClient() as client:
resp = await client.post(
f"{self.base_url}/torrents/cleanup",
headers=self._headers(),
json={
"strategy": strategy,
"target_free_gb": target_free_gb,
},
timeout=60,
)
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
def get_flacfetch_client() -> Optional[FlacfetchClient]:
"""
Get the flacfetch client if configured.
Returns:
FlacfetchClient instance if FLACFETCH_API_URL and FLACFETCH_API_KEY are set,
None otherwise (indicating local-only mode).
"""
global _client
if _client is None:
from backend.config import get_settings
settings = get_settings()
if settings.flacfetch_api_url and settings.flacfetch_api_key:
_client = FlacfetchClient(
base_url=settings.flacfetch_api_url,
api_key=settings.flacfetch_api_key,
)
logger.info("FlacfetchClient initialized for remote service")
else:
logger.debug("FlacfetchClient not configured (missing URL or API key)")
return _client
def reset_flacfetch_client():
"""Reset the singleton client (for testing)."""
global _client
_client = None
-352
View File
@@ -1,352 +0,0 @@
"""Native Google Drive API service for cloud backend.
This service provides Google Drive operations using the native API,
for uploading files to public share folders. It handles:
- Folder creation and lookup
- File uploads with resumable upload support
- Uploading to organized folder structure (MP4/, MP4-720p/, CDG/)
Credentials are loaded from Google Cloud Secret Manager and can be
shared with YouTube credentials if scopes include drive.file.
"""
import json
import logging
import os
from typing import Any, Dict, Optional
from backend.config import get_settings
logger = logging.getLogger(__name__)
class GoogleDriveService:
"""Google Drive operations using native API."""
# Secret Manager secret name for Google Drive credentials
# Can be same as YouTube if scopes include drive.file
GDRIVE_CREDENTIALS_SECRET = "gdrive-oauth-credentials"
def __init__(self):
self.settings = get_settings()
self._service = None
self._credentials_data: Optional[Dict[str, Any]] = None
self._loaded = False
def _load_credentials(self) -> Optional[Dict[str, Any]]:
"""Load OAuth credentials from Secret Manager."""
if self._loaded:
return self._credentials_data
try:
creds_json = self.settings.get_secret(self.GDRIVE_CREDENTIALS_SECRET)
if not creds_json:
# Try falling back to YouTube credentials (may have drive scope)
logger.info(
"Google Drive credentials not found, trying YouTube credentials"
)
creds_json = self.settings.get_secret("youtube-oauth-credentials")
if not creds_json:
logger.warning("Google Drive credentials not found in Secret Manager")
self._loaded = True
return None
self._credentials_data = json.loads(creds_json)
# Validate required fields
required_fields = ["refresh_token", "client_id", "client_secret"]
missing = [f for f in required_fields if not self._credentials_data.get(f)]
if missing:
logger.error(f"Google Drive credentials missing required fields: {missing}")
self._credentials_data = None
self._loaded = True
return None
logger.info("Google Drive credentials loaded successfully from Secret Manager")
self._loaded = True
return self._credentials_data
except json.JSONDecodeError as e:
logger.error(f"Failed to parse Google Drive credentials JSON: {e}")
self._loaded = True
return None
except Exception as e:
logger.error(f"Failed to load Google Drive credentials: {e}")
self._loaded = True
return None
@property
def is_configured(self) -> bool:
"""Check if Google Drive credentials are available."""
creds = self._load_credentials()
return creds is not None
@property
def service(self):
"""Get or create Google Drive service."""
if self._service is None:
# Import here to avoid import errors if google packages not installed
try:
from google.oauth2.credentials import Credentials
from googleapiclient.discovery import build
except ImportError:
raise ImportError(
"google-api-python-client and google-auth packages are required. "
"Install them with: pip install google-api-python-client google-auth"
)
creds_data = self._load_credentials()
if not creds_data:
raise RuntimeError(
"Google Drive credentials not configured in Secret Manager"
)
# Create credentials object
credentials = Credentials(
token=creds_data.get("token"),
refresh_token=creds_data.get("refresh_token"),
token_uri=creds_data.get(
"token_uri", "https://oauth2.googleapis.com/token"
),
client_id=creds_data.get("client_id"),
client_secret=creds_data.get("client_secret"),
scopes=creds_data.get(
"scopes", ["https://www.googleapis.com/auth/drive.file"]
),
)
self._service = build("drive", "v3", credentials=credentials)
logger.info("Google Drive service initialized successfully")
return self._service
def get_or_create_folder(self, parent_id: str, folder_name: str) -> str:
"""
Get existing folder or create new one, return folder ID.
Args:
parent_id: Parent folder ID
folder_name: Name of folder to find or create
Returns:
Folder ID
"""
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"and mimeType='application/vnd.google-apps.folder' and trashed=false"
)
results = self.service.files().list(q=query, fields="files(id, name)").execute()
if results.get("files"):
folder_id = results["files"][0]["id"]
logger.info(f"Found existing folder '{folder_name}': {folder_id}")
return folder_id
# Create folder
logger.info(f"Creating new folder '{folder_name}'")
metadata = {
"name": folder_name,
"mimeType": "application/vnd.google-apps.folder",
"parents": [parent_id],
}
folder = self.service.files().create(body=metadata, fields="id").execute()
folder_id = folder["id"]
logger.info(f"Created folder '{folder_name}': {folder_id}")
return folder_id
def upload_file(
self,
local_path: str,
parent_id: str,
filename: str,
replace_existing: bool = True,
) -> str:
"""
Upload a file to a specific Drive folder.
Args:
local_path: Local file path
parent_id: Parent folder ID in Google Drive
filename: Name for the file in Drive
replace_existing: If True, delete existing file with same name first
Returns:
File ID of uploaded file
"""
from googleapiclient.http import MediaFileUpload
file_size = os.path.getsize(local_path)
logger.info(
f"Uploading {local_path} ({file_size / 1024 / 1024:.1f} MB) "
f"as '{filename}' to folder {parent_id}"
)
# Determine MIME type
ext = os.path.splitext(local_path)[1].lower()
mime_types = {
".mp4": "video/mp4",
".mkv": "video/x-matroska",
".zip": "application/zip",
".flac": "audio/flac",
".mp3": "audio/mpeg",
".wav": "audio/wav",
".png": "image/png",
".jpg": "image/jpeg",
".jpeg": "image/jpeg",
}
mime_type = mime_types.get(ext, "application/octet-stream")
# 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"
)
results = self.service.files().list(q=query, fields="files(id)").execute()
for existing_file in results.get("files", []):
logger.info(f"Deleting existing file: {existing_file['id']}")
self.service.files().delete(fileId=existing_file["id"]).execute()
# Upload file
metadata = {"name": filename, "parents": [parent_id]}
media = MediaFileUpload(local_path, mimetype=mime_type, resumable=True)
file_result = (
self.service.files().create(body=metadata, media_body=media, fields="id").execute()
)
file_id = file_result["id"]
logger.info(f"Successfully uploaded '{filename}': {file_id}")
return file_id
def upload_to_public_share(
self,
root_folder_id: str,
brand_code: str,
base_name: str,
output_files: dict,
) -> Dict[str, str]:
"""
Upload final files to public share folder structure.
Creates/uses subfolders:
- MP4/{brand_code} - {base_name}.mp4 (lossy 4k)
- MP4-720p/{brand_code} - {base_name}.mp4
- CDG/{brand_code} - {base_name}.zip
Args:
root_folder_id: Google Drive folder ID for public share root
brand_code: Brand code (e.g., "NOMAD-1163")
base_name: Base filename (e.g., "Artist - Title")
output_files: Dictionary with output file paths:
- final_karaoke_lossy_mp4: 4K lossy MP4
- final_karaoke_lossy_720p_mp4: 720p lossy MP4
- final_karaoke_cdg_zip: CDG package ZIP
Returns:
Dictionary mapping category to uploaded file ID
"""
filename_base = f"{brand_code} - {base_name}"
uploaded_files = {}
logger.info(
f"Uploading public share files to Google Drive folder {root_folder_id}"
)
logger.info(f"Filename base: {filename_base}")
# Upload lossy 4k to MP4/
lossy_mp4_path = output_files.get("final_karaoke_lossy_mp4")
if lossy_mp4_path and os.path.exists(lossy_mp4_path):
mp4_folder_id = self.get_or_create_folder(root_folder_id, "MP4")
file_id = self.upload_file(
lossy_mp4_path,
mp4_folder_id,
f"{filename_base}.mp4",
)
uploaded_files["mp4"] = file_id
logger.info(f"Uploaded 4K MP4 to MP4/ folder")
# Upload 720p to MP4-720p/
mp4_720p_path = output_files.get("final_karaoke_lossy_720p_mp4")
if mp4_720p_path and os.path.exists(mp4_720p_path):
mp4_720_folder_id = self.get_or_create_folder(root_folder_id, "MP4-720p")
file_id = self.upload_file(
mp4_720p_path,
mp4_720_folder_id,
f"{filename_base}.mp4",
)
uploaded_files["mp4_720p"] = file_id
logger.info(f"Uploaded 720p MP4 to MP4-720p/ folder")
# Upload CDG ZIP to CDG/
cdg_zip_path = output_files.get("final_karaoke_cdg_zip")
if cdg_zip_path and os.path.exists(cdg_zip_path):
cdg_folder_id = self.get_or_create_folder(root_folder_id, "CDG")
file_id = self.upload_file(
cdg_zip_path,
cdg_folder_id,
f"{filename_base}.zip",
)
uploaded_files["cdg"] = file_id
logger.info(f"Uploaded CDG ZIP to CDG/ folder")
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
def get_gdrive_service() -> GoogleDriveService:
"""Get the singleton Google Drive service instance."""
global _gdrive_service
if _gdrive_service is None:
_gdrive_service = GoogleDriveService()
return _gdrive_service
-258
View File
@@ -1,258 +0,0 @@
"""
Job-aware logging utilities.
This module provides a context manager and logging handler that captures
Python logging output and forwards it to Firestore for real-time streaming
to the CLI.
Usage:
with JobLogContext(job_id, worker="review") as log_context:
# Any logging within this block will be captured and sent to Firestore
logger.info("Processing...") # This will be stored and streamed to CLI
"""
import logging
import threading
from typing import Optional
from contextlib import contextmanager
from datetime import datetime
from backend.services.firestore_service import FirestoreService
class JobLogHandler(logging.Handler):
"""
A logging handler that forwards log records to Firestore for job tracking.
This enables real-time log streaming to the CLI during long-running operations
like lyrics correction, preview generation, etc.
"""
def __init__(
self,
job_id: str,
worker: str = "review",
firestore: Optional[FirestoreService] = None,
min_level: int = logging.INFO,
batch_size: int = 1, # Send immediately for real-time experience
):
"""
Initialize the job log handler.
Args:
job_id: The job ID to associate logs with
worker: Worker name (e.g., "review", "add-lyrics", "preview")
firestore: FirestoreService instance (creates one if not provided)
min_level: Minimum log level to capture (default INFO)
batch_size: Number of logs to batch before sending (1 = immediate)
"""
super().__init__()
self.job_id = job_id
self.worker = worker
self.firestore = firestore or FirestoreService()
self.min_level = min_level
self.batch_size = batch_size
self._log_buffer = []
self._lock = threading.Lock()
# Set the handler's level
self.setLevel(min_level)
# Create a formatter that extracts the useful parts
self.setFormatter(logging.Formatter('%(message)s'))
def emit(self, record: logging.LogRecord) -> None:
"""
Process a log record and send it to Firestore.
This method is called by the logging framework for each log message.
"""
try:
# Skip if below minimum level
if record.levelno < self.min_level:
return
# Format the message
message = self.format(record)
# Truncate very long messages
if len(message) > 1000:
message = message[:997] + "..."
# Create log entry
log_entry = {
'timestamp': datetime.utcnow().isoformat() + 'Z',
'level': record.levelname,
'worker': self.worker,
'message': message,
}
# Add to buffer
with self._lock:
self._log_buffer.append(log_entry)
# Flush if batch size reached
if len(self._log_buffer) >= self.batch_size:
self._flush_buffer()
except Exception:
# Never let logging errors propagate
self.handleError(record)
def _flush_buffer(self) -> None:
"""Flush buffered logs to Firestore."""
if not self._log_buffer:
return
try:
for log_entry in self._log_buffer:
self.firestore.append_worker_log(self.job_id, log_entry)
self._log_buffer = []
except Exception:
# If Firestore fails, just clear buffer and continue
self._log_buffer = []
def flush(self) -> None:
"""Flush any remaining buffered logs."""
with self._lock:
self._flush_buffer()
def close(self) -> None:
"""Clean up the handler."""
self.flush()
super().close()
@contextmanager
def job_log_context(
job_id: str,
worker: str = "review",
logger_names: Optional[list] = None,
min_level: int = logging.INFO,
):
"""
Context manager that captures logs and forwards them to Firestore.
This allows the CLI to see real-time logs from operations like
add-lyrics, preview generation, etc.
Args:
job_id: Job ID to associate logs with
worker: Worker name for log categorization
logger_names: List of logger names to capture (None = capture common loggers)
min_level: Minimum log level to capture
Usage:
with job_log_context(job_id, worker="add-lyrics"):
# All logging in this block will be captured
correction_operations.add_lyrics_source(...)
"""
# Default loggers to capture - these cover most of our processing
# Note: We intentionally DON'T include the root logger ('') to avoid
# duplicate log entries since logs propagate up the logger hierarchy.
# Only capture at the top-level package loggers.
if logger_names is None:
logger_names = [
'backend.api.routes.review',
'lyrics_transcriber',
'karaoke_gen',
]
# Create the handler
handler = JobLogHandler(
job_id=job_id,
worker=worker,
min_level=min_level,
)
# Add handler to all specified loggers
loggers = []
for name in logger_names:
log = logging.getLogger(name) if name else logging.getLogger()
log.addHandler(handler)
loggers.append(log)
try:
# Log start
handler.emit(logging.LogRecord(
name='job_log_context',
level=logging.INFO,
pathname='',
lineno=0,
msg=f"🚀 Starting {worker} operation for job {job_id}",
args=(),
exc_info=None,
))
yield handler
finally:
# Log completion
handler.emit(logging.LogRecord(
name='job_log_context',
level=logging.INFO,
pathname='',
lineno=0,
msg=f"✅ Completed {worker} operation for job {job_id}",
args=(),
exc_info=None,
))
# Flush remaining logs
handler.flush()
# Remove handler from all loggers
for log in loggers:
log.removeHandler(handler)
# Close handler
handler.close()
class JobLogger:
"""
A convenience class for direct logging to a job's log stream.
Use this when you want to log specific messages without capturing
all logging output.
"""
def __init__(self, job_id: str, worker: str = "review"):
"""
Initialize job logger.
Args:
job_id: Job ID to log to
worker: Worker name for log categorization
"""
self.job_id = job_id
self.worker = worker
self.firestore = FirestoreService()
def _log(self, level: str, message: str) -> None:
"""Internal logging method."""
log_entry = {
'timestamp': datetime.utcnow().isoformat() + 'Z',
'level': level,
'worker': self.worker,
'message': message[:1000],
}
try:
self.firestore.append_worker_log(self.job_id, log_entry)
except Exception:
pass # Don't let logging errors propagate
def info(self, message: str) -> None:
"""Log an INFO message."""
self._log('INFO', message)
def warning(self, message: str) -> None:
"""Log a WARNING message."""
self._log('WARNING', message)
def error(self, message: str) -> None:
"""Log an ERROR message."""
self._log('ERROR', message)
def debug(self, message: str) -> None:
"""Log a DEBUG message."""
self._log('DEBUG', message)
-704
View File
@@ -1,704 +0,0 @@
"""
Job management and queue operations.
This module handles the complete job lifecycle including:
- Job creation and initialization
- State transitions and validation
- Worker coordination (parallel audio + lyrics processing)
- Progress tracking and timeline events
- Error handling and retries
"""
import logging
import uuid
from datetime import datetime
from typing import Optional, Dict, Any, List
from backend.config import settings
from backend.models.job import Job, JobStatus, JobCreate, STATE_TRANSITIONS
from backend.models.worker_log import WorkerLogEntry
from backend.services.firestore_service import FirestoreService
from backend.services.storage_service import StorageService
logger = logging.getLogger(__name__)
class JobManager:
"""Manager for job lifecycle and state."""
def __init__(self):
"""Initialize job manager with required services."""
self.firestore = FirestoreService()
self.storage = StorageService()
def create_job(self, job_create: JobCreate) -> Job:
"""
Create a new job with initial state PENDING.
Jobs start in PENDING state and transition to DOWNLOADING
when a worker picks them up.
"""
job_id = str(uuid.uuid4())[:8]
now = datetime.utcnow()
job = Job(
job_id=job_id,
status=JobStatus.PENDING, # New state machine starts with PENDING
progress=0,
created_at=now,
updated_at=now,
url=str(job_create.url) if job_create.url else None,
artist=job_create.artist,
title=job_create.title,
# User preferences
enable_cdg=job_create.enable_cdg,
enable_txt=job_create.enable_txt,
enable_youtube_upload=job_create.enable_youtube_upload,
youtube_description=job_create.youtube_description,
youtube_description_template=job_create.youtube_description_template, # video_worker reads this
webhook_url=job_create.webhook_url,
user_email=job_create.user_email,
# Distribution settings
brand_prefix=job_create.brand_prefix,
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,
keep_brand_code=job_create.keep_brand_code,
# Request metadata (for tracking and filtering)
request_metadata=job_create.request_metadata,
)
self.firestore.create_job(job)
logger.info(f"Created new job {job_id} with status PENDING")
return job
def get_job(self, job_id: str) -> Optional[Job]:
"""Get a job by ID."""
return self.firestore.get_job(job_id)
def update_job_status(
self,
job_id: str,
status: JobStatus,
progress: Optional[int] = None,
message: Optional[str] = None,
**kwargs
) -> None:
"""Update job status with timeline tracking."""
self.firestore.update_job_status(
job_id=job_id,
status=status,
progress=progress,
message=message,
**kwargs
)
def update_job(self, job_id: str, updates: Dict[str, Any]) -> None:
"""Update job with arbitrary fields."""
self.firestore.update_job(job_id, updates)
def list_jobs(
self,
status: Optional[JobStatus] = None,
environment: Optional[str] = None,
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
"""
return self.firestore.list_jobs(
status=status,
environment=environment,
client_id=client_id,
created_after=created_after,
created_before=created_before,
user_email=user_email,
limit=limit
)
def delete_jobs_by_filter(
self,
environment: Optional[str] = None,
client_id: Optional[str] = None,
status: Optional[JobStatus] = None,
created_before: Optional[datetime] = None,
delete_files: bool = True
) -> Dict[str, Any]:
"""
Delete multiple jobs matching filter criteria.
CAUTION: This is a destructive operation. Use carefully.
Args:
environment: Delete jobs with this environment (e.g., "test")
client_id: Delete jobs from this client
status: Delete jobs with this status
created_before: Delete jobs created before this datetime
delete_files: Also delete GCS files (default True)
Returns:
Dict with deletion statistics
"""
# First get matching jobs to delete their files
if delete_files:
jobs = self.firestore.list_jobs(
status=status,
environment=environment,
client_id=client_id,
created_before=created_before,
limit=10000 # High limit for deletion
)
files_deleted = 0
for job in jobs:
# Delete files from various locations
try:
# Delete uploads folder
self.storage.delete_folder(f"uploads/{job.job_id}/")
# Delete jobs folder
self.storage.delete_folder(f"jobs/{job.job_id}/")
files_deleted += 1
except Exception as e:
logger.warning(f"Error deleting files for job {job.job_id}: {e}")
# Delete the jobs from Firestore
deleted_count = self.firestore.delete_jobs_by_filter(
environment=environment,
client_id=client_id,
status=status,
created_before=created_before
)
return {
'jobs_deleted': deleted_count,
'files_deleted': files_deleted if delete_files else 0
}
def mark_job_error(self, job_id: str, error_message: str) -> None:
"""Mark a job as errored."""
self.firestore.update_job_status(
job_id=job_id,
status=JobStatus.ERROR,
progress=0,
message=error_message,
error_message=error_message
)
logger.error(f"Job {job_id} marked as error: {error_message}")
def get_output_urls(self, job_id: str) -> Dict[str, str]:
"""Generate signed URLs for job output files."""
job = self.get_job(job_id)
if not job or not job.output_files:
return {}
urls = {}
for file_type, gcs_path in job.output_files.items():
try:
urls[file_type] = self.storage.generate_signed_url(gcs_path, expiration_minutes=120)
except Exception as e:
logger.error(f"Error generating URL for {file_type}: {e}")
return urls
def delete_job(self, job_id: str, delete_files: bool = True) -> None:
"""Delete a job, its files, and its logs subcollection."""
if delete_files:
job = self.get_job(job_id)
if job and job.output_files:
for gcs_path in job.output_files.values():
try:
self.storage.delete_file(gcs_path)
except Exception as e:
logger.error(f"Error deleting file {gcs_path}: {e}")
# Delete logs subcollection first (must be done before deleting parent doc)
try:
deleted_logs = self.firestore.delete_logs_subcollection(job_id)
if deleted_logs > 0:
logger.info(f"Deleted {deleted_logs} log entries for job {job_id}")
except Exception as e:
logger.warning(f"Error deleting logs subcollection for job {job_id}: {e}")
self.firestore.delete_job(job_id)
logger.info(f"Deleted job {job_id}")
def validate_state_transition(self, job_id: str, new_status: JobStatus) -> bool:
"""
Validate that a state transition is legal.
Returns:
True if transition is valid, False otherwise
"""
job = self.get_job(job_id)
if not job:
logger.error(f"Job {job_id} not found")
return False
current_status = job.status
valid_transitions = STATE_TRANSITIONS.get(current_status, [])
if new_status not in valid_transitions:
logger.error(
f"Invalid state transition for job {job_id}: "
f"{current_status} -> {new_status}. "
f"Valid transitions: {valid_transitions}"
)
return False
return True
def transition_to_state(
self,
job_id: str,
new_status: JobStatus,
progress: Optional[int] = None,
message: Optional[str] = None,
state_data_updates: Optional[Dict[str, Any]] = None
) -> bool:
"""
Transition job to new state with validation.
Args:
job_id: Job ID
new_status: Target state
progress: Progress percentage (0-100)
message: Timeline message
state_data_updates: Updates to state_data field
Returns:
True if transition succeeded, False otherwise
"""
if not self.validate_state_transition(job_id, new_status):
return False
updates = {
'status': new_status,
'updated_at': datetime.utcnow()
}
if progress is not None:
updates['progress'] = progress
# Generate review token when entering AWAITING_REVIEW state
if new_status == JobStatus.AWAITING_REVIEW:
from backend.api.dependencies import generate_review_token, get_review_token_expiry
review_token = generate_review_token()
review_token_expires = get_review_token_expiry(hours=48) # 48 hour expiry
updates['review_token'] = review_token
updates['review_token_expires_at'] = review_token_expires
logger.info(f"Generated review token for job {job_id}, expires in 48 hours")
# Generate instrumental token when entering AWAITING_INSTRUMENTAL_SELECTION state
if new_status == JobStatus.AWAITING_INSTRUMENTAL_SELECTION:
from backend.api.dependencies import generate_review_token, get_review_token_expiry
instrumental_token = generate_review_token() # Reuse same token generator
instrumental_token_expires = get_review_token_expiry(hours=48) # 48 hour expiry
updates['instrumental_token'] = instrumental_token
updates['instrumental_token_expires_at'] = instrumental_token_expires
logger.info(f"Generated instrumental token for job {job_id}, expires in 48 hours")
# If we have state_data_updates, merge them with existing state_data
merged_state_data = None
if state_data_updates:
job = self.get_job(job_id)
if job:
merged_state_data = {**job.state_data, **state_data_updates}
# Update job status (includes timeline event), passing state_data if present
if merged_state_data is not None:
self.update_job_status(
job_id=job_id,
status=new_status,
progress=progress,
message=message,
state_data=merged_state_data
)
else:
self.update_job_status(
job_id=job_id,
status=new_status,
progress=progress,
message=message
)
# Apply review token update separately if generated
if new_status == JobStatus.AWAITING_REVIEW and 'review_token' in updates:
self.firestore.update_job(job_id, {
'review_token': updates['review_token'],
'review_token_expires_at': updates['review_token_expires_at']
})
# Apply instrumental token update separately if generated
if new_status == JobStatus.AWAITING_INSTRUMENTAL_SELECTION and 'instrumental_token' in updates:
self.firestore.update_job(job_id, {
'instrumental_token': updates['instrumental_token'],
'instrumental_token_expires_at': updates['instrumental_token_expires_at']
})
logger.info(f"Job {job_id} transitioned to {new_status}")
return True
def update_state_data(self, job_id: str, key: str, value: Any) -> None:
"""
Update a specific key in the job's state_data field.
This is used by workers to store stage-specific metadata.
"""
job = self.get_job(job_id)
if not job:
logger.error(f"Job {job_id} not found")
return
state_data = job.state_data.copy()
state_data[key] = value
self.update_job(job_id, {'state_data': state_data})
logger.debug(f"Job {job_id} state_data updated: {key} = {value}")
def fail_job(self, job_id: str, error_message: str, error_details: Optional[Dict[str, Any]] = None) -> bool:
"""
Mark a job as failed with error information.
Args:
job_id: Job ID
error_message: Human-readable error message
error_details: Optional structured error details
Returns:
True if successful
"""
try:
# Update error fields
self.update_job(job_id, {
'error_message': error_message,
'error_details': error_details or {}
})
# Use update_job_status which handles timeline
self.update_job_status(
job_id=job_id,
status=JobStatus.FAILED,
message=error_message
)
logger.error(f"Job {job_id} failed: {error_message}")
return True
except Exception as e:
logger.error(f"Error marking job {job_id} as failed: {e}")
return False
def update_file_url(self, job_id: str, category: str, file_type: str, url: str) -> None:
"""
Update a file URL in the job's file_urls structure.
Args:
job_id: Job ID
category: Category (e.g., "stems", "lyrics", "finals")
file_type: File type within category (e.g., "clean", "lrc", "lossless_4k_mp4")
url: GCS URL
"""
job = self.get_job(job_id)
if not job:
logger.error(f"Job {job_id} not found")
return
file_urls = job.file_urls.copy()
if category not in file_urls:
file_urls[category] = {}
file_urls[category][file_type] = url
self.update_job(job_id, {'file_urls': file_urls})
logger.debug(f"Job {job_id} file URL updated: {category}.{file_type}")
def check_parallel_processing_complete(self, job_id: str) -> bool:
"""
Check if both parallel tracks (audio + lyrics) are complete.
This is called after audio_complete or lyrics_complete to determine
if we can proceed to screen generation.
Returns:
True if both tracks complete, False otherwise
"""
job = self.get_job(job_id)
if not job:
return False
audio_complete = job.state_data.get('audio_complete', False)
lyrics_complete = job.state_data.get('lyrics_complete', False)
return audio_complete and lyrics_complete
def mark_audio_complete(self, job_id: str) -> None:
"""
Mark audio processing as complete and check if can proceed.
If lyrics are also complete, automatically triggers screens worker.
"""
self.update_state_data(job_id, 'audio_complete', True)
if self.check_parallel_processing_complete(job_id):
logger.info(f"Job {job_id}: Both audio and lyrics complete, triggering screens worker")
# Transition happens in screens worker
# We just trigger it here
self._trigger_screens_worker(job_id)
def mark_lyrics_complete(self, job_id: str) -> None:
"""
Mark lyrics processing as complete and check if can proceed.
If audio is also complete, automatically triggers screens worker.
"""
self.update_state_data(job_id, 'lyrics_complete', True)
if self.check_parallel_processing_complete(job_id):
logger.info(f"Job {job_id}: Both audio and lyrics complete, triggering screens worker")
# Transition happens in screens worker
# We just trigger it here
self._trigger_screens_worker(job_id)
def _trigger_screens_worker(self, job_id: str) -> None:
"""
Trigger screens generation worker.
Uses WorkerService to make HTTP call to internal API.
This must be async, so we use asyncio to create a task.
"""
import asyncio
from backend.services.worker_service import get_worker_service
logger.info(f"Job {job_id}: Triggering screens worker")
# Create async task to trigger worker
# This allows us to call async code from sync context
async def _trigger():
worker_service = get_worker_service()
await worker_service.trigger_screens_worker(job_id)
# Create task in event loop
try:
loop = asyncio.get_event_loop()
if loop.is_running():
# If loop is already running, create task
asyncio.create_task(_trigger())
else:
# If no loop, run directly
asyncio.run(_trigger())
except RuntimeError:
# Fallback: just log
logger.warning(f"Job {job_id}: Could not trigger screens worker (no event loop)")
# TODO: In production, use message queue instead
def cancel_job(self, job_id: str, reason: Optional[str] = None) -> bool:
"""
Cancel a job.
Only jobs in non-terminal states can be cancelled.
"""
job = self.get_job(job_id)
if not job:
return False
terminal_states = [JobStatus.COMPLETE, JobStatus.FAILED, JobStatus.CANCELLED]
if job.status in terminal_states:
logger.warning(f"Cannot cancel job {job_id} in terminal state {job.status}")
return False
message = f"Job cancelled{f': {reason}' if reason else ''}"
self.update_job_status(
job_id=job_id,
status=JobStatus.CANCELLED,
message=message
)
logger.info(f"Job {job_id} cancelled")
return True
def mark_job_failed(
self,
job_id: str,
error_message: str,
error_details: Optional[Dict[str, Any]] = None
) -> None:
"""
Mark a job as failed with error details.
This replaces mark_job_error() with better error tracking.
"""
updates = {
'error_message': error_message
}
if error_details:
updates['error_details'] = error_details
self.firestore.update_job_status(
job_id=job_id,
status=JobStatus.FAILED,
progress=0,
message=f"Failed: {error_message}",
**updates
)
logger.error(f"Job {job_id} failed: {error_message}")
def increment_retry_count(self, job_id: str) -> int:
"""
Increment retry count for a job.
Returns:
New retry count
"""
job = self.get_job(job_id)
if not job:
return 0
new_count = job.retry_count + 1
self.update_job(job_id, {'retry_count': new_count})
return new_count
def append_worker_log(
self,
job_id: str,
worker: str,
level: str,
message: str,
max_logs: int = 500,
metadata: Optional[Dict[str, Any]] = None
) -> None:
"""
Append a log entry to the job's logs.
By default (USE_LOG_SUBCOLLECTION=true), logs are stored in a Firestore
subcollection (jobs/{job_id}/logs) to avoid the 1MB document size limit.
For backward compatibility (USE_LOG_SUBCOLLECTION=false), logs are stored
in the embedded worker_logs array using atomic ArrayUnion.
Args:
job_id: Job ID
worker: Worker name (audio, lyrics, screens, video, render, distribution)
level: Log level (DEBUG, INFO, WARNING, ERROR)
message: Log message
max_logs: Not used (kept for API compatibility)
metadata: Optional additional metadata dict
"""
if settings.use_log_subcollection:
# New subcollection approach - avoids 1MB limit
log_entry = WorkerLogEntry.create(
job_id=job_id,
worker=worker,
level=level,
message=message,
metadata=metadata
)
self.firestore.append_log_to_subcollection(job_id, log_entry)
else:
# Legacy embedded array approach
log_entry = {
'timestamp': datetime.utcnow().isoformat() + 'Z',
'level': level,
'worker': worker,
'message': message[:1000] # Truncate long messages
}
self.firestore.append_worker_log(job_id, log_entry)
def get_worker_logs(
self,
job_id: str,
since_index: int = 0,
worker: Optional[str] = None
) -> List[Dict[str, Any]]:
"""
Get worker logs for a job, optionally filtered by worker and index.
By default (USE_LOG_SUBCOLLECTION=true), logs are read from the
subcollection. Falls back to embedded array for older jobs.
Args:
job_id: Job ID
since_index: Return only logs after this index (for pagination)
worker: Filter by worker name (optional)
Returns:
List of log entries as dicts (in legacy format for API compatibility)
"""
if settings.use_log_subcollection:
# Try subcollection first
subcollection_logs = self.firestore.get_logs_from_subcollection(
job_id=job_id,
offset=since_index,
worker=worker,
limit=500
)
if subcollection_logs:
# Convert to legacy format for API compatibility
return [log.to_legacy_dict() for log in subcollection_logs]
# Fall through to check embedded array for older jobs
# Embedded array approach (legacy jobs or fallback)
job = self.get_job(job_id)
if not job or not job.worker_logs:
return []
logs = [log.dict() if hasattr(log, 'dict') else log for log in job.worker_logs]
# Filter by index
if since_index > 0:
logs = logs[since_index:]
# Filter by worker
if worker:
logs = [log for log in logs if log.get('worker') == worker]
return logs
def get_worker_logs_count(self, job_id: str) -> int:
"""
Get the total count of worker logs for a job.
Args:
job_id: Job ID
Returns:
Total count of logs
"""
if settings.use_log_subcollection:
# Try subcollection first
count = self.firestore.get_logs_count_from_subcollection(job_id)
if count > 0:
return count
# Fall through to check embedded array
# Embedded array (legacy jobs or fallback)
job = self.get_job(job_id)
if not job or not job.worker_logs:
return 0
return len(job.worker_logs)
-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
-413
View File
@@ -1,413 +0,0 @@
"""
Custom metrics for Cloud Monitoring.
This module provides application-level metrics for tracking job processing,
worker performance, and external API usage. Metrics can be viewed in:
1. Cloud Logging (via structured log entries)
2. Cloud Monitoring (via log-based metrics or OpenTelemetry)
The metrics service uses a pragmatic approach:
- Always emits metrics as structured log entries (works immediately)
- Uses the same JSON format as Cloud Logging
- Can be enhanced with OpenTelemetry metrics exporters when available
Usage:
from backend.services.metrics import metrics
# Record a job completion
metrics.record_job_completed("abc123", source="upload")
# Record worker duration
metrics.record_worker_duration("audio", 45.2, success=True)
# Record external API call
with metrics.time_external_api("modal"):
response = await modal_client.separate_audio(...)
"""
import logging
import time
from contextlib import contextmanager
from dataclasses import dataclass, field
from typing import Any, Dict, Optional
from backend.services.tracing import get_current_trace_id, get_current_span_id
logger = logging.getLogger("metrics")
@dataclass
class MetricLabels:
"""Common metric labels."""
job_id: Optional[str] = None
worker: Optional[str] = None
status: Optional[str] = None
source: Optional[str] = None
api: Optional[str] = None
operation: Optional[str] = None
bucket: Optional[str] = None
def to_dict(self) -> Dict[str, Any]:
"""Convert to dict, excluding None values."""
return {k: v for k, v in self.__dict__.items() if v is not None}
class MetricsService:
"""
Application metrics service.
Emits metrics as structured log entries that can be:
1. Queried directly in Cloud Logging
2. Converted to Cloud Monitoring metrics via log-based metrics
3. Exported via OpenTelemetry (when configured)
"""
def __init__(self):
"""Initialize the metrics service."""
self._logger = logging.getLogger("metrics")
# Ensure metrics logger outputs at INFO level
self._logger.setLevel(logging.INFO)
def _emit_metric(self, metric_name: str, metric_type: str, value: float, labels: Dict[str, Any]) -> None:
"""
Emit a metric as a structured log entry.
The log format is designed to be easily parsed by Cloud Logging
and converted to log-based metrics.
Args:
metric_name: Name of the metric (e.g., "jobs_total")
metric_type: Type of metric (counter, histogram, gauge)
value: Metric value
labels: Metric labels/dimensions
"""
# Add trace context if available
trace_id = get_current_trace_id()
span_id = get_current_span_id()
# Build metric entry
metric_entry = {
"metric_name": metric_name,
"metric_type": metric_type,
"metric_value": value,
**labels,
}
if trace_id:
metric_entry["trace_id"] = trace_id
if span_id:
metric_entry["span_id"] = span_id
# Emit as structured log entry
# Use INFO level so metrics always show up
self._logger.info(
f"METRIC {metric_name}={value}",
extra=metric_entry
)
# =========================================
# Job Metrics
# =========================================
def record_job_created(self, job_id: str, source: str = "unknown") -> None:
"""
Record a new job creation.
Args:
job_id: Job ID
source: Job source (upload, url, search)
"""
self._emit_metric(
metric_name="jobs_total",
metric_type="counter",
value=1,
labels={"job_id": job_id, "status": "created", "source": source}
)
def record_job_completed(self, job_id: str, source: str = "unknown") -> None:
"""
Record a job completion.
Args:
job_id: Job ID
source: Job source (upload, url, search)
"""
self._emit_metric(
metric_name="jobs_total",
metric_type="counter",
value=1,
labels={"job_id": job_id, "status": "completed", "source": source}
)
def record_job_failed(self, job_id: str, source: str = "unknown", error: Optional[str] = None) -> None:
"""
Record a job failure.
Args:
job_id: Job ID
source: Job source (upload, url, search)
error: Optional error message
"""
labels = {"job_id": job_id, "status": "failed", "source": source}
if error:
labels["error"] = error[:200] # Truncate long errors
self._emit_metric(
metric_name="jobs_total",
metric_type="counter",
value=1,
labels=labels
)
def record_job_duration(self, job_id: str, duration_seconds: float, source: str = "unknown") -> None:
"""
Record total job processing duration.
Args:
job_id: Job ID
duration_seconds: Total processing time in seconds
source: Job source (upload, url, search)
"""
self._emit_metric(
metric_name="job_duration_seconds",
metric_type="histogram",
value=duration_seconds,
labels={"job_id": job_id, "source": source}
)
# =========================================
# Worker Metrics
# =========================================
def record_worker_started(self, worker: str, job_id: str) -> None:
"""
Record a worker invocation start.
Args:
worker: Worker name (audio, lyrics, screens, video, render_video)
job_id: Job ID
"""
self._emit_metric(
metric_name="worker_invocations_total",
metric_type="counter",
value=1,
labels={"worker": worker, "job_id": job_id, "status": "started"}
)
def record_worker_duration(self, worker: str, duration_seconds: float, success: bool, job_id: Optional[str] = None) -> None:
"""
Record worker processing duration.
Args:
worker: Worker name
duration_seconds: Processing time in seconds
success: Whether worker completed successfully
job_id: Optional job ID
"""
labels = {
"worker": worker,
"success": str(success).lower(),
}
if job_id:
labels["job_id"] = job_id
self._emit_metric(
metric_name="job_stage_duration_seconds",
metric_type="histogram",
value=duration_seconds,
labels=labels
)
# Also emit a counter for success/failure tracking
self._emit_metric(
metric_name="worker_invocations_total",
metric_type="counter",
value=1,
labels={"worker": worker, "success": str(success).lower(), "job_id": job_id or "unknown"}
)
# =========================================
# GCS Metrics
# =========================================
def record_gcs_operation(
self,
operation: str,
bucket: str,
success: bool,
size_bytes: Optional[int] = None,
duration_seconds: Optional[float] = None,
job_id: Optional[str] = None,
) -> None:
"""
Record a GCS operation.
Args:
operation: Operation type (upload, download, delete)
bucket: GCS bucket name
success: Whether operation succeeded
size_bytes: Optional file size in bytes
duration_seconds: Optional operation duration
job_id: Optional job ID
"""
labels = {
"operation": operation,
"bucket": bucket,
"success": str(success).lower(),
}
if job_id:
labels["job_id"] = job_id
self._emit_metric(
metric_name="gcs_operations_total",
metric_type="counter",
value=1,
labels=labels
)
if size_bytes is not None:
self._emit_metric(
metric_name="gcs_operation_bytes",
metric_type="histogram",
value=size_bytes,
labels={**labels, "operation": operation}
)
if duration_seconds is not None:
self._emit_metric(
metric_name="gcs_operation_duration_seconds",
metric_type="histogram",
value=duration_seconds,
labels={**labels, "operation": operation}
)
# =========================================
# External API Metrics
# =========================================
def record_external_api_call(
self,
api: str,
success: bool,
duration_seconds: float,
job_id: Optional[str] = None,
error: Optional[str] = None,
) -> None:
"""
Record an external API call.
Args:
api: API name (modal, audioshake, genius, spotify)
success: Whether call succeeded
duration_seconds: API call duration
job_id: Optional job ID
error: Optional error message
"""
labels = {
"api": api,
"success": str(success).lower(),
}
if job_id:
labels["job_id"] = job_id
if error:
labels["error"] = error[:100] # Truncate
self._emit_metric(
metric_name="external_api_calls_total",
metric_type="counter",
value=1,
labels=labels
)
self._emit_metric(
metric_name="external_api_duration_seconds",
metric_type="histogram",
value=duration_seconds,
labels={"api": api, "success": str(success).lower()}
)
@contextmanager
def time_external_api(self, api: str, job_id: Optional[str] = None):
"""
Context manager to time an external API call.
Usage:
with metrics.time_external_api("modal", job_id) as timer:
response = await client.call_api()
timer.set_success(True)
Args:
api: API name
job_id: Optional job ID
Yields:
Timer object with set_success() method
"""
timer = _ApiTimer()
start_time = time.time()
try:
yield timer
except Exception as e:
timer.set_success(False)
timer.error = str(e)
raise
finally:
duration = time.time() - start_time
self.record_external_api_call(
api=api,
success=timer.success,
duration_seconds=duration,
job_id=job_id,
error=timer.error,
)
@contextmanager
def time_worker(self, worker: str, job_id: str):
"""
Context manager to time a worker execution.
Usage:
with metrics.time_worker("audio", job_id) as timer:
await process_audio()
timer.set_success(True)
Args:
worker: Worker name
job_id: Job ID
Yields:
Timer object with set_success() method
"""
timer = _ApiTimer()
self.record_worker_started(worker, job_id)
start_time = time.time()
try:
yield timer
except Exception as e:
timer.set_success(False)
raise
finally:
duration = time.time() - start_time
self.record_worker_duration(
worker=worker,
duration_seconds=duration,
success=timer.success,
job_id=job_id,
)
class _ApiTimer:
"""Helper class for tracking API call success state."""
def __init__(self):
self.success = True # Assume success unless set otherwise
self.error: Optional[str] = None
def set_success(self, success: bool) -> None:
self.success = success
# Global metrics instance
metrics = MetricsService()
-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
-106
View File
@@ -1,106 +0,0 @@
"""
Rclone configuration service for cloud storage integration.
This service manages the rclone configuration needed for Dropbox
and other cloud storage uploads from the backend workers.
"""
import logging
import os
import tempfile
from typing import Optional
from backend.config import get_settings
logger = logging.getLogger(__name__)
class RcloneService:
"""Service for managing rclone configuration."""
# Secret Manager secret name for rclone config
RCLONE_CONFIG_SECRET = "rclone-config"
def __init__(self):
self.settings = get_settings()
self._config_file: Optional[str] = None
self._config_loaded = False
def setup_rclone_config(self) -> bool:
"""
Load rclone config from Secret Manager and set up environment.
Writes the config to a temp file and sets RCLONE_CONFIG env var.
Returns:
True if successful, False otherwise
"""
if self._config_loaded:
logger.debug("Rclone config already loaded")
return True
try:
# Get rclone config from Secret Manager
config_content = self.settings.get_secret(self.RCLONE_CONFIG_SECRET)
if not config_content:
logger.warning("Rclone config not found in Secret Manager")
return False
# Write to a temp file
fd, config_path = tempfile.mkstemp(prefix="rclone_", suffix=".conf")
try:
with os.fdopen(fd, 'w') as f:
f.write(config_content)
self._config_file = config_path
# Set environment variable for rclone to find the config
os.environ["RCLONE_CONFIG"] = config_path
logger.info(f"Rclone config loaded and written to {config_path}")
self._config_loaded = True
return True
except Exception:
# Clean up the temp file on error
# Note: os.fdopen() takes ownership of fd, so it's already closed
# We only need to remove the temp file if it exists
if os.path.exists(config_path):
os.unlink(config_path)
raise
except Exception as e:
logger.error(f"Failed to setup rclone config: {e}")
return False
def cleanup(self) -> None:
"""Remove the temporary config file."""
if self._config_file and os.path.exists(self._config_file):
try:
os.unlink(self._config_file)
logger.debug(f"Cleaned up rclone config file: {self._config_file}")
except Exception as e:
logger.warning(f"Failed to cleanup rclone config: {e}")
# Always reset internal state and environment, even if the file was missing
if self._config_file is not None:
os.environ.pop("RCLONE_CONFIG", None)
self._config_file = None
self._config_loaded = False
@property
def is_configured(self) -> bool:
"""Check if rclone is configured and ready to use."""
return self._config_loaded and self._config_file is not None
# Singleton instance
_rclone_service: Optional[RcloneService] = None
def get_rclone_service() -> RcloneService:
"""Get the singleton rclone service instance."""
global _rclone_service
if _rclone_service is None:
_rclone_service = RcloneService()
return _rclone_service
-209
View File
@@ -1,209 +0,0 @@
"""
Google Cloud Storage operations for file management.
"""
import logging
import os
import json
from typing import Optional, BinaryIO, Any, Dict
from pathlib import Path
from google.cloud import storage
from datetime import timedelta
from backend.config import settings
logger = logging.getLogger(__name__)
class StorageService:
"""Service for Google Cloud Storage operations."""
def __init__(self):
"""Initialize GCS client."""
self.client = storage.Client(project=settings.google_cloud_project)
self.bucket = self.client.bucket(settings.gcs_bucket_name)
def upload_file(self, local_path: str, destination_path: str) -> str:
"""Upload a file to GCS."""
try:
blob = self.bucket.blob(destination_path)
blob.upload_from_filename(local_path)
logger.info(f"Uploaded {local_path} to gs://{settings.gcs_bucket_name}/{destination_path}")
return destination_path
except Exception as e:
logger.error(f"Error uploading file {local_path}: {e}")
raise
def upload_fileobj(self, file_obj: BinaryIO, destination_path: str, content_type: Optional[str] = None) -> str:
"""Upload a file object to GCS."""
try:
blob = self.bucket.blob(destination_path)
if content_type:
blob.content_type = content_type
blob.upload_from_file(file_obj, rewind=True)
logger.info(f"Uploaded file object to gs://{settings.gcs_bucket_name}/{destination_path}")
return destination_path
except Exception as e:
logger.error(f"Error uploading file object: {e}")
raise
def download_file(self, source_path: str, destination_path: str) -> str:
"""Download a file from GCS."""
try:
blob = self.bucket.blob(source_path)
blob.download_to_filename(destination_path)
logger.info(f"Downloaded gs://{settings.gcs_bucket_name}/{source_path} to {destination_path}")
return destination_path
except Exception as e:
logger.error(f"Error downloading file {source_path}: {e}")
raise
def generate_signed_url(self, blob_path: str, expiration_minutes: int = 60) -> str:
"""Generate a signed URL for downloading a file.
In Cloud Run, this uses the IAM signBlob API since we don't have
a private key available. Requires the service account to have
roles/iam.serviceAccountTokenCreator on itself.
"""
return self._generate_signed_url_internal(blob_path, "GET", expiration_minutes)
def generate_signed_upload_url(self, blob_path: str, content_type: str = "application/octet-stream", expiration_minutes: int = 60) -> str:
"""Generate a signed URL for uploading a file directly to GCS.
This allows clients to upload files directly to GCS without going through
the backend, bypassing any request body size limits.
Args:
blob_path: The destination path in GCS
content_type: The expected content type of the upload
expiration_minutes: How long the URL is valid for
Returns:
A signed URL that accepts PUT requests with the file content
"""
return self._generate_signed_url_internal(blob_path, "PUT", expiration_minutes, content_type)
def _generate_signed_url_internal(self, blob_path: str, method: str, expiration_minutes: int = 60, content_type: Optional[str] = None) -> str:
"""Internal method to generate signed URLs for GET or PUT operations."""
import google.auth
from google.auth.transport import requests
try:
blob = self.bucket.blob(blob_path)
# Get default credentials and refresh to ensure we have a valid token
credentials, project = google.auth.default()
# Common kwargs for signed URL generation
kwargs = {
"version": "v4",
"expiration": timedelta(minutes=expiration_minutes),
"method": method,
}
# For PUT requests, we need to specify the content type in headers
if method == "PUT" and content_type:
kwargs["headers"] = {"Content-Type": content_type}
# Check if we're using compute credentials (Cloud Run/GCE)
# These need to use IAM signBlob via service_account_email + access_token
if hasattr(credentials, 'service_account_email'):
# Refresh credentials to get a valid access token
auth_request = requests.Request()
credentials.refresh(auth_request)
kwargs["service_account_email"] = credentials.service_account_email
kwargs["access_token"] = credentials.token
url = blob.generate_signed_url(**kwargs)
logger.info(f"Generated signed {method} URL for {blob_path}")
return url
except Exception as e:
logger.error(f"Error generating signed {method} URL for {blob_path}: {e}")
raise
def delete_file(self, blob_path: str) -> None:
"""Delete a file from GCS."""
try:
blob = self.bucket.blob(blob_path)
blob.delete()
logger.info(f"Deleted gs://{settings.gcs_bucket_name}/{blob_path}")
except Exception as e:
logger.error(f"Error deleting file {blob_path}: {e}")
raise
def delete_folder(self, prefix: str) -> int:
"""
Delete all files in GCS with a given prefix (folder).
Args:
prefix: The folder prefix to delete (e.g., "uploads/abc123/")
Returns:
Number of files deleted
"""
try:
blobs = list(self.bucket.list_blobs(prefix=prefix))
deleted_count = 0
for blob in blobs:
try:
blob.delete()
deleted_count += 1
except Exception as e:
logger.warning(f"Error deleting blob {blob.name}: {e}")
if deleted_count > 0:
logger.info(f"Deleted {deleted_count} files from gs://{settings.gcs_bucket_name}/{prefix}")
return deleted_count
except Exception as e:
logger.error(f"Error deleting folder {prefix}: {e}")
return 0 # Don't raise - folder deletion shouldn't break operations
def list_files(self, prefix: str) -> list:
"""List files in GCS with a given prefix."""
try:
blobs = self.bucket.list_blobs(prefix=prefix)
return [blob.name for blob in blobs]
except Exception as e:
logger.error(f"Error listing files with prefix {prefix}: {e}")
raise
def file_exists(self, blob_path: str) -> bool:
"""Check if a file exists in GCS."""
try:
blob = self.bucket.blob(blob_path)
return blob.exists()
except Exception as e:
logger.error(f"Error checking file existence {blob_path}: {e}")
raise
def upload_json(self, destination_path: str, data: Dict[str, Any]) -> str:
"""Upload a JSON object to GCS."""
try:
blob = self.bucket.blob(destination_path)
blob.content_type = "application/json"
blob.upload_from_string(
json.dumps(data, indent=2, ensure_ascii=False),
content_type="application/json"
)
logger.info(f"Uploaded JSON to gs://{settings.gcs_bucket_name}/{destination_path}")
return destination_path
except Exception as e:
logger.error(f"Error uploading JSON to {destination_path}: {e}")
raise
def download_json(self, source_path: str) -> Dict[str, Any]:
"""Download and parse a JSON file from GCS."""
try:
blob = self.bucket.blob(source_path)
content = blob.download_as_text()
data = json.loads(content)
logger.info(f"Downloaded JSON from gs://{settings.gcs_bucket_name}/{source_path}")
return data
except Exception as e:
logger.error(f"Error downloading JSON from {source_path}: {e}")
raise
-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
-254
View File
@@ -1,254 +0,0 @@
"""
Structured logging with trace correlation for Cloud Logging.
This module provides JSON-formatted logging that integrates with Google Cloud Logging
and correlates logs with OpenTelemetry traces in Cloud Trace.
When running in Cloud Run:
- Logs are output as JSON for Cloud Logging to parse
- Each log entry includes trace ID and span ID for correlation
- Custom fields (job_id, worker) are preserved in the log structure
Usage:
# In main.py, before any logging:
from backend.services.structured_logging import setup_structured_logging
setup_structured_logging()
# Then use standard logging:
logger = logging.getLogger(__name__)
logger.info("Processing started", extra={"job_id": "abc123"})
"""
import json
import logging
import os
import sys
from datetime import datetime
from typing import Any, Dict, Optional
# Cloud Logging severity mapping (compatible with GCP)
# https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry#LogSeverity
SEVERITY_MAP = {
"DEBUG": "DEBUG",
"INFO": "INFO",
"WARNING": "WARNING",
"ERROR": "ERROR",
"CRITICAL": "CRITICAL",
}
class StructuredFormatter(logging.Formatter):
"""
JSON formatter with trace correlation for Google Cloud Logging.
Produces log entries in the format expected by Cloud Logging, including:
- logging.googleapis.com/trace: Links to Cloud Trace
- logging.googleapis.com/spanId: Current span ID
- severity: Cloud Logging severity level
- Custom fields passed via 'extra' dict
"""
def __init__(self, project_id: Optional[str] = None):
"""
Initialize the structured formatter.
Args:
project_id: GCP project ID for trace URLs (auto-detected if not provided)
"""
super().__init__()
self.project_id = project_id or os.environ.get("GOOGLE_CLOUD_PROJECT") or os.environ.get("GCP_PROJECT")
def format(self, record: logging.LogRecord) -> str:
"""
Format a log record as JSON.
Args:
record: The log record to format
Returns:
JSON string for Cloud Logging
"""
from backend.services.tracing import get_current_trace_id, get_current_span_id
# Build base log entry
log_entry: Dict[str, Any] = {
"timestamp": datetime.utcfromtimestamp(record.created).isoformat() + "Z",
"severity": SEVERITY_MAP.get(record.levelname, record.levelname),
"message": record.getMessage(),
"logger": record.name,
}
# Add trace correlation if available
trace_id = get_current_trace_id()
span_id = get_current_span_id()
if trace_id and self.project_id:
# Format for Cloud Logging trace correlation
log_entry["logging.googleapis.com/trace"] = f"projects/{self.project_id}/traces/{trace_id}"
if span_id:
log_entry["logging.googleapis.com/spanId"] = span_id
# 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",
]
for field in custom_fields:
value = getattr(record, field, None)
if value is not None:
log_entry[field] = value
# Add source location for debugging
if record.pathname and record.lineno:
log_entry["logging.googleapis.com/sourceLocation"] = {
"file": record.pathname,
"line": record.lineno,
"function": record.funcName,
}
# Add exception info if present
if record.exc_info:
log_entry["exception"] = self.formatException(record.exc_info)
# Remove None values for cleaner output
return json.dumps({k: v for k, v in log_entry.items() if v is not None})
class HumanReadableFormatter(logging.Formatter):
"""
Human-readable formatter for local development.
Includes trace context when available but outputs in traditional format.
"""
def format(self, record: logging.LogRecord) -> str:
"""Format a log record for human readability."""
from backend.services.tracing import get_current_trace_id
# Build base message
timestamp = datetime.utcfromtimestamp(record.created).strftime("%Y-%m-%d %H:%M:%S")
# Add job_id prefix if available
job_id = getattr(record, "job_id", None)
job_prefix = f"[job:{job_id[:8]}] " if job_id else ""
# Add trace ID suffix if available
trace_id = get_current_trace_id()
trace_suffix = f" [trace:{trace_id[:8]}]" if trace_id else ""
message = f"{timestamp} - {record.name} - {record.levelname} - {job_prefix}{record.getMessage()}{trace_suffix}"
# Add exception info if present
if record.exc_info:
message += "\n" + self.formatException(record.exc_info)
return message
def is_cloud_run() -> bool:
"""Check if we're running in Cloud Run."""
return os.environ.get("K_SERVICE") is not None
def setup_structured_logging(force_json: bool = False, log_level: Optional[str] = None) -> None:
"""
Configure structured logging for the application.
In Cloud Run: Uses JSON format with trace correlation for Cloud Logging
In development: Uses human-readable format with optional trace context
Args:
force_json: Force JSON output even in development
log_level: Override log level (default from settings or INFO)
"""
from backend.config import settings
# Determine log level
level = log_level or getattr(settings, "log_level", "INFO")
level = getattr(logging, level.upper(), logging.INFO)
# Choose formatter based on environment
if is_cloud_run() or force_json:
formatter = StructuredFormatter()
else:
formatter = HumanReadableFormatter()
# Create handler
handler = logging.StreamHandler(sys.stdout)
handler.setFormatter(formatter)
handler.setLevel(level)
# Configure root logger
root_logger = logging.getLogger()
root_logger.setLevel(level)
# Remove existing handlers and add our handler
root_logger.handlers = [handler]
# Also configure uvicorn loggers to use our format
for logger_name in ["uvicorn", "uvicorn.access", "uvicorn.error"]:
logger = logging.getLogger(logger_name)
logger.handlers = [handler]
logger.propagate = False
class JobLogAdapter(logging.LoggerAdapter):
"""
Logger adapter that automatically adds job context to log records.
Usage:
logger = logging.getLogger(__name__)
job_logger = JobLogAdapter(logger, job_id="abc123", worker="audio")
job_logger.info("Processing started") # Automatically includes job_id and worker
"""
def __init__(self, logger: logging.Logger, job_id: str, worker: Optional[str] = None, **extra):
"""
Initialize the adapter.
Args:
logger: Base logger instance
job_id: Job ID to include in all log records
worker: Optional worker name
**extra: Additional fields to include in all log records
"""
super().__init__(logger, {"job_id": job_id, "worker": worker, **extra})
def process(self, msg: str, kwargs: Dict[str, Any]) -> tuple:
"""Process a logging call to add extra context."""
# Merge extra dict from adapter with any extra passed to the log call
extra = kwargs.get("extra", {})
extra.update(self.extra)
kwargs["extra"] = extra
return msg, kwargs
def get_job_logger(job_id: str, worker: Optional[str] = None, name: Optional[str] = None) -> JobLogAdapter:
"""
Get a logger adapter configured for a specific job.
This is a convenience function for creating job-specific loggers.
Args:
job_id: Job ID to include in all log records
worker: Optional worker name
name: Logger name (defaults to "job")
Returns:
JobLogAdapter configured for the job
Usage:
logger = get_job_logger("abc123", "audio")
logger.info("Starting audio separation")
logger.error("Failed to process", extra={"error": str(e)})
"""
base_logger = logging.getLogger(name or "job")
return JobLogAdapter(base_logger, job_id=job_id, worker=worker)
-469
View File
@@ -1,469 +0,0 @@
"""
Theme service for managing pre-created style themes.
Themes are stored in GCS at themes/{theme_id}/ with:
- style_params.json: Complete style configuration
- preview.png: Preview image for theme selection UI
- youtube_description.txt: Optional YouTube description template
- assets/: Fonts, backgrounds, and other assets
The service provides:
- Theme listing with signed preview URLs
- Theme detail retrieval
- Color override application
- Job style preparation (copying theme to job folder)
"""
import copy
import json
import logging
import os
import tempfile
import threading
from datetime import datetime, timedelta
from typing import Any, Dict, List, Optional, Tuple
from backend.models.theme import (
ColorOverrides,
ThemeDetail,
ThemeMetadata,
ThemeRegistry,
ThemeSummary,
hex_to_rgba,
)
from backend.services.storage_service import StorageService
logger = logging.getLogger(__name__)
# GCS paths for themes
THEMES_PREFIX = "themes"
METADATA_FILE = f"{THEMES_PREFIX}/_metadata.json"
class ThemeService:
"""Service for managing themes from GCS."""
def __init__(self, storage: Optional[StorageService] = None):
"""
Initialize the theme service.
Args:
storage: StorageService instance (creates new one if not provided)
"""
self.storage = storage or StorageService()
self._metadata_cache: Optional[ThemeRegistry] = None
self._cache_time: Optional[datetime] = None
self.CACHE_TTL_SECONDS = 300 # 5 minute cache for theme metadata
def _get_theme_path(self, theme_id: str, filename: str = "") -> str:
"""Get the GCS path for a theme file."""
if filename:
return f"{THEMES_PREFIX}/{theme_id}/{filename}"
return f"{THEMES_PREFIX}/{theme_id}"
def _is_cache_valid(self) -> bool:
"""Check if the metadata cache is still valid."""
if self._metadata_cache is None or self._cache_time is None:
return False
age = datetime.now() - self._cache_time
return age.total_seconds() < self.CACHE_TTL_SECONDS
def _load_metadata(self, force_refresh: bool = False) -> ThemeRegistry:
"""
Load theme metadata from GCS with caching.
Args:
force_refresh: Force reload from GCS even if cache is valid
Returns:
ThemeRegistry containing all theme metadata
"""
if not force_refresh and self._is_cache_valid():
return self._metadata_cache # type: ignore
try:
data = self.storage.download_json(METADATA_FILE)
self._metadata_cache = ThemeRegistry(**data)
self._cache_time = datetime.now()
logger.info(f"Loaded theme metadata: {len(self._metadata_cache.themes)} themes")
return self._metadata_cache
except Exception as e:
logger.error(f"Failed to load theme metadata: {e}")
# Return empty registry on error
return ThemeRegistry(version=1, themes=[])
def list_themes(self) -> List[ThemeSummary]:
"""
List all available themes with signed preview URLs.
Returns:
List of ThemeSummary objects with preview URLs
"""
metadata = self._load_metadata()
summaries = []
for theme in metadata.themes:
try:
# Generate signed URLs for preview images
preview_path = self._get_theme_path(theme.id, "preview.png")
thumbnail_path = self._get_theme_path(theme.id, "preview_thumbnail.png")
preview_url = None
thumbnail_url = None
if self.storage.file_exists(preview_path):
preview_url = self.storage.generate_signed_url(preview_path, expiration_minutes=60)
# Try thumbnail, fall back to main preview
if self.storage.file_exists(thumbnail_path):
thumbnail_url = self.storage.generate_signed_url(thumbnail_path, expiration_minutes=60)
elif preview_url:
thumbnail_url = preview_url
summaries.append(
ThemeSummary(
id=theme.id,
name=theme.name,
description=theme.description,
preview_url=preview_url,
thumbnail_url=thumbnail_url,
is_default=theme.is_default,
)
)
except Exception as e:
logger.warning(f"Error processing theme {theme.id}: {e}")
# Still include theme but without preview URLs
summaries.append(
ThemeSummary(
id=theme.id,
name=theme.name,
description=theme.description,
is_default=theme.is_default,
)
)
return summaries
def get_theme(self, theme_id: str) -> Optional[ThemeDetail]:
"""
Get full theme details including style parameters.
Args:
theme_id: The theme identifier
Returns:
ThemeDetail if found, None otherwise
"""
metadata = self._load_metadata()
# Find theme in metadata
theme_meta = next((t for t in metadata.themes if t.id == theme_id), None)
if not theme_meta:
logger.warning(f"Theme not found: {theme_id}")
return None
try:
# Load style_params.json
style_params_path = self._get_theme_path(theme_id, "style_params.json")
style_params = self.storage.download_json(style_params_path)
# Check for YouTube description
youtube_desc_path = self._get_theme_path(theme_id, "youtube_description.txt")
has_youtube_desc = self.storage.file_exists(youtube_desc_path)
# Generate preview URL
preview_path = self._get_theme_path(theme_id, "preview.png")
preview_url = None
if self.storage.file_exists(preview_path):
preview_url = self.storage.generate_signed_url(preview_path, expiration_minutes=60)
return ThemeDetail(
id=theme_id,
name=theme_meta.name,
description=theme_meta.description,
preview_url=preview_url,
is_default=theme_meta.is_default,
style_params=style_params,
has_youtube_description=has_youtube_desc,
)
except Exception as e:
logger.error(f"Error loading theme {theme_id}: {e}")
return None
def get_theme_style_params(self, theme_id: str) -> Optional[Dict[str, Any]]:
"""
Get just the style_params.json for a theme.
Args:
theme_id: The theme identifier
Returns:
Style parameters dict if found, None otherwise
"""
try:
style_params_path = self._get_theme_path(theme_id, "style_params.json")
return self.storage.download_json(style_params_path)
except Exception as e:
logger.error(f"Error loading style params for theme {theme_id}: {e}")
return None
def get_youtube_description(self, theme_id: str) -> Optional[str]:
"""
Get the YouTube description template for a theme.
Args:
theme_id: The theme identifier
Returns:
YouTube description text if found, None otherwise
"""
try:
youtube_desc_path = self._get_theme_path(theme_id, "youtube_description.txt")
if not self.storage.file_exists(youtube_desc_path):
return None
# Download to temp file and read
with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".txt") as tmp:
tmp_path = tmp.name
try:
self.storage.download_file(youtube_desc_path, tmp_path)
with open(tmp_path, "r") as f:
return f.read()
finally:
if os.path.exists(tmp_path):
os.remove(tmp_path)
except Exception as e:
logger.error(f"Error loading YouTube description for theme {theme_id}: {e}")
return None
def apply_color_overrides(
self, style_params: Dict[str, Any], overrides: ColorOverrides
) -> Dict[str, Any]:
"""
Apply user color overrides to theme style parameters.
Args:
style_params: Base style parameters from theme
overrides: User color overrides
Returns:
Modified style parameters with overrides applied
"""
if not overrides.has_overrides():
return style_params
# Deep copy to avoid modifying original
result = copy.deepcopy(style_params)
# Apply artist_color to intro, end, and CDG sections
if overrides.artist_color:
if "intro" in result:
result["intro"]["artist_color"] = overrides.artist_color
if "end" in result:
result["end"]["artist_color"] = overrides.artist_color
if "cdg" in result:
result["cdg"]["artist_color"] = overrides.artist_color
# Apply title_color to intro, end, and CDG sections
if overrides.title_color:
if "intro" in result:
result["intro"]["title_color"] = overrides.title_color
if "end" in result:
result["end"]["title_color"] = overrides.title_color
if "cdg" in result:
result["cdg"]["title_color"] = overrides.title_color
# Apply sung_lyrics_color (karaoke uses RGBA, CDG uses hex)
if overrides.sung_lyrics_color:
if "karaoke" in result:
result["karaoke"]["primary_color"] = hex_to_rgba(overrides.sung_lyrics_color)
if "cdg" in result:
result["cdg"]["active_fill"] = overrides.sung_lyrics_color
# Apply unsung_lyrics_color (karaoke uses RGBA, CDG uses hex)
if overrides.unsung_lyrics_color:
if "karaoke" in result:
result["karaoke"]["secondary_color"] = hex_to_rgba(overrides.unsung_lyrics_color)
if "cdg" in result:
result["cdg"]["inactive_fill"] = overrides.unsung_lyrics_color
return result
def prepare_job_style(
self,
job_id: str,
theme_id: str,
color_overrides: Optional[ColorOverrides] = None,
) -> Tuple[str, Dict[str, str]]:
"""
Prepare style files for a job by copying theme to job folder.
This method:
1. Loads the theme's style_params.json
2. Applies any color overrides
3. Updates asset paths to point to theme assets (shared, not copied)
4. Uploads modified style_params.json to job folder
5. Returns the GCS path and style_assets mapping
Args:
job_id: The job ID
theme_id: The theme to use
color_overrides: Optional color overrides
Returns:
Tuple of (style_params_gcs_path, style_assets dict)
Raises:
ValueError: If theme not found
"""
# Load theme style params
style_params = self.get_theme_style_params(theme_id)
if style_params is None:
raise ValueError(f"Theme not found: {theme_id}")
# Apply color overrides if provided
if color_overrides:
style_params = self.apply_color_overrides(style_params, color_overrides)
# Update asset paths to point to theme's shared assets
# Theme assets stay in themes/{theme_id}/assets/ - they're shared
style_assets = self._build_style_assets_mapping(theme_id, style_params)
# Update style_params to use theme asset paths (not job-specific)
style_params = self._update_asset_paths_in_style(theme_id, style_params)
# Upload modified style_params.json to job's style folder
job_style_path = f"uploads/{job_id}/style/style_params.json"
self.storage.upload_json(job_style_path, style_params)
logger.info(f"Prepared job {job_id} style from theme {theme_id}")
return job_style_path, style_assets
def _build_style_assets_mapping(
self, theme_id: str, style_params: Dict[str, Any]
) -> Dict[str, str]:
"""
Build the style_assets mapping for a theme.
Maps asset keys to their GCS paths in the theme folder.
"""
style_assets = {}
theme_assets_prefix = f"{THEMES_PREFIX}/{theme_id}/assets"
# Check each potential asset type
asset_checks = [
("intro_background", "intro", "background_image"),
("karaoke_background", "karaoke", "background_image"),
("end_background", "end", "background_image"),
("font", "intro", "font"), # Font is typically shared across sections
("cdg_instrumental_background", "cdg", "instrumental_background"),
("cdg_title_background", "cdg", "title_screen_background"),
("cdg_outro_background", "cdg", "outro_background"),
]
for asset_key, section, field in asset_checks:
if section in style_params and field in style_params[section]:
value = style_params[section][field]
if value and isinstance(value, str):
# Check if it's a theme asset path or already has the full path
if value.startswith(f"{THEMES_PREFIX}/"):
# Already a full theme path
style_assets[asset_key] = value
elif not value.startswith("/") and not value.startswith("gs://"):
# Relative path - prepend theme assets prefix
asset_path = f"{theme_assets_prefix}/{os.path.basename(value)}"
if self.storage.file_exists(asset_path):
style_assets[asset_key] = asset_path
return style_assets
def _update_asset_paths_in_style(
self, theme_id: str, style_params: Dict[str, Any]
) -> Dict[str, Any]:
"""
Update asset paths in style_params to use full GCS theme paths.
This ensures the style_loader can find assets when processing.
"""
result = copy.deepcopy(style_params)
theme_assets_prefix = f"{THEMES_PREFIX}/{theme_id}/assets"
# Fields that contain asset paths
path_fields = {
"intro": ["background_image", "font"],
"end": ["background_image", "font"],
"karaoke": ["background_image", "font_path"],
"cdg": [
"font_path",
"instrumental_background",
"title_screen_background",
"outro_background",
],
}
for section, fields in path_fields.items():
if section not in result:
continue
for field in fields:
if field not in result[section]:
continue
value = result[section][field]
if value and isinstance(value, str):
# Skip if already a full path or URL
if value.startswith(f"{THEMES_PREFIX}/") or value.startswith("gs://"):
continue
# Skip absolute local paths (shouldn't happen but be safe)
if value.startswith("/"):
continue
# Update to full theme asset path
result[section][field] = f"{theme_assets_prefix}/{os.path.basename(value)}"
return result
def theme_exists(self, theme_id: str) -> bool:
"""
Check if a theme exists.
Args:
theme_id: The theme identifier
Returns:
True if theme exists, False otherwise
"""
metadata = self._load_metadata()
return any(t.id == theme_id for t in metadata.themes)
def get_default_theme_id(self) -> Optional[str]:
"""
Get the ID of the default theme.
Returns:
Default theme ID if one exists, None otherwise
"""
metadata = self._load_metadata()
default_theme = next((t for t in metadata.themes if t.is_default), None)
return default_theme.id if default_theme else None
def invalidate_cache(self) -> None:
"""Force invalidation of the metadata cache."""
self._metadata_cache = None
self._cache_time = None
logger.info("Theme metadata cache invalidated")
# Singleton instance with thread-safe initialization
_theme_service: Optional[ThemeService] = None
_theme_service_lock = threading.Lock()
def get_theme_service() -> ThemeService:
"""Get or create the singleton ThemeService instance (thread-safe)."""
global _theme_service
if _theme_service is None:
with _theme_service_lock:
# Double-check after acquiring lock
if _theme_service is None:
_theme_service = ThemeService()
return _theme_service
-543
View File
@@ -1,543 +0,0 @@
"""
OpenTelemetry tracing configuration for Google Cloud Trace.
This module sets up distributed tracing that exports to Google Cloud Trace,
providing visibility into request flows, latency, and errors across the
entire backend.
Usage:
# In main.py or app initialization
from backend.services.tracing import setup_tracing, instrument_app
setup_tracing(service_name="karaoke-backend")
app = FastAPI()
instrument_app(app)
# For custom spans in your code
from backend.services.tracing import tracer, create_span
with tracer.start_as_current_span("my-operation") as span:
span.set_attribute("job_id", job_id)
# ... do work ...
# For job-specific spans with automatic job_id attribute
from backend.services.tracing import job_span
with job_span("audio-worker", job_id) as span:
# job_id is automatically set as an attribute
span.set_attribute("stage", "separation")
# ... do work ...
# For propagating trace context through Cloud Tasks
from backend.services.tracing import inject_trace_context, extract_trace_context
# In worker_service.py (when creating task):
headers = inject_trace_context({})
# In internal.py (when receiving task):
context = extract_trace_context(request.headers)
with tracer.start_as_current_span("worker", context=context):
...
"""
import os
import logging
from typing import Optional, Any, Dict
from contextlib import contextmanager
from functools import wraps
# OpenTelemetry imports
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor, SimpleSpanProcessor
from opentelemetry.sdk.resources import Resource, SERVICE_NAME, SERVICE_VERSION
from opentelemetry.trace import Status, StatusCode, Span
from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
# Google Cloud Trace exporter
try:
from opentelemetry.exporter.cloud_trace import CloudTraceSpanExporter
from opentelemetry.resourcedetector.gcp_resource_detector import GoogleCloudResourceDetector
GCP_AVAILABLE = True
except ImportError:
GCP_AVAILABLE = False
CloudTraceSpanExporter = None
GoogleCloudResourceDetector = None
# FastAPI instrumentation
try:
from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
FASTAPI_INSTRUMENTATION_AVAILABLE = True
except ImportError:
FASTAPI_INSTRUMENTATION_AVAILABLE = False
FastAPIInstrumentor = None
# HTTPX instrumentation (for outgoing HTTP calls)
try:
from opentelemetry.instrumentation.httpx import HTTPXClientInstrumentation
HTTPX_INSTRUMENTATION_AVAILABLE = True
except ImportError:
HTTPX_INSTRUMENTATION_AVAILABLE = False
HTTPXClientInstrumentation = None
# Logging instrumentation
try:
from opentelemetry.instrumentation.logging import LoggingInstrumentor
LOGGING_INSTRUMENTATION_AVAILABLE = True
except ImportError:
LOGGING_INSTRUMENTATION_AVAILABLE = False
LoggingInstrumentor = None
logger = logging.getLogger(__name__)
# Global tracer instance
_tracer: Optional[trace.Tracer] = None
_initialized = False
def setup_tracing(
service_name: str = "karaoke-backend",
service_version: str = "0.71.7",
enable_in_dev: bool = False,
) -> bool:
"""
Initialize OpenTelemetry tracing with Google Cloud Trace exporter.
Args:
service_name: Name of the service (appears in Cloud Trace)
service_version: Version of the service
enable_in_dev: Whether to enable tracing in development (default False)
Returns:
True if tracing was initialized, False if skipped
"""
global _tracer, _initialized
if _initialized:
logger.debug("Tracing already initialized")
return True
# Check if we should enable tracing
# In Cloud Run, GOOGLE_CLOUD_PROJECT is always set
is_cloud_run = os.environ.get("K_SERVICE") is not None
gcp_project = os.environ.get("GOOGLE_CLOUD_PROJECT") or os.environ.get("GCP_PROJECT")
if not is_cloud_run and not enable_in_dev:
logger.info("Tracing disabled in development (set enable_in_dev=True to enable)")
_tracer = trace.get_tracer(service_name)
return False
if not GCP_AVAILABLE:
logger.warning("Google Cloud Trace exporter not available, tracing disabled")
_tracer = trace.get_tracer(service_name)
return False
logger.info(f"Initializing OpenTelemetry tracing for {service_name} v{service_version}")
try:
# Create resource with service info and GCP resource detection
resource_attributes = {
SERVICE_NAME: service_name,
SERVICE_VERSION: service_version,
}
# Detect GCP resources (project, region, instance, etc.)
if GoogleCloudResourceDetector and is_cloud_run:
try:
gcp_resource = GoogleCloudResourceDetector().detect()
resource = Resource.create(resource_attributes).merge(gcp_resource)
logger.info("Detected GCP resources for tracing")
except Exception as e:
logger.warning(f"Could not detect GCP resources: {e}")
resource = Resource.create(resource_attributes)
else:
resource = Resource.create(resource_attributes)
# Create tracer provider
provider = TracerProvider(resource=resource)
# Add Cloud Trace exporter
if CloudTraceSpanExporter and gcp_project:
try:
exporter = CloudTraceSpanExporter(project_id=gcp_project)
# Use BatchSpanProcessor for production (better performance)
processor = BatchSpanProcessor(exporter)
provider.add_span_processor(processor)
logger.info(f"Cloud Trace exporter configured for project: {gcp_project}")
except Exception as e:
logger.warning(f"Could not configure Cloud Trace exporter: {e}")
# Set the global tracer provider
trace.set_tracer_provider(provider)
# Get tracer instance
_tracer = trace.get_tracer(service_name, service_version)
# Instrument logging to include trace context
if LOGGING_INSTRUMENTATION_AVAILABLE and LoggingInstrumentor:
try:
LoggingInstrumentor().instrument(set_logging_format=True)
logger.info("Logging instrumentation enabled")
except Exception as e:
logger.warning(f"Could not instrument logging: {e}")
# Instrument HTTPX for outgoing requests
if HTTPX_INSTRUMENTATION_AVAILABLE and HTTPXClientInstrumentation:
try:
HTTPXClientInstrumentation().instrument()
logger.info("HTTPX instrumentation enabled")
except Exception as e:
logger.warning(f"Could not instrument HTTPX: {e}")
_initialized = True
logger.info("OpenTelemetry tracing initialized successfully")
return True
except Exception as e:
logger.error(f"Failed to initialize tracing: {e}")
_tracer = trace.get_tracer(service_name)
return False
def instrument_app(app) -> None:
"""
Instrument a FastAPI application with automatic tracing.
This adds spans for all incoming requests, including:
- Request method and path
- Response status code
- Request duration
- Error information
Args:
app: FastAPI application instance
"""
if not FASTAPI_INSTRUMENTATION_AVAILABLE or not FastAPIInstrumentor:
logger.warning("FastAPI instrumentation not available")
return
try:
FastAPIInstrumentor.instrument_app(
app,
excluded_urls="health,healthz,ready,readiness,ping",
)
logger.info("FastAPI instrumentation enabled")
except Exception as e:
logger.warning(f"Could not instrument FastAPI: {e}")
def get_tracer() -> trace.Tracer:
"""
Get the global tracer instance.
Returns:
Tracer instance (creates a no-op tracer if not initialized)
"""
global _tracer
if _tracer is None:
_tracer = trace.get_tracer("karaoke-backend")
return _tracer
# Convenience alias - lazily forwards attribute access to get_tracer()
class _TracerProxy:
"""Proxy that lazily returns the global tracer."""
def __getattr__(self, name):
return getattr(get_tracer(), name)
tracer = _TracerProxy()
@contextmanager
def create_span(
name: str,
attributes: Optional[Dict[str, Any]] = None,
kind: trace.SpanKind = trace.SpanKind.INTERNAL,
):
"""
Create a traced span as a context manager.
Usage:
with create_span("process-lyrics", {"job_id": job_id}) as span:
# ... do work ...
span.set_attribute("words_processed", 500)
Args:
name: Span name (appears in Cloud Trace)
attributes: Initial span attributes
kind: Span kind (INTERNAL, SERVER, CLIENT, PRODUCER, CONSUMER)
Yields:
The active span
"""
tracer = get_tracer()
with tracer.start_as_current_span(name, kind=kind) as span:
if attributes:
for key, value in attributes.items():
span.set_attribute(key, value)
try:
yield span
except Exception as e:
span.set_status(Status(StatusCode.ERROR, str(e)))
span.record_exception(e)
raise
def traced(
name: Optional[str] = None,
attributes: Optional[Dict[str, Any]] = None,
):
"""
Decorator to trace a function.
Usage:
@traced("process-correction")
def process_correction(job_id: str):
...
@traced(attributes={"operation": "add-lyrics"})
async def add_lyrics(job_id: str, source: str):
...
Args:
name: Span name (defaults to function name)
attributes: Static attributes to add to span
"""
def decorator(func):
span_name = name or func.__name__
@wraps(func)
async def async_wrapper(*args, **kwargs):
with create_span(span_name, attributes) as span:
# Add function arguments as attributes
span.set_attribute("function", func.__name__)
return await func(*args, **kwargs)
@wraps(func)
def sync_wrapper(*args, **kwargs):
with create_span(span_name, attributes) as span:
span.set_attribute("function", func.__name__)
return func(*args, **kwargs)
# Return appropriate wrapper based on function type
import asyncio
if asyncio.iscoroutinefunction(func):
return async_wrapper
return sync_wrapper
return decorator
def add_span_attribute(key: str, value: Any) -> None:
"""
Add an attribute to the current span.
Args:
key: Attribute name
value: Attribute value (must be string, int, float, bool, or list thereof)
"""
span = trace.get_current_span()
if span and span.is_recording():
span.set_attribute(key, value)
def add_span_event(name: str, attributes: Optional[Dict[str, Any]] = None) -> None:
"""
Add an event to the current span.
Events are timestamped annotations that appear in the trace timeline.
Args:
name: Event name
attributes: Event attributes
"""
span = trace.get_current_span()
if span and span.is_recording():
span.add_event(name, attributes=attributes or {})
def set_span_error(error: Exception) -> None:
"""
Mark the current span as errored.
Args:
error: The exception that occurred
"""
span = trace.get_current_span()
if span and span.is_recording():
span.set_status(Status(StatusCode.ERROR, str(error)))
span.record_exception(error)
def get_current_trace_id() -> Optional[str]:
"""
Get the current trace ID for correlation.
This can be used to link logs to traces.
Returns:
Trace ID as hex string, or None if no active trace
"""
span = trace.get_current_span()
if span:
ctx = span.get_span_context()
if ctx.is_valid:
return format(ctx.trace_id, '032x')
return None
def get_current_span_id() -> Optional[str]:
"""
Get the current span ID.
Returns:
Span ID as hex string, or None if no active span
"""
span = trace.get_current_span()
if span:
ctx = span.get_span_context()
if ctx.is_valid:
return format(ctx.span_id, '016x')
return None
# =====================================================
# Job-Aware Tracing Utilities
# =====================================================
@contextmanager
def job_span(
name: str,
job_id: str,
attributes: Optional[Dict[str, Any]] = None,
kind: trace.SpanKind = trace.SpanKind.INTERNAL,
):
"""
Create a traced span with job_id automatically set as an attribute.
This is the preferred way to create spans in job processing workers.
The job_id attribute enables filtering spans by job in Cloud Trace.
Usage:
with job_span("audio-separation", job_id) as span:
span.set_attribute("stage", "clean_instrumental")
# ... do work ...
Args:
name: Span name (appears in Cloud Trace)
job_id: Job ID to attach to the span
attributes: Additional span attributes
kind: Span kind (INTERNAL, SERVER, CLIENT, PRODUCER, CONSUMER)
Yields:
The active span
"""
all_attributes = {
"job_id": job_id,
"service.operation": name,
}
if attributes:
all_attributes.update(attributes)
with create_span(name, all_attributes, kind) as span:
yield span
def inject_trace_context(headers: Dict[str, str]) -> Dict[str, str]:
"""
Inject current trace context into HTTP headers.
Use this when creating Cloud Tasks or making HTTP calls to propagate
the trace context so child spans link to the parent trace.
Usage:
headers = inject_trace_context({
"Content-Type": "application/json",
"Authorization": "Bearer token",
})
# Use headers in HTTP request or Cloud Task
Args:
headers: Existing headers dict to add trace context to
Returns:
Headers dict with traceparent/tracestate headers added
"""
propagator = TraceContextTextMapPropagator()
carrier = dict(headers) # Make a copy
propagator.inject(carrier)
return carrier
def extract_trace_context(headers: Dict[str, str]) -> Optional[trace.Context]:
"""
Extract trace context from HTTP headers.
Use this when receiving Cloud Tasks or HTTP requests to continue
the trace from the parent span.
Usage:
context = extract_trace_context(request.headers)
with tracer.start_as_current_span("worker", context=context):
# ... processing ...
Args:
headers: HTTP headers containing traceparent/tracestate
Returns:
Context object for use with start_as_current_span, or None
"""
propagator = TraceContextTextMapPropagator()
return propagator.extract(headers)
def start_span_with_context(
name: str,
context: Optional[trace.Context],
job_id: Optional[str] = None,
attributes: Optional[Dict[str, Any]] = None,
):
"""
Start a span as child of the given context (or current context if None).
This is useful for starting worker spans that should link to the
trace from the original API request.
Usage:
context = extract_trace_context(request.headers)
with start_span_with_context("audio-worker", context, job_id) as span:
# ... processing ...
Args:
name: Span name
context: Parent context (from extract_trace_context) or None
job_id: Optional job ID to set as attribute
attributes: Additional span attributes
Returns:
Context manager yielding the span
"""
tracer = get_tracer()
all_attributes = attributes or {}
if job_id:
all_attributes["job_id"] = job_id
all_attributes["service.operation"] = name
@contextmanager
def _span():
kwargs = {"kind": trace.SpanKind.INTERNAL}
if context is not None:
kwargs["context"] = context
with tracer.start_as_current_span(name, **kwargs) as span:
for key, value in all_attributes.items():
span.set_attribute(key, value)
try:
yield span
except Exception as e:
span.set_status(Status(StatusCode.ERROR, str(e)))
span.record_exception(e)
raise
return _span()
-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
-460
View File
@@ -1,460 +0,0 @@
"""
Worker coordination service.
Handles triggering and coordinating background workers.
Supports two modes:
- Cloud Tasks (production): Guaranteed delivery, automatic retries, horizontal scaling
- Direct HTTP (development): Faster iteration, simpler debugging
SOLID Principles:
- Single Responsibility: Only handles worker coordination
- Dependency Inversion: Depends on HTTP abstraction, not implementation
- Open/Closed: Can add new workers without modifying existing code
Observability:
- Propagates trace context through Cloud Tasks for distributed tracing
- All worker invocations create spans linked to original request trace
"""
import logging
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
logger = logging.getLogger(__name__)
# Mapping of worker types to their Cloud Tasks queue names
# These queues are created by Pulumi in infrastructure/__main__.py
WORKER_QUEUES = {
"audio": "audio-worker-queue",
"lyrics": "lyrics-worker-queue",
"screens": "screens-worker-queue",
"render-video": "render-worker-queue",
"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:
"""
Service for coordinating background workers.
Supports two execution modes controlled by ENABLE_CLOUD_TASKS env var:
1. Cloud Tasks mode (production, ENABLE_CLOUD_TASKS=true):
- Tasks enqueued to Cloud Tasks for guaranteed delivery
- Automatic retries on failure
- Each task runs in dedicated Cloud Run instance
- Rate limiting to protect external APIs (Modal, AudioShake)
2. Direct HTTP mode (development, ENABLE_CLOUD_TASKS=false):
- Direct HTTP POST to internal worker endpoints
- Worker runs as FastAPI BackgroundTask
- Faster iteration for local development
- No retry guarantees
"""
def __init__(self):
"""Initialize worker service."""
self.settings = get_settings()
self._base_url = self._get_base_url()
self._admin_token = self._get_admin_token()
self._use_cloud_tasks = self._should_use_cloud_tasks()
self._tasks_client = None
if self._use_cloud_tasks:
logger.info("WorkerService initialized with Cloud Tasks mode")
else:
logger.info("WorkerService initialized with direct HTTP mode")
def _should_use_cloud_tasks(self) -> bool:
"""
Check if Cloud Tasks should be used for worker coordination.
Controlled by ENABLE_CLOUD_TASKS setting (from environment variable).
Default is false (direct HTTP mode) for backward compatibility.
Returns:
True if Cloud Tasks should be used, False for direct HTTP
"""
return self.settings.enable_cloud_tasks
@property
def tasks_client(self):
"""
Lazy-initialize Cloud Tasks client.
Only created when needed to avoid import overhead in development mode.
"""
if self._tasks_client is None and self._use_cloud_tasks:
try:
from google.cloud import tasks_v2
self._tasks_client = tasks_v2.CloudTasksClient()
except ImportError:
logger.error(
"google-cloud-tasks not installed. "
"Install with: pip install google-cloud-tasks"
)
raise
return self._tasks_client
def _get_admin_token(self) -> Optional[str]:
"""
Get admin token for internal API authentication.
Returns the first admin token from ADMIN_TOKENS env var.
"""
admin_tokens_str = self.settings.admin_tokens or ""
tokens = [t.strip() for t in admin_tokens_str.split(",") if t.strip()]
if tokens:
return tokens[0]
return None
def _get_base_url(self) -> str:
"""
Get base URL for internal API calls.
Priority:
1. TEST_SERVER_URL env var (for tests)
2. CLOUD_RUN_SERVICE_URL env var (for Cloud Tasks to call back)
3. localhost with PORT env var (for development)
Returns:
Base URL for API calls
"""
# Check for test environment override
test_url = os.getenv("TEST_SERVER_URL")
if test_url:
return test_url
# Production: Cloud Run service URL
# This must be the publicly accessible URL for Cloud Tasks to call
service_url = os.getenv("CLOUD_RUN_SERVICE_URL")
if service_url:
return service_url
# Development mode: use localhost with PORT env var
port = os.getenv("PORT", "8000")
return f"http://localhost:{port}"
async def trigger_worker(
self,
worker_type: str,
job_id: str,
timeout_seconds: int = 30
) -> bool:
"""
Trigger a background worker for a job.
In production (ENABLE_CLOUD_TASKS=true):
- Enqueues task to Cloud Tasks queue
- Cloud Tasks delivers HTTP request to internal endpoint
- Automatic retries on failure with exponential backoff
- Rate limiting protects external APIs
In development (ENABLE_CLOUD_TASKS=false):
- Direct HTTP POST to internal endpoint
- Faster iteration, but no retry guarantees
- Worker runs in same container as API
Args:
worker_type: Worker type ("audio", "lyrics", "screens", "render-video", "video")
job_id: Job ID to process
timeout_seconds: Request timeout (for direct HTTP mode)
Returns:
True if trigger successful (or task enqueued), False otherwise
"""
if self._use_cloud_tasks:
return await self._enqueue_cloud_task(worker_type, job_id)
else:
return await self._trigger_http(worker_type, job_id, timeout_seconds)
async def _enqueue_cloud_task(self, worker_type: str, job_id: str) -> bool:
"""
Enqueue task to Cloud Tasks for guaranteed delivery.
The task will be delivered as an HTTP POST to the internal worker endpoint.
Cloud Tasks handles:
- Retry on failure (with exponential backoff)
- Rate limiting (max dispatches per second)
- Deduplication (via task name if needed)
- OIDC authentication for Cloud Run
Observability:
- Injects trace context headers so worker spans link to parent trace
Args:
worker_type: Worker type
job_id: Job ID to process
Returns:
True if task enqueued successfully, False otherwise
"""
try:
from google.cloud import tasks_v2
queue_name = WORKER_QUEUES.get(worker_type)
if not queue_name:
logger.error(f"Unknown worker type: {worker_type}")
return False
project = self.settings.google_cloud_project
if not project:
logger.error("GOOGLE_CLOUD_PROJECT not set, cannot enqueue Cloud Task")
return False
location = self.settings.gcp_region # Must match queue location
# Build queue path
parent = self.tasks_client.queue_path(project, location, queue_name)
# Build base headers
headers = {
"Content-Type": "application/json",
}
# Add admin auth via custom header
# NOTE: We use X-Admin-Token instead of Authorization because Cloud Tasks
# OIDC token overwrites the Authorization header when oidc_token is specified.
# The OIDC token handles Cloud Run authentication (allows Cloud Tasks to invoke
# the service), while X-Admin-Token handles application-level authentication.
if self._admin_token:
headers["X-Admin-Token"] = self._admin_token
logger.debug(
f"[job:{job_id}] Using admin token for Cloud Task auth via X-Admin-Token, "
f"token prefix: {self._admin_token[:8]}..., len={len(self._admin_token)}"
)
# Inject trace context for distributed tracing
# 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": {
"http_method": tasks_v2.HttpMethod.POST,
"url": f"{self._base_url}/api/internal/workers/{worker_type}",
"headers": headers,
"body": json.dumps({"job_id": job_id}).encode(),
# Use OIDC token for Cloud Run authentication
# This allows Cloud Tasks to invoke the Cloud Run service
"oidc_token": {
"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
# Note: We don't set a task name, allowing Cloud Tasks to generate one
# 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)"
)
return True
except Exception as e:
logger.error(
f"[job:{job_id}] Failed to enqueue Cloud Task for {worker_type}: {e}",
exc_info=True
)
return False
async def _trigger_http(
self,
worker_type: str,
job_id: str,
timeout_seconds: int = 30
) -> bool:
"""
Trigger worker via direct HTTP call (development mode).
This is the original implementation - direct HTTP POST to internal endpoint.
The endpoint adds the worker function to FastAPI BackgroundTasks.
Observability:
- Injects trace context headers so worker spans link to parent trace
Args:
worker_type: Worker type
job_id: Job ID to process
timeout_seconds: Request timeout
Returns:
True if trigger successful, False otherwise
"""
try:
# Build headers with admin auth token
headers = {}
if self._admin_token:
headers["Authorization"] = f"Bearer {self._admin_token}"
# Inject trace context for distributed tracing
headers = inject_trace_context(headers)
async with httpx.AsyncClient(timeout=timeout_seconds) as client:
url = f"{self._base_url}/api/internal/workers/{worker_type}"
response = await client.post(
url,
json={"job_id": job_id},
headers=headers
)
if response.status_code == 200:
logger.info(f"[job:{job_id}] Successfully triggered {worker_type} worker")
return True
else:
logger.error(
f"[job:{job_id}] Failed to trigger {worker_type} worker: "
f"HTTP {response.status_code} - {response.text}"
)
return False
except httpx.TimeoutException:
logger.error(f"[job:{job_id}] Timeout triggering {worker_type} worker")
return False
except Exception as e:
logger.error(
f"[job:{job_id}] Error triggering {worker_type} worker: {e}",
exc_info=True
)
return False
# Convenience methods for specific workers
# These provide a cleaner API and better IDE autocomplete
async def trigger_audio_worker(self, job_id: str) -> bool:
"""Trigger audio separation worker."""
return await self.trigger_worker("audio", job_id)
async def trigger_lyrics_worker(self, job_id: str) -> bool:
"""Trigger lyrics transcription worker."""
return await self.trigger_worker("lyrics", job_id)
async def trigger_screens_worker(self, job_id: str) -> bool:
"""Trigger screen generation worker."""
return await self.trigger_worker("screens", job_id)
async def trigger_video_worker(self, job_id: str) -> bool:
"""
Trigger video generation worker.
When USE_CLOUD_RUN_JOBS_FOR_VIDEO=true and ENABLE_CLOUD_TASKS=true,
uses Cloud Run Jobs for execution (supports >30 min encoding).
Otherwise, uses Cloud Tasks or direct HTTP.
"""
if self._use_cloud_tasks and self.settings.use_cloud_run_jobs_for_video:
return await self._trigger_cloud_run_job(job_id)
return await self.trigger_worker("video", job_id)
async def _trigger_cloud_run_job(self, job_id: str) -> bool:
"""
Trigger video encoding as a Cloud Run Job.
Cloud Run Jobs support up to 24 hours of execution time,
making them suitable for very long video encoding tasks.
Args:
job_id: Job ID to process
Returns:
True if job was triggered successfully, False otherwise
"""
try:
from google.cloud import run_v2
project = self.settings.google_cloud_project
if not project:
logger.error("GOOGLE_CLOUD_PROJECT not set, cannot trigger Cloud Run Job")
return False
location = self.settings.gcp_region
job_name = f"projects/{project}/locations/{location}/jobs/video-encoding-job"
# Create Cloud Run Jobs client
client = run_v2.JobsClient()
# Run the job with overrides for the specific job_id
request = run_v2.RunJobRequest(
name=job_name,
overrides=run_v2.RunJobRequest.Overrides(
container_overrides=[
run_v2.RunJobRequest.Overrides.ContainerOverride(
args=["python", "-m", "backend.workers.video_worker", "--job-id", job_id],
)
]
)
)
# Run the job (async operation)
operation = client.run_job(request=request)
logger.info(f"Started Cloud Run Job for video encoding, job {job_id}: {operation.metadata}")
return True
except Exception as e:
logger.error(
f"Failed to trigger Cloud Run Job for video/{job_id}: {e}",
exc_info=True
)
return False
async def trigger_render_video_worker(self, job_id: str) -> bool:
"""Trigger render video worker (post-review)."""
return await self.trigger_worker("render-video", job_id)
# Global worker service instance
_worker_service: Optional[WorkerService] = None
def get_worker_service() -> WorkerService:
"""
Get global worker service instance.
Singleton pattern to reuse HTTP client pool.
Returns:
WorkerService instance
"""
global _worker_service
if _worker_service is None:
_worker_service = WorkerService()
return _worker_service
def reset_worker_service() -> None:
"""
Reset the global worker service instance.
Used in tests to ensure clean state between test cases.
"""
global _worker_service
_worker_service = None
-112
View File
@@ -1,112 +0,0 @@
"""
YouTube credential service for server-side video uploads.
This service manages YouTube OAuth credentials stored in Secret Manager
for non-interactive uploads from backend workers.
"""
import json
import logging
from typing import Optional, Dict, Any
from backend.config import get_settings
logger = logging.getLogger(__name__)
class YouTubeService:
"""Service for managing YouTube OAuth credentials."""
# Secret Manager secret name for YouTube credentials
YOUTUBE_CREDENTIALS_SECRET = "youtube-oauth-credentials"
def __init__(self):
self.settings = get_settings()
self._credentials: Optional[Dict[str, Any]] = None
self._loaded = False
def load_credentials(self) -> bool:
"""
Load YouTube OAuth credentials from Secret Manager.
The secret should contain a JSON object with:
- token: Current access token (may be expired)
- refresh_token: Refresh token for getting new access tokens
- token_uri: Token endpoint URL
- client_id: OAuth client ID
- client_secret: OAuth client secret
- scopes: List of OAuth scopes
Returns:
True if credentials were loaded successfully, False otherwise
"""
if self._loaded:
return self._credentials is not None
try:
# Get credentials from Secret Manager
creds_json = self.settings.get_secret(self.YOUTUBE_CREDENTIALS_SECRET)
if not creds_json:
logger.warning("YouTube credentials not found in Secret Manager")
self._loaded = True
return False
# Parse the credentials JSON
self._credentials = json.loads(creds_json)
# Validate required fields
required_fields = ['refresh_token', 'token_uri', 'client_id', 'client_secret']
missing = [f for f in required_fields if not self._credentials.get(f)]
if missing:
logger.error(f"YouTube credentials missing required fields: {missing}")
self._credentials = None
self._loaded = True
return False
logger.info("YouTube credentials loaded successfully from Secret Manager")
self._loaded = True
return True
except json.JSONDecodeError as e:
logger.error(f"Failed to parse YouTube credentials JSON: {e}")
self._loaded = True
return False
except Exception as e:
logger.error(f"Failed to load YouTube credentials: {e}")
self._loaded = True
return False
def get_credentials_dict(self) -> Optional[Dict[str, Any]]:
"""
Get the YouTube credentials as a dictionary.
This format is compatible with KaraokeFinalise's user_youtube_credentials
parameter, which creates a google.oauth2.credentials.Credentials object.
Returns:
Dictionary with credential data, or None if not available
"""
if not self._loaded:
self.load_credentials()
return self._credentials
@property
def is_configured(self) -> bool:
"""Check if YouTube credentials are configured and ready to use."""
if not self._loaded:
self.load_credentials()
return self._credentials is not None
# Singleton instance
_youtube_service: Optional[YouTubeService] = None
def get_youtube_service() -> YouTubeService:
"""Get the singleton YouTube service instance."""
global _youtube_service
if _youtube_service is None:
_youtube_service = YouTubeService()
return _youtube_service
-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
-4
View File
@@ -1,4 +0,0 @@
"""
Backend integration tests package.
"""
Loaded 100 of 1057 files, more files were not shown because too many files have changed in this diff. Show more