Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
ddc4460065 | ||
|
|
b0f3d15112 | ||
|
|
753499db01 | ||
|
|
1b6e682860 | ||
|
|
9baba12280 | ||
|
|
24b7b75ab2 | ||
|
|
0b59b7abfc | ||
|
|
942cbb4f66 | ||
|
|
96383a60d4 | ||
|
|
0cf14be531 | ||
|
|
95edd82555 | ||
|
|
6e02ca3056 | ||
|
|
966e8cc963 | ||
|
|
04b1c8fd3e | ||
|
|
f47b126c08 | ||
|
|
4438293b6d | ||
|
|
de4e92d9bf | ||
|
|
e7f88b60d0 | ||
|
|
fbb1cd7299 | ||
|
|
77820a44c9 | ||
|
|
e92ddd8609 | ||
|
|
a2bf2230ab | ||
|
|
75c6879b7e | ||
|
|
f51ef68179 | ||
|
|
8a5420f5f8 | ||
|
|
c9b7f1bb1a | ||
|
|
d9da1dd360 | ||
|
|
a8fa6b5f46 | ||
|
|
ebe0121938 | ||
|
|
01db9a764a | ||
|
|
f524796f7f | ||
|
|
8372ed211a | ||
|
|
78068ea1d8 | ||
|
|
84d7c12f13 | ||
|
|
7a4ed9661c | ||
|
|
dd62c32026 | ||
|
|
c130fa8a07 | ||
|
|
e0d1fa7536 | ||
|
|
29ffbd4ae2 | ||
|
|
e440f0bbcd | ||
|
|
e0f5a84e54 | ||
|
|
8da57da767 | ||
|
|
b840a12669 | ||
|
|
f7038ce72c | ||
|
|
138ddeecf5 | ||
|
|
a7d9bb40b9 | ||
|
|
20f842fa85 | ||
|
|
1b74199032 | ||
|
|
e75c5b2723 | ||
|
|
36a60c09da | ||
|
|
ba4534fdbd |
No files matched your search
@@ -0,0 +1,217 @@
|
||||
---
|
||||
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
|
||||
@@ -415,8 +415,9 @@ jobs:
|
||||
run: |
|
||||
echo "🔍 Checking if base image needs rebuild..."
|
||||
|
||||
CURRENT_HASH=$(sha256sum poetry.lock | cut -d' ' -f1)
|
||||
echo "Current poetry.lock hash: $CURRENT_HASH"
|
||||
# Hash both poetry.lock AND Dockerfile.base - rebuild if either changes
|
||||
CURRENT_HASH=$(cat poetry.lock backend/Dockerfile.base | sha256sum | cut -d' ' -f1)
|
||||
echo "Current combined hash (poetry.lock + Dockerfile.base): $CURRENT_HASH"
|
||||
|
||||
gcloud auth configure-docker us-central1-docker.pkg.dev --quiet
|
||||
|
||||
@@ -424,14 +425,18 @@ jobs:
|
||||
EXISTING_HASH=""
|
||||
|
||||
if docker pull $BASE_IMAGE 2>/dev/null; then
|
||||
EXISTING_HASH=$(docker inspect $BASE_IMAGE --format='{{index .Config.Labels "poetry.lock.hash"}}' 2>/dev/null || echo "")
|
||||
EXISTING_HASH=$(docker inspect $BASE_IMAGE --format='{{index .Config.Labels "base.content.hash"}}' 2>/dev/null || echo "")
|
||||
# Fallback to old label name for backwards compatibility
|
||||
if [ -z "$EXISTING_HASH" ]; then
|
||||
EXISTING_HASH=$(docker inspect $BASE_IMAGE --format='{{index .Config.Labels "poetry.lock.hash"}}' 2>/dev/null || echo "")
|
||||
fi
|
||||
echo "Existing base image hash: $EXISTING_HASH"
|
||||
else
|
||||
echo "⚠️ No existing base image found"
|
||||
fi
|
||||
|
||||
if [ "$CURRENT_HASH" != "$EXISTING_HASH" ]; then
|
||||
echo "🔄 Base image needs rebuild (poetry.lock changed)"
|
||||
echo "🔄 Base image needs rebuild (poetry.lock or Dockerfile.base changed)"
|
||||
echo "needs_rebuild=true" >> $GITHUB_OUTPUT
|
||||
else
|
||||
echo "✅ Base image is up to date"
|
||||
|
||||
@@ -11,7 +11,9 @@
|
||||
# gcloud builds submit --config=cloudbuild-base.yaml --project=nomadkaraoke
|
||||
|
||||
# Use pre-built base image with all dependencies
|
||||
FROM us-central1-docker.pkg.dev/nomadkaraoke/karaoke-repo/karaoke-backend-base:latest
|
||||
# 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
|
||||
@@ -34,5 +36,7 @@ ENV PORT=8080
|
||||
# Expose port
|
||||
EXPOSE 8080
|
||||
|
||||
# Run the application
|
||||
# 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)
|
||||
CMD ["uvicorn", "backend.main:app", "--host", "0.0.0.0", "--port", "8080"]
|
||||
@@ -7,12 +7,15 @@
|
||||
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 \
|
||||
ffmpeg \
|
||||
libsndfile1 \
|
||||
libsox-dev \
|
||||
sox \
|
||||
build-essential \
|
||||
curl \
|
||||
&& rm -rf /var/lib/apt/lists/*
|
||||
|
||||
# Set working directory
|
||||
@@ -34,9 +37,9 @@ RUN python -m spacy download en_core_web_sm
|
||||
# Label with build info
|
||||
ARG BUILD_DATE
|
||||
ARG BUILD_ID
|
||||
ARG POETRY_LOCK_HASH
|
||||
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 for karaoke-backend"
|
||||
LABEL poetry.lock.hash="${POETRY_LOCK_HASH}"
|
||||
LABEL org.opencontainers.image.description="Base image with Python dependencies and system tools for karaoke-backend"
|
||||
LABEL base.content.hash="${BASE_CONTENT_HASH}"
|
||||
@@ -82,15 +82,40 @@ class AudioSearchRequest(BaseModel):
|
||||
|
||||
|
||||
class AudioSearchResultResponse(BaseModel):
|
||||
"""A single audio search result."""
|
||||
"""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
|
||||
url: str
|
||||
duration: Optional[int] = None
|
||||
quality: Optional[str] = None
|
||||
source_id: Optional[str] = None
|
||||
provider: str # Maps to source_name in Release
|
||||
url: str # Maps to download_url in Release
|
||||
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):
|
||||
@@ -418,20 +443,50 @@ async def search_audio(
|
||||
message=f"Found {len(search_results)} audio sources. Waiting for selection."
|
||||
)
|
||||
|
||||
# Convert to response format
|
||||
result_responses = [
|
||||
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,
|
||||
# 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_dict = {}
|
||||
if r.raw_result:
|
||||
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()
|
||||
quality_data=raw_dict.get('quality'),
|
||||
)
|
||||
)
|
||||
for r in search_results
|
||||
]
|
||||
|
||||
return AudioSearchResponse(
|
||||
status="awaiting_selection",
|
||||
@@ -473,6 +528,8 @@ async def get_audio_search_results(job_id: str):
|
||||
"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),
|
||||
}
|
||||
|
||||
@@ -131,6 +131,10 @@ class CreateJobWithUploadUrlsRequest(BaseModel):
|
||||
|
||||
# Existing instrumental configuration (Batch 3)
|
||||
existing_instrumental: bool = Field(False, description="Whether an existing instrumental file is being uploaded")
|
||||
|
||||
# Two-phase workflow configuration (Batch 6)
|
||||
prep_only: bool = Field(False, description="Stop after review phase, don't run finalisation")
|
||||
keep_brand_code: Optional[str] = Field(None, description="Preserve existing brand code instead of generating new one")
|
||||
|
||||
|
||||
class SignedUploadUrl(BaseModel):
|
||||
@@ -638,6 +642,56 @@ VALID_FILE_TYPES = {
|
||||
'existing_instrumental': ALLOWED_AUDIO_EXTENSIONS, # Batch 3: user-provided instrumental
|
||||
}
|
||||
|
||||
# Valid file types for finalise-only mode (Batch 6)
|
||||
ALLOWED_VIDEO_EXTENSIONS = {'.mkv', '.mov', '.mp4'}
|
||||
FINALISE_ONLY_FILE_TYPES = {
|
||||
'audio': ALLOWED_AUDIO_EXTENSIONS, # Original audio
|
||||
'with_vocals': ALLOWED_VIDEO_EXTENSIONS, # Karaoke video from prep
|
||||
'title_screen': ALLOWED_VIDEO_EXTENSIONS, # Title screen video
|
||||
'end_screen': ALLOWED_VIDEO_EXTENSIONS, # End screen video
|
||||
'title_jpg': ALLOWED_IMAGE_EXTENSIONS, # Title screen JPG
|
||||
'title_png': ALLOWED_IMAGE_EXTENSIONS, # Title screen PNG
|
||||
'end_jpg': ALLOWED_IMAGE_EXTENSIONS, # End screen JPG
|
||||
'end_png': ALLOWED_IMAGE_EXTENSIONS, # End screen PNG
|
||||
'instrumental_clean': ALLOWED_AUDIO_EXTENSIONS, # Clean instrumental
|
||||
'instrumental_backing': ALLOWED_AUDIO_EXTENSIONS, # Instrumental with backing vocals
|
||||
'lrc': {'.lrc'}, # LRC lyrics
|
||||
'ass': {'.ass'}, # ASS subtitles
|
||||
'corrections': {'.json'}, # Corrections JSON
|
||||
'style_params': {'.json'}, # Style params
|
||||
}
|
||||
|
||||
# Pydantic models for finalise-only flow (Batch 6)
|
||||
class FinaliseOnlyFileRequest(BaseModel):
|
||||
"""Information about a prep output file to be uploaded for finalise-only mode."""
|
||||
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 prep file: 'with_vocals', 'title_screen', 'end_screen', 'instrumental_clean', 'instrumental_backing', 'lrc', etc.")
|
||||
|
||||
|
||||
class CreateFinaliseOnlyJobRequest(BaseModel):
|
||||
"""Request to create a finalise-only job with prep output files."""
|
||||
artist: str = Field(..., description="Artist name")
|
||||
title: str = Field(..., description="Song title")
|
||||
files: List[FinaliseOnlyFileRequest] = Field(..., description="List of prep output files to upload")
|
||||
|
||||
# Processing options
|
||||
enable_cdg: bool = Field(True, description="Generate CDG+MP3 package")
|
||||
enable_txt: bool = Field(True, description="Generate TXT+MP3 package")
|
||||
|
||||
# Finalisation options
|
||||
brand_prefix: Optional[str] = Field(None, description="Brand code prefix (e.g., NOMAD)")
|
||||
keep_brand_code: Optional[str] = Field(None, description="Preserve existing brand code from folder name")
|
||||
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")
|
||||
|
||||
|
||||
|
||||
|
||||
async def _validate_audio_durations(
|
||||
storage: StorageService,
|
||||
@@ -1243,3 +1297,425 @@ async def create_job_from_url(
|
||||
except Exception as e:
|
||||
logger.error(f"Error creating job from URL: {e}", exc_info=True)
|
||||
raise HTTPException(status_code=500, detail=str(e)) from e
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# Finalise-Only Upload Flow (Batch 6)
|
||||
# ============================================================================
|
||||
|
||||
def _get_gcs_path_for_finalise_file(job_id: str, file_type: str, filename: str) -> str:
|
||||
"""Generate the GCS path for a finalise-only file based on its type."""
|
||||
ext = Path(filename).suffix.lower()
|
||||
|
||||
# Map file types to appropriate GCS paths
|
||||
if file_type == 'audio':
|
||||
return f"uploads/{job_id}/audio/{filename}"
|
||||
elif file_type == 'with_vocals':
|
||||
return f"jobs/{job_id}/videos/with_vocals{ext}"
|
||||
elif file_type == 'title_screen':
|
||||
return f"jobs/{job_id}/screens/title{ext}"
|
||||
elif file_type == 'end_screen':
|
||||
return f"jobs/{job_id}/screens/end{ext}"
|
||||
elif file_type == 'title_jpg':
|
||||
return f"jobs/{job_id}/screens/title.jpg"
|
||||
elif file_type == 'title_png':
|
||||
return f"jobs/{job_id}/screens/title.png"
|
||||
elif file_type == 'end_jpg':
|
||||
return f"jobs/{job_id}/screens/end.jpg"
|
||||
elif file_type == 'end_png':
|
||||
return f"jobs/{job_id}/screens/end.png"
|
||||
elif file_type == 'instrumental_clean':
|
||||
return f"jobs/{job_id}/stems/instrumental_clean{ext}"
|
||||
elif file_type == 'instrumental_backing':
|
||||
return f"jobs/{job_id}/stems/instrumental_with_backing{ext}"
|
||||
elif file_type == 'lrc':
|
||||
return f"jobs/{job_id}/lyrics/karaoke.lrc"
|
||||
elif file_type == 'ass':
|
||||
return f"jobs/{job_id}/lyrics/karaoke.ass"
|
||||
elif file_type == 'corrections':
|
||||
return f"jobs/{job_id}/lyrics/corrections.json"
|
||||
elif file_type == 'style_params':
|
||||
return f"uploads/{job_id}/style/style_params.json"
|
||||
else:
|
||||
return f"uploads/{job_id}/other/{filename}"
|
||||
|
||||
|
||||
@router.post("/jobs/create-finalise-only")
|
||||
async def create_finalise_only_job(
|
||||
request: Request,
|
||||
body: CreateFinaliseOnlyJobRequest,
|
||||
):
|
||||
"""
|
||||
Create a finalise-only job for continuing from a local prep phase.
|
||||
|
||||
This endpoint is used when:
|
||||
1. User previously ran --prep-only which created local prep outputs
|
||||
2. User optionally made manual edits to stems, lyrics, etc.
|
||||
3. User now wants cloud to handle finalisation (encoding, distribution)
|
||||
|
||||
Required files:
|
||||
- with_vocals: The karaoke video from prep (*.mkv or *.mov)
|
||||
- title_screen: Title screen video
|
||||
- end_screen: End screen video
|
||||
- instrumental_clean or instrumental_backing: At least one instrumental
|
||||
|
||||
The endpoint returns signed URLs for uploading all the prep files.
|
||||
"""
|
||||
try:
|
||||
# Validate files list
|
||||
if not body.files:
|
||||
raise HTTPException(status_code=400, detail="At least one file is required")
|
||||
|
||||
# Validate file types
|
||||
file_types = {f.file_type for f in body.files}
|
||||
|
||||
# Check required files for finalise-only
|
||||
if 'with_vocals' not in file_types:
|
||||
raise HTTPException(
|
||||
status_code=400,
|
||||
detail="with_vocals video is required for finalise-only mode"
|
||||
)
|
||||
if 'title_screen' not in file_types:
|
||||
raise HTTPException(
|
||||
status_code=400,
|
||||
detail="title_screen video is required for finalise-only mode"
|
||||
)
|
||||
if 'end_screen' not in file_types:
|
||||
raise HTTPException(
|
||||
status_code=400,
|
||||
detail="end_screen video is required for finalise-only mode"
|
||||
)
|
||||
if 'instrumental_clean' not in file_types and 'instrumental_backing' not in file_types:
|
||||
raise HTTPException(
|
||||
status_code=400,
|
||||
detail="At least one instrumental (clean or backing) is required"
|
||||
)
|
||||
|
||||
# Validate file extensions
|
||||
for file_info in body.files:
|
||||
if file_info.file_type not in FINALISE_ONLY_FILE_TYPES:
|
||||
raise HTTPException(
|
||||
status_code=400,
|
||||
detail=f"Invalid file_type: '{file_info.file_type}'. Valid types: {list(FINALISE_ONLY_FILE_TYPES.keys())}"
|
||||
)
|
||||
|
||||
ext = Path(file_info.filename).suffix.lower()
|
||||
allowed_extensions = FINALISE_ONLY_FILE_TYPES[file_info.file_type]
|
||||
if ext not in allowed_extensions:
|
||||
raise HTTPException(
|
||||
status_code=400,
|
||||
detail=f"Invalid file extension '{ext}' for file_type '{file_info.file_type}'. Allowed: {allowed_extensions}"
|
||||
)
|
||||
|
||||
# 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
|
||||
|
||||
# Validate distribution credentials if services are requested
|
||||
invalid_services = []
|
||||
credential_manager = get_credential_manager()
|
||||
|
||||
if body.enable_youtube_upload:
|
||||
result = credential_manager.check_youtube_credentials()
|
||||
if result.status != CredentialStatus.VALID:
|
||||
invalid_services.append(f"youtube ({result.message})")
|
||||
|
||||
if 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"The following distribution services need re-authorization: {', '.join(invalid_services)}",
|
||||
"invalid_services": invalid_services,
|
||||
"auth_url": "/api/auth/status"
|
||||
}
|
||||
)
|
||||
|
||||
# Extract request metadata
|
||||
request_metadata = extract_request_metadata(request, created_from="finalise_only_upload")
|
||||
|
||||
# Create job with finalise_only=True
|
||||
job_create = JobCreate(
|
||||
artist=body.artist,
|
||||
title=body.title,
|
||||
filename="finalise_only", # No single audio file - using prep outputs
|
||||
enable_cdg=body.enable_cdg,
|
||||
enable_txt=body.enable_txt,
|
||||
brand_prefix=body.brand_prefix,
|
||||
enable_youtube_upload=body.enable_youtube_upload,
|
||||
youtube_description=body.youtube_description,
|
||||
discord_webhook_url=effective_discord_webhook_url,
|
||||
dropbox_path=effective_dropbox_path,
|
||||
gdrive_folder_id=effective_gdrive_folder_id,
|
||||
finalise_only=True,
|
||||
keep_brand_code=body.keep_brand_code,
|
||||
request_metadata=request_metadata,
|
||||
)
|
||||
job = job_manager.create_job(job_create)
|
||||
job_id = job.job_id
|
||||
|
||||
logger.info(f"Created finalise-only job {job_id} for {body.artist} - {body.title}")
|
||||
|
||||
# Generate signed upload URLs for each file
|
||||
upload_urls = []
|
||||
for file_info in body.files:
|
||||
gcs_path = _get_gcs_path_for_finalise_file(job_id, file_info.file_type, file_info.filename)
|
||||
|
||||
# Generate signed upload URL (valid for 60 minutes)
|
||||
signed_url = storage_service.generate_signed_upload_url(
|
||||
gcs_path,
|
||||
content_type=file_info.content_type,
|
||||
expiration_minutes=60
|
||||
)
|
||||
|
||||
upload_urls.append(SignedUploadUrl(
|
||||
file_type=file_info.file_type,
|
||||
gcs_path=gcs_path,
|
||||
upload_url=signed_url,
|
||||
content_type=file_info.content_type
|
||||
))
|
||||
|
||||
logger.info(f"Generated signed upload URL for {file_info.file_type}: {gcs_path}")
|
||||
|
||||
return CreateJobWithUploadUrlsResponse(
|
||||
status="success",
|
||||
job_id=job_id,
|
||||
message="Finalise-only job created. Upload files to the provided URLs, then call /api/jobs/{job_id}/finalise-uploads-complete",
|
||||
upload_urls=upload_urls,
|
||||
server_version=VERSION
|
||||
)
|
||||
|
||||
except HTTPException:
|
||||
raise
|
||||
except Exception as e:
|
||||
logger.error(f"Error creating finalise-only job: {e}", exc_info=True)
|
||||
raise HTTPException(status_code=500, detail=str(e)) from e
|
||||
|
||||
|
||||
@router.post("/jobs/{job_id}/finalise-uploads-complete")
|
||||
async def mark_finalise_uploads_complete(
|
||||
job_id: str,
|
||||
background_tasks: BackgroundTasks,
|
||||
body: UploadsCompleteRequest,
|
||||
):
|
||||
"""
|
||||
Mark finalise-only file uploads as complete and start video generation.
|
||||
|
||||
This is called after uploading prep outputs for a finalise-only job.
|
||||
The job will transition directly to AWAITING_INSTRUMENTAL_SELECTION.
|
||||
"""
|
||||
try:
|
||||
# Get job and verify it exists
|
||||
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 in pending state and is finalise-only
|
||||
if job.status != JobStatus.PENDING:
|
||||
raise HTTPException(
|
||||
status_code=400,
|
||||
detail=f"Job {job_id} is not in pending state (current: {job.status}). Cannot complete uploads."
|
||||
)
|
||||
|
||||
if not job.finalise_only:
|
||||
raise HTTPException(
|
||||
status_code=400,
|
||||
detail=f"Job {job_id} is not a finalise-only job. Use /api/jobs/{{job_id}}/uploads-complete instead."
|
||||
)
|
||||
|
||||
# Validate required files were uploaded
|
||||
required_files = {'with_vocals', 'title_screen', 'end_screen'}
|
||||
uploaded_set = set(body.uploaded_files)
|
||||
|
||||
missing_files = required_files - uploaded_set
|
||||
if missing_files:
|
||||
raise HTTPException(
|
||||
status_code=400,
|
||||
detail=f"Missing required files: {missing_files}"
|
||||
)
|
||||
|
||||
# Require at least one instrumental
|
||||
if 'instrumental_clean' not in uploaded_set and 'instrumental_backing' not in uploaded_set:
|
||||
raise HTTPException(
|
||||
status_code=400,
|
||||
detail="At least one instrumental (clean or backing) is required"
|
||||
)
|
||||
|
||||
# Build file_urls structure from uploaded files
|
||||
file_urls: Dict[str, Dict[str, str]] = {
|
||||
'videos': {},
|
||||
'screens': {},
|
||||
'stems': {},
|
||||
'lyrics': {},
|
||||
}
|
||||
|
||||
for file_type in body.uploaded_files:
|
||||
if file_type not in FINALISE_ONLY_FILE_TYPES:
|
||||
logger.warning(f"Unknown file_type in uploaded_files: {file_type}")
|
||||
continue
|
||||
|
||||
# Determine the GCS path - we need to find the actual file
|
||||
if file_type == 'audio':
|
||||
prefix = f"uploads/{job_id}/audio/"
|
||||
elif file_type == 'with_vocals':
|
||||
prefix = f"jobs/{job_id}/videos/with_vocals"
|
||||
elif file_type == 'title_screen':
|
||||
prefix = f"jobs/{job_id}/screens/title"
|
||||
elif file_type == 'end_screen':
|
||||
prefix = f"jobs/{job_id}/screens/end"
|
||||
elif file_type == 'title_jpg':
|
||||
prefix = f"jobs/{job_id}/screens/title.jpg"
|
||||
elif file_type == 'title_png':
|
||||
prefix = f"jobs/{job_id}/screens/title.png"
|
||||
elif file_type == 'end_jpg':
|
||||
prefix = f"jobs/{job_id}/screens/end.jpg"
|
||||
elif file_type == 'end_png':
|
||||
prefix = f"jobs/{job_id}/screens/end.png"
|
||||
elif file_type == 'instrumental_clean':
|
||||
prefix = f"jobs/{job_id}/stems/instrumental_clean"
|
||||
elif file_type == 'instrumental_backing':
|
||||
prefix = f"jobs/{job_id}/stems/instrumental_with_backing"
|
||||
elif file_type == 'lrc':
|
||||
prefix = f"jobs/{job_id}/lyrics/karaoke.lrc"
|
||||
elif file_type == 'ass':
|
||||
prefix = f"jobs/{job_id}/lyrics/karaoke.ass"
|
||||
elif file_type == 'corrections':
|
||||
prefix = f"jobs/{job_id}/lyrics/corrections"
|
||||
elif file_type == 'style_params':
|
||||
prefix = f"uploads/{job_id}/style/style_params"
|
||||
else:
|
||||
continue
|
||||
|
||||
# List files with this prefix to find the actual uploaded file
|
||||
files = storage_service.list_files(prefix)
|
||||
if not files:
|
||||
raise HTTPException(
|
||||
status_code=400,
|
||||
detail=f"File for '{file_type}' was not uploaded to GCS. Expected prefix: {prefix}"
|
||||
)
|
||||
|
||||
gcs_path = files[0]
|
||||
|
||||
# Map to file_urls structure
|
||||
if file_type == 'audio':
|
||||
pass # Handled separately
|
||||
elif file_type == 'with_vocals':
|
||||
file_urls['videos']['with_vocals'] = gcs_path
|
||||
elif file_type == 'title_screen':
|
||||
file_urls['screens']['title'] = gcs_path
|
||||
elif file_type == 'end_screen':
|
||||
file_urls['screens']['end'] = gcs_path
|
||||
elif file_type == 'title_jpg':
|
||||
file_urls['screens']['title_jpg'] = gcs_path
|
||||
elif file_type == 'title_png':
|
||||
file_urls['screens']['title_png'] = gcs_path
|
||||
elif file_type == 'end_jpg':
|
||||
file_urls['screens']['end_jpg'] = gcs_path
|
||||
elif file_type == 'end_png':
|
||||
file_urls['screens']['end_png'] = gcs_path
|
||||
elif file_type == 'instrumental_clean':
|
||||
file_urls['stems']['instrumental_clean'] = gcs_path
|
||||
elif file_type == 'instrumental_backing':
|
||||
file_urls['stems']['instrumental_with_backing'] = gcs_path
|
||||
elif file_type == 'lrc':
|
||||
file_urls['lyrics']['lrc'] = gcs_path
|
||||
elif file_type == 'ass':
|
||||
file_urls['lyrics']['ass'] = gcs_path
|
||||
elif file_type == 'corrections':
|
||||
file_urls['lyrics']['corrections'] = gcs_path
|
||||
|
||||
# Get audio path if uploaded
|
||||
audio_gcs_path = None
|
||||
if 'audio' in body.uploaded_files:
|
||||
audio_files = storage_service.list_files(f"uploads/{job_id}/audio/")
|
||||
if audio_files:
|
||||
audio_gcs_path = audio_files[0]
|
||||
|
||||
# Update job with file paths
|
||||
update_data = {
|
||||
'file_urls': file_urls,
|
||||
'finalise_only': True,
|
||||
}
|
||||
|
||||
if audio_gcs_path:
|
||||
update_data['input_media_gcs_path'] = audio_gcs_path
|
||||
|
||||
# Mark parallel processing as complete (we're skipping it)
|
||||
update_data['state_data'] = {
|
||||
'audio_complete': True,
|
||||
'lyrics_complete': True,
|
||||
'finalise_only': True,
|
||||
}
|
||||
|
||||
job_manager.update_job(job_id, update_data)
|
||||
|
||||
logger.info(f"Validated finalise-only uploads for job {job_id}: {body.uploaded_files}")
|
||||
|
||||
# Transition directly to AWAITING_INSTRUMENTAL_SELECTION
|
||||
job_manager.transition_to_state(
|
||||
job_id=job_id,
|
||||
new_status=JobStatus.AWAITING_INSTRUMENTAL_SELECTION,
|
||||
progress=80,
|
||||
message="Prep files uploaded - select your instrumental"
|
||||
)
|
||||
|
||||
# Get distribution services info for response
|
||||
credential_manager = get_credential_manager()
|
||||
distribution_services: Dict[str, Any] = {}
|
||||
|
||||
updated_job = job_manager.get_job(job_id)
|
||||
|
||||
if updated_job.dropbox_path:
|
||||
dropbox_result = credential_manager.check_dropbox_credentials()
|
||||
distribution_services["dropbox"] = {
|
||||
"enabled": True,
|
||||
"path": updated_job.dropbox_path,
|
||||
"credentials_valid": dropbox_result.status == CredentialStatus.VALID,
|
||||
}
|
||||
|
||||
if updated_job.gdrive_folder_id:
|
||||
gdrive_result = credential_manager.check_gdrive_credentials()
|
||||
distribution_services["gdrive"] = {
|
||||
"enabled": True,
|
||||
"folder_id": updated_job.gdrive_folder_id,
|
||||
"credentials_valid": gdrive_result.status == CredentialStatus.VALID,
|
||||
}
|
||||
|
||||
if updated_job.enable_youtube_upload:
|
||||
youtube_result = credential_manager.check_youtube_credentials()
|
||||
distribution_services["youtube"] = {
|
||||
"enabled": True,
|
||||
"credentials_valid": youtube_result.status == CredentialStatus.VALID,
|
||||
}
|
||||
|
||||
if updated_job.discord_webhook_url:
|
||||
distribution_services["discord"] = {
|
||||
"enabled": True,
|
||||
}
|
||||
|
||||
return {
|
||||
"status": "success",
|
||||
"job_id": job_id,
|
||||
"message": "Finalise-only uploads validated. Select instrumental to continue.",
|
||||
"files_validated": body.uploaded_files,
|
||||
"server_version": VERSION,
|
||||
"distribution_services": distribution_services,
|
||||
}
|
||||
|
||||
except HTTPException:
|
||||
raise
|
||||
except Exception as e:
|
||||
logger.error(f"Error completing finalise-only uploads for job {job_id}: {e}", exc_info=True)
|
||||
raise HTTPException(status_code=500, detail=str(e)) from e
|
||||
@@ -1,10 +1,64 @@
|
||||
"""
|
||||
Health check routes.
|
||||
"""
|
||||
import os
|
||||
import logging
|
||||
from fastapi import APIRouter
|
||||
from typing import Dict
|
||||
from typing import Dict, Any, Optional
|
||||
|
||||
from backend.version import VERSION
|
||||
from backend.services.flacfetch_client import get_flacfetch_client
|
||||
|
||||
router = APIRouter()
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
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")
|
||||
@@ -16,6 +70,67 @@ async def health_check() -> Dict[str, str]:
|
||||
}
|
||||
|
||||
|
||||
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),
|
||||
}
|
||||
|
||||
|
||||
@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()
|
||||
|
||||
# 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')}")
|
||||
|
||||
return {
|
||||
"status": "healthy",
|
||||
"service": "karaoke-gen-backend",
|
||||
"version": VERSION,
|
||||
"dependencies": {
|
||||
"transmission_local": transmission_status,
|
||||
"flacfetch_remote": flacfetch_status,
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@router.get("/readiness")
|
||||
async def readiness_check() -> Dict[str, str]:
|
||||
"""Readiness check endpoint for Cloud Run."""
|
||||
|
||||
@@ -56,6 +56,12 @@ class Settings(BaseSettings):
|
||||
# Storage paths
|
||||
temp_dir: str = os.getenv("TEMP_DIR", "/tmp/karaoke-gen")
|
||||
|
||||
# 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")
|
||||
|
||||
@@ -73,6 +73,7 @@ class JobStatus(str, Enum):
|
||||
|
||||
# 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
|
||||
|
||||
@@ -86,8 +87,8 @@ class JobStatus(str, Enum):
|
||||
|
||||
# Valid state transitions
|
||||
STATE_TRANSITIONS = {
|
||||
# PENDING can go to DOWNLOADING (file upload) or SEARCHING_AUDIO (artist+title search)
|
||||
JobStatus.PENDING: [JobStatus.DOWNLOADING, JobStatus.SEARCHING_AUDIO, JobStatus.FAILED, JobStatus.CANCELLED],
|
||||
# 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],
|
||||
@@ -115,10 +116,10 @@ STATE_TRANSITIONS = {
|
||||
# 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.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.FAILED],
|
||||
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],
|
||||
@@ -133,9 +134,11 @@ STATE_TRANSITIONS = {
|
||||
JobStatus.UPLOADING: [JobStatus.NOTIFYING, JobStatus.COMPLETE, JobStatus.FAILED],
|
||||
JobStatus.NOTIFYING: [JobStatus.COMPLETE, JobStatus.FAILED],
|
||||
|
||||
# Terminal states - COMPLETE and CANCELLED have no transitions
|
||||
# Terminal states - COMPLETE, PREP_COMPLETE, and CANCELLED have no transitions
|
||||
# FAILED allows 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.INSTRUMENTAL_SELECTED, # Retry from video generation
|
||||
JobStatus.REVIEW_COMPLETE, # Retry from render stage
|
||||
@@ -243,6 +246,11 @@ class Job(BaseModel):
|
||||
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
|
||||
|
||||
# Processing state
|
||||
track_output_dir: Optional[str] = None # Local output directory (temp)
|
||||
audio_hash: Optional[str] = None # Hash for deduplication
|
||||
@@ -424,6 +432,11 @@ class JobCreate(BaseModel):
|
||||
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)
|
||||
"""
|
||||
|
||||
@@ -1,79 +1,67 @@
|
||||
"""
|
||||
Audio search service for finding and downloading audio files.
|
||||
|
||||
This service integrates with flacfetch to search for audio from various sources
|
||||
(YouTube, music trackers, etc.) and download the selected audio file.
|
||||
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
|
||||
import tempfile
|
||||
from dataclasses import dataclass, asdict
|
||||
from typing import List, Optional, Dict, Any
|
||||
from typing import List, Optional
|
||||
|
||||
# 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__)
|
||||
|
||||
|
||||
@dataclass
|
||||
class AudioSearchResult:
|
||||
"""
|
||||
Represents a single search result for audio.
|
||||
|
||||
This is a serializable representation of a search result that can be
|
||||
stored in Firestore and sent to clients.
|
||||
"""
|
||||
title: str
|
||||
artist: str
|
||||
provider: str
|
||||
url: str
|
||||
duration: Optional[int] = None # Duration in seconds
|
||||
quality: Optional[str] = None # e.g., "FLAC", "320kbps", etc.
|
||||
source_id: Optional[str] = None # Unique ID from the source
|
||||
index: int = 0 # Index in the results list (for selection)
|
||||
|
||||
def to_dict(self) -> Dict[str, Any]:
|
||||
"""Convert to dict for JSON serialization."""
|
||||
return asdict(self)
|
||||
|
||||
@classmethod
|
||||
def from_dict(cls, data: Dict[str, Any]) -> "AudioSearchResult":
|
||||
"""Create from dict."""
|
||||
return cls(**data)
|
||||
# Re-export exception under backend's naming convention for compatibility
|
||||
AudioSearchError = AudioFetcherError
|
||||
|
||||
|
||||
@dataclass
|
||||
class AudioDownloadResult:
|
||||
"""Result of downloading an audio file."""
|
||||
filepath: str
|
||||
artist: str
|
||||
title: str
|
||||
provider: str
|
||||
duration: Optional[int] = None
|
||||
quality: Optional[str] = None
|
||||
|
||||
|
||||
class AudioSearchError(Exception):
|
||||
"""Base exception for audio search errors."""
|
||||
pass
|
||||
|
||||
|
||||
class NoResultsError(AudioSearchError):
|
||||
"""Raised when no search results are found."""
|
||||
pass
|
||||
|
||||
|
||||
class DownloadError(AudioSearchError):
|
||||
"""Raised when download fails."""
|
||||
pass
|
||||
# Also alias AudioFetchResult as AudioDownloadResult for backwards compatibility
|
||||
AudioDownloadResult = AudioFetchResult
|
||||
|
||||
|
||||
class AudioSearchService:
|
||||
"""
|
||||
Service for searching and downloading audio files using flacfetch.
|
||||
Service for searching and downloading audio files.
|
||||
|
||||
This service is used by the backend to:
|
||||
1. Search for audio by artist/title
|
||||
2. Return results for user selection
|
||||
3. Download the selected audio to a local file
|
||||
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"
|
||||
@@ -93,60 +81,42 @@ class AudioSearchService:
|
||||
"""
|
||||
# Use environment variables if not explicitly provided
|
||||
if redacted_api_key is self._USE_ENV:
|
||||
self._redacted_api_key = os.environ.get("REDACTED_API_KEY")
|
||||
else:
|
||||
self._redacted_api_key = redacted_api_key
|
||||
redacted_api_key = os.environ.get("REDACTED_API_KEY")
|
||||
|
||||
if ops_api_key is self._USE_ENV:
|
||||
self._ops_api_key = os.environ.get("OPS_API_KEY")
|
||||
else:
|
||||
self._ops_api_key = ops_api_key
|
||||
|
||||
self._manager = None
|
||||
self._raw_results = {} # Cache raw results for download
|
||||
|
||||
def _get_manager(self):
|
||||
"""Lazily initialize and return the FetchManager."""
|
||||
if self._manager is None:
|
||||
try:
|
||||
from flacfetch.core.manager import FetchManager
|
||||
from flacfetch.providers.youtube import YouTubeProvider
|
||||
except ImportError as e:
|
||||
logger.error(f"flacfetch not installed: {e}")
|
||||
raise AudioSearchError(
|
||||
"flacfetch library is not installed. "
|
||||
"Install with: pip install flacfetch"
|
||||
) from e
|
||||
|
||||
self._manager = FetchManager()
|
||||
|
||||
# Add providers based on available API keys
|
||||
if self._redacted_api_key:
|
||||
try:
|
||||
from flacfetch.providers.redacted import RedactedProvider
|
||||
self._manager.add_provider(RedactedProvider(api_key=self._redacted_api_key))
|
||||
logger.debug("Added Redacted provider")
|
||||
except ImportError:
|
||||
logger.warning("Redacted provider not available")
|
||||
|
||||
if self._ops_api_key:
|
||||
try:
|
||||
from flacfetch.providers.ops import OPSProvider
|
||||
self._manager.add_provider(OPSProvider(api_key=self._ops_api_key))
|
||||
logger.debug("Added OPS provider")
|
||||
except ImportError:
|
||||
logger.warning("OPS provider not available")
|
||||
|
||||
# Always add YouTube as a fallback provider
|
||||
self._manager.add_provider(YouTubeProvider())
|
||||
logger.debug("Added YouTube provider")
|
||||
ops_api_key = os.environ.get("OPS_API_KEY")
|
||||
|
||||
return self._manager
|
||||
# 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(
|
||||
redacted_api_key=redacted_api_key,
|
||||
ops_api_key=ops_api_key,
|
||||
)
|
||||
|
||||
# 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
|
||||
@@ -156,49 +126,90 @@ class AudioSearchService:
|
||||
|
||||
Raises:
|
||||
NoResultsError: If no results are found
|
||||
AudioSearchError: For other errors
|
||||
AudioSearchError: For other errors (e.g., flacfetch not installed)
|
||||
"""
|
||||
try:
|
||||
from flacfetch.core.models import TrackQuery
|
||||
except ImportError as e:
|
||||
raise AudioSearchError("flacfetch not installed") from e
|
||||
|
||||
manager = self._get_manager()
|
||||
query = TrackQuery(artist=artist, title=title)
|
||||
|
||||
logger.info(f"Searching for audio: {artist} - {title}")
|
||||
|
||||
try:
|
||||
results = manager.search(query)
|
||||
# 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.
|
||||
|
||||
if not results:
|
||||
raise NoResultsError(f"No results found for: {artist} - {title}")
|
||||
|
||||
# Convert to our AudioSearchResult format and cache raw results
|
||||
search_results = []
|
||||
self._raw_results.clear()
|
||||
|
||||
for i, result in enumerate(results):
|
||||
search_result = AudioSearchResult(
|
||||
title=getattr(result, "title", title),
|
||||
artist=getattr(result, "artist", artist),
|
||||
provider=getattr(result, "provider", "Unknown"),
|
||||
url=getattr(result, "url", ""),
|
||||
duration=getattr(result, "duration", None),
|
||||
quality=getattr(result, "quality", None),
|
||||
source_id=getattr(result, "id", str(i)),
|
||||
index=i,
|
||||
)
|
||||
search_results.append(search_result)
|
||||
Runs async code in a sync context for compatibility with existing API.
|
||||
"""
|
||||
try:
|
||||
# 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()
|
||||
|
||||
# Cache raw result for later download
|
||||
self._raw_results[i] = result
|
||||
|
||||
logger.info(f"Found {len(search_results)} results for: {artist} - {title}")
|
||||
return search_results
|
||||
# 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"),
|
||||
provider=item.get("provider", "Unknown"),
|
||||
quality=item.get("quality", ""),
|
||||
size_bytes=item.get("size_bytes"),
|
||||
duration_seconds=item.get("duration_seconds"),
|
||||
is_lossless=item.get("is_lossless", False),
|
||||
seeders=item.get("seeders"),
|
||||
year=item.get("year"),
|
||||
extra_info={
|
||||
"index": item.get("index"),
|
||||
"target_file": item.get("target_file"),
|
||||
"view_count": item.get("view_count"),
|
||||
"channel": item.get("channel"),
|
||||
"remote": True, # Flag for download logic
|
||||
},
|
||||
)
|
||||
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:
|
||||
"""
|
||||
@@ -212,90 +223,136 @@ class AudioSearchService:
|
||||
Returns:
|
||||
Index of the best result
|
||||
"""
|
||||
if not results:
|
||||
return 0
|
||||
|
||||
manager = self._get_manager()
|
||||
|
||||
# Get raw results for the indices we have
|
||||
raw_results = [self._raw_results.get(r.index) for r in results if r.index in self._raw_results]
|
||||
|
||||
if raw_results:
|
||||
try:
|
||||
best = manager.select_best(raw_results)
|
||||
# Find index of best result
|
||||
for i, raw in enumerate(raw_results):
|
||||
if raw == best:
|
||||
return results[i].index
|
||||
except Exception as e:
|
||||
logger.warning(f"select_best failed, using first result: {e}")
|
||||
|
||||
# Fallback: return first result
|
||||
return results[0].index if results else 0
|
||||
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,
|
||||
) -> AudioDownloadResult:
|
||||
"""
|
||||
Download audio from a search result.
|
||||
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/")
|
||||
|
||||
Returns:
|
||||
AudioDownloadResult with the downloaded file path
|
||||
|
||||
Raises:
|
||||
DownloadError: If download fails
|
||||
DownloadError: If download fails or no cached result for index
|
||||
"""
|
||||
if result_index not in self._raw_results:
|
||||
raise DownloadError(f"No cached result for index {result_index}. Run search() first.")
|
||||
if result_index < 0 or result_index >= len(self._cached_results):
|
||||
raise DownloadError(
|
||||
f"No cached result for index {result_index}. "
|
||||
f"Available indices: 0-{len(self._cached_results) - 1}. "
|
||||
"Run search() first."
|
||||
)
|
||||
|
||||
raw_result = self._raw_results[result_index]
|
||||
manager = self._get_manager()
|
||||
result = self._cached_results[result_index]
|
||||
|
||||
# Ensure output directory exists
|
||||
os.makedirs(output_dir, exist_ok=True)
|
||||
logger.info(f"Downloading: {result.artist} - {result.title} from {result.provider}")
|
||||
|
||||
# Get metadata from raw result
|
||||
artist = getattr(raw_result, "artist", "Unknown")
|
||||
title = getattr(raw_result, "title", "Unknown")
|
||||
provider = getattr(raw_result, "provider", "Unknown")
|
||||
# Check if this was a remote search (torrent sources need remote download)
|
||||
if self._remote_search_id and self._remote_client:
|
||||
# Check if this is a torrent source that needs remote handling
|
||||
is_remote = result.extra_info.get("remote", False) if result.extra_info else False
|
||||
is_torrent = result.provider in ["Redacted", "OPS"]
|
||||
|
||||
if is_remote or is_torrent:
|
||||
return self._download_remote(result_index, output_dir, output_filename, gcs_path)
|
||||
|
||||
# Generate filename if not provided
|
||||
if output_filename is None:
|
||||
output_filename = f"{artist} - {title}"
|
||||
# Delegate to shared FlacFetcher (local download)
|
||||
fetch_result = self._fetcher.download(result, output_dir, output_filename)
|
||||
|
||||
logger.info(f"Downloading: {artist} - {title} from {provider}")
|
||||
logger.info(f"Downloaded to: {fetch_result.filepath}")
|
||||
|
||||
return fetch_result
|
||||
|
||||
def _download_remote(
|
||||
self,
|
||||
result_index: int,
|
||||
output_dir: str,
|
||||
output_filename: Optional[str] = None,
|
||||
gcs_path: Optional[str] = None,
|
||||
) -> AudioDownloadResult:
|
||||
"""
|
||||
Download using the remote flacfetch service.
|
||||
|
||||
The remote service downloads via torrent and optionally uploads to GCS.
|
||||
"""
|
||||
if not self._remote_search_id:
|
||||
raise DownloadError("No remote search ID - run search() first")
|
||||
|
||||
result = self._cached_results[result_index]
|
||||
|
||||
try:
|
||||
filepath = manager.download(
|
||||
raw_result,
|
||||
output_path=output_dir,
|
||||
output_filename=output_filename,
|
||||
)
|
||||
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=self._remote_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()
|
||||
|
||||
if filepath is None:
|
||||
raise DownloadError(f"Download returned no file path for: {artist} - {title}")
|
||||
# Determine file path
|
||||
filepath = final_status.get("gcs_path") or final_status.get("output_path")
|
||||
|
||||
logger.info(f"Downloaded to: {filepath}")
|
||||
if not filepath:
|
||||
raise DownloadError("Remote download completed but no file path returned")
|
||||
|
||||
logger.info(f"Remote download complete: {filepath}")
|
||||
|
||||
return AudioDownloadResult(
|
||||
filepath=filepath,
|
||||
artist=artist,
|
||||
title=title,
|
||||
provider=provider,
|
||||
duration=getattr(raw_result, "duration", None),
|
||||
quality=getattr(raw_result, "quality", None),
|
||||
artist=result.artist,
|
||||
title=result.title,
|
||||
provider=result.provider,
|
||||
quality=result.quality,
|
||||
)
|
||||
|
||||
except FlacfetchServiceError as e:
|
||||
raise DownloadError(f"Remote download failed: {e}") from e
|
||||
except Exception as e:
|
||||
raise DownloadError(f"Failed to download {artist} - {title}: {e}") from e
|
||||
logger.error(f"Remote download error: {e}")
|
||||
raise DownloadError(f"Remote download failed: {e}") from e
|
||||
|
||||
def search_and_download_auto(
|
||||
self,
|
||||
@@ -303,6 +360,7 @@ class AudioSearchService:
|
||||
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.
|
||||
@@ -315,6 +373,7 @@ class AudioSearchService:
|
||||
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
|
||||
@@ -328,10 +387,64 @@ class AudioSearchService:
|
||||
|
||||
# Select best
|
||||
best_index = self.select_best(results)
|
||||
logger.info(f"Auto-selected result {best_index}: {results[best_index].artist} - {results[best_index].title} ({results[best_index].provider})")
|
||||
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)
|
||||
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,
|
||||
) -> 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)
|
||||
)
|
||||
|
||||
def is_remote_enabled(self) -> bool:
|
||||
"""Check if remote flacfetch service is configured."""
|
||||
return self._remote_client is not None
|
||||
|
||||
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
|
||||
@@ -344,5 +457,3 @@ def get_audio_search_service() -> AudioSearchService:
|
||||
if _audio_search_service is None:
|
||||
_audio_search_service = AudioSearchService()
|
||||
return _audio_search_service
|
||||
|
||||
|
||||
@@ -0,0 +1,412 @@
|
||||
"""
|
||||
Client for the remote flacfetch HTTP API service.
|
||||
|
||||
This client communicates with a dedicated flacfetch VM that handles:
|
||||
- BitTorrent downloads from private trackers (Redacted, 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 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}")
|
||||
|
||||
|
||||
# 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
|
||||
|
||||
@@ -55,6 +55,10 @@ class JobManager:
|
||||
youtube_description=job_create.youtube_description,
|
||||
webhook_url=job_create.webhook_url,
|
||||
user_email=job_create.user_email,
|
||||
# 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,
|
||||
)
|
||||
|
||||
@@ -99,7 +99,11 @@ class TestJobStatusAudioSearchStates:
|
||||
|
||||
|
||||
class TestAudioSearchResult:
|
||||
"""Test AudioSearchResult dataclass."""
|
||||
"""Test AudioSearchResult dataclass.
|
||||
|
||||
AudioSearchResult is now imported from karaoke_gen.audio_fetcher.
|
||||
These tests verify the backend can use it correctly.
|
||||
"""
|
||||
|
||||
def test_create_audio_search_result(self):
|
||||
"""Test creating an AudioSearchResult."""
|
||||
@@ -140,6 +144,8 @@ class TestAudioSearchResult:
|
||||
assert data['provider'] == "YouTube"
|
||||
assert data['url'] == "https://youtube.com/watch?v=abc123"
|
||||
assert data['index'] == 0
|
||||
# raw_result should NOT be in serialized dict
|
||||
assert 'raw_result' not in data
|
||||
|
||||
def test_from_dict(self):
|
||||
"""Test creating from dict."""
|
||||
@@ -160,6 +166,7 @@ class TestAudioSearchResult:
|
||||
assert result.artist == "ABBA"
|
||||
assert result.provider == "YouTube"
|
||||
assert result.index == 0
|
||||
assert result.raw_result is None # Not set from dict
|
||||
|
||||
|
||||
class TestAudioSearchServiceInit:
|
||||
@@ -171,10 +178,9 @@ class TestAudioSearchServiceInit:
|
||||
# Pass explicit None to override environment
|
||||
service = AudioSearchService(redacted_api_key=None, ops_api_key=None)
|
||||
|
||||
# When explicitly passed None, it should be None (not from env)
|
||||
assert service._redacted_api_key is None
|
||||
assert service._ops_api_key is None
|
||||
assert service._manager is None
|
||||
# Service should have a FlacFetcher internally
|
||||
assert service._fetcher is not None
|
||||
assert service._cached_results == []
|
||||
|
||||
def test_init_with_keys(self):
|
||||
"""Test initialization with API keys."""
|
||||
@@ -183,41 +189,40 @@ class TestAudioSearchServiceInit:
|
||||
ops_api_key="test_ops_key",
|
||||
)
|
||||
|
||||
assert service._redacted_api_key == "test_redacted_key"
|
||||
assert service._ops_api_key == "test_ops_key"
|
||||
# Keys are passed to FlacFetcher
|
||||
assert service._fetcher._redacted_api_key == "test_redacted_key"
|
||||
assert service._fetcher._ops_api_key == "test_ops_key"
|
||||
|
||||
def test_init_reads_from_environment(self):
|
||||
"""Test initialization reads keys from environment variables."""
|
||||
import os
|
||||
|
||||
# Just test that the service can be initialized
|
||||
service = AudioSearchService()
|
||||
|
||||
# The service should have API keys from env or None
|
||||
assert service._manager is None # Not yet initialized
|
||||
# The service should have a FlacFetcher
|
||||
assert service._fetcher is not None
|
||||
|
||||
|
||||
class TestAudioSearchServiceSearch:
|
||||
"""Test AudioSearchService.search() method."""
|
||||
|
||||
@patch('backend.services.audio_search_service.AudioSearchService._get_manager')
|
||||
def test_search_returns_results(self, mock_get_manager):
|
||||
def test_search_returns_results(self):
|
||||
"""Test search returns AudioSearchResult list."""
|
||||
# Mock the flacfetch result
|
||||
mock_result = Mock()
|
||||
mock_result.title = "Waterloo"
|
||||
mock_result.artist = "ABBA"
|
||||
mock_result.provider = "YouTube"
|
||||
mock_result.url = "https://youtube.com/watch?v=abc123"
|
||||
mock_result.duration = 180
|
||||
mock_result.quality = "FLAC"
|
||||
mock_result.id = "abc123"
|
||||
# Create mock result
|
||||
mock_result = AudioSearchResult(
|
||||
title="Waterloo",
|
||||
artist="ABBA",
|
||||
provider="YouTube",
|
||||
url="https://youtube.com/watch?v=abc123",
|
||||
duration=180,
|
||||
quality="FLAC",
|
||||
source_id="abc123",
|
||||
index=0,
|
||||
)
|
||||
|
||||
mock_manager = Mock()
|
||||
mock_manager.search.return_value = [mock_result]
|
||||
mock_get_manager.return_value = mock_manager
|
||||
service = AudioSearchService(redacted_api_key=None, ops_api_key=None)
|
||||
service._fetcher = Mock()
|
||||
service._fetcher.search.return_value = [mock_result]
|
||||
|
||||
service = AudioSearchService()
|
||||
results = service.search("ABBA", "Waterloo")
|
||||
|
||||
assert len(results) == 1
|
||||
@@ -226,40 +231,36 @@ class TestAudioSearchServiceSearch:
|
||||
assert results[0].provider == "YouTube"
|
||||
assert results[0].index == 0
|
||||
|
||||
@patch('backend.services.audio_search_service.AudioSearchService._get_manager')
|
||||
def test_search_no_results_raises_error(self, mock_get_manager):
|
||||
def test_search_no_results_raises_error(self):
|
||||
"""Test search raises NoResultsError when no results."""
|
||||
mock_manager = Mock()
|
||||
mock_manager.search.return_value = []
|
||||
mock_get_manager.return_value = mock_manager
|
||||
|
||||
service = AudioSearchService()
|
||||
service = AudioSearchService(redacted_api_key=None, ops_api_key=None)
|
||||
service._fetcher = Mock()
|
||||
service._fetcher.search.side_effect = NoResultsError("No results found")
|
||||
|
||||
with pytest.raises(NoResultsError) as exc_info:
|
||||
service.search("Unknown Artist", "Unknown Song")
|
||||
|
||||
assert "No results found" in str(exc_info.value)
|
||||
|
||||
@patch('backend.services.audio_search_service.AudioSearchService._get_manager')
|
||||
def test_search_multiple_results(self, mock_get_manager):
|
||||
def test_search_multiple_results(self):
|
||||
"""Test search returns multiple results with correct indices."""
|
||||
mock_results = []
|
||||
for i in range(3):
|
||||
mock_result = Mock()
|
||||
mock_result.title = f"Song {i}"
|
||||
mock_result.artist = "Artist"
|
||||
mock_result.provider = ["YouTube", "Redacted", "OPS"][i]
|
||||
mock_result.url = f"https://example.com/{i}"
|
||||
mock_result.duration = 180 + i * 10
|
||||
mock_result.quality = ["320kbps", "FLAC", "FLAC"][i]
|
||||
mock_result.id = str(i)
|
||||
mock_results.append(mock_result)
|
||||
mock_results.append(AudioSearchResult(
|
||||
title=f"Song {i}",
|
||||
artist="Artist",
|
||||
provider=["YouTube", "Redacted", "OPS"][i],
|
||||
url=f"https://example.com/{i}",
|
||||
duration=180 + i * 10,
|
||||
quality=["320kbps", "FLAC", "FLAC"][i],
|
||||
source_id=str(i),
|
||||
index=i,
|
||||
))
|
||||
|
||||
mock_manager = Mock()
|
||||
mock_manager.search.return_value = mock_results
|
||||
mock_get_manager.return_value = mock_manager
|
||||
service = AudioSearchService(redacted_api_key=None, ops_api_key=None)
|
||||
service._fetcher = Mock()
|
||||
service._fetcher.search.return_value = mock_results
|
||||
|
||||
service = AudioSearchService()
|
||||
results = service.search("Artist", "Song")
|
||||
|
||||
assert len(results) == 3
|
||||
@@ -271,34 +272,39 @@ class TestAudioSearchServiceSearch:
|
||||
class TestAudioSearchServiceSelectBest:
|
||||
"""Test AudioSearchService.select_best() method."""
|
||||
|
||||
@patch('backend.services.audio_search_service.AudioSearchService._get_manager')
|
||||
def test_select_best_uses_manager(self, mock_get_manager):
|
||||
"""Test select_best uses flacfetch's select_best."""
|
||||
# First need to do a search to populate cache
|
||||
mock_result = Mock()
|
||||
mock_result.title = "Waterloo"
|
||||
mock_result.artist = "ABBA"
|
||||
mock_result.provider = "YouTube"
|
||||
mock_result.url = "https://youtube.com/watch?v=abc123"
|
||||
mock_result.duration = 180
|
||||
mock_result.quality = "FLAC"
|
||||
mock_result.id = "abc123"
|
||||
def test_select_best_delegates_to_fetcher(self):
|
||||
"""Test select_best uses FlacFetcher's select_best."""
|
||||
mock_results = [
|
||||
AudioSearchResult(
|
||||
title="Waterloo",
|
||||
artist="ABBA",
|
||||
provider="YouTube",
|
||||
url="https://youtube.com/watch?v=abc123",
|
||||
index=0,
|
||||
),
|
||||
AudioSearchResult(
|
||||
title="Waterloo",
|
||||
artist="ABBA",
|
||||
provider="Redacted",
|
||||
url="https://example.com/456",
|
||||
index=1,
|
||||
),
|
||||
]
|
||||
|
||||
mock_manager = Mock()
|
||||
mock_manager.search.return_value = [mock_result]
|
||||
mock_manager.select_best.return_value = mock_result
|
||||
mock_get_manager.return_value = mock_manager
|
||||
service = AudioSearchService(redacted_api_key=None, ops_api_key=None)
|
||||
service._fetcher = Mock()
|
||||
service._fetcher.select_best.return_value = 1
|
||||
|
||||
service = AudioSearchService()
|
||||
results = service.search("ABBA", "Waterloo")
|
||||
best_index = service.select_best(mock_results)
|
||||
|
||||
best_index = service.select_best(results)
|
||||
|
||||
assert best_index == 0
|
||||
assert best_index == 1
|
||||
service._fetcher.select_best.assert_called_once_with(mock_results)
|
||||
|
||||
def test_select_best_empty_list_returns_zero(self):
|
||||
"""Test select_best returns 0 for empty list."""
|
||||
service = AudioSearchService()
|
||||
service = AudioSearchService(redacted_api_key=None, ops_api_key=None)
|
||||
service._fetcher = Mock()
|
||||
service._fetcher.select_best.return_value = 0
|
||||
|
||||
best_index = service.select_best([])
|
||||
|
||||
@@ -308,24 +314,18 @@ class TestAudioSearchServiceSelectBest:
|
||||
class TestAudioSearchServiceDownload:
|
||||
"""Test AudioSearchService.download() method."""
|
||||
|
||||
@patch('backend.services.audio_search_service.AudioSearchService._get_manager')
|
||||
def test_download_without_search_raises_error(self, mock_get_manager):
|
||||
def test_download_without_search_raises_error(self):
|
||||
"""Test download without prior search raises error."""
|
||||
mock_manager = Mock()
|
||||
mock_get_manager.return_value = mock_manager
|
||||
|
||||
service = AudioSearchService()
|
||||
service = AudioSearchService(redacted_api_key=None, ops_api_key=None)
|
||||
|
||||
with pytest.raises(DownloadError) as exc_info:
|
||||
service.download(0, "/tmp")
|
||||
|
||||
assert "No cached result" in str(exc_info.value)
|
||||
|
||||
@patch('backend.services.audio_search_service.AudioSearchService._get_manager')
|
||||
def test_download_after_search(self, mock_get_manager):
|
||||
def test_download_after_search(self):
|
||||
"""Test download after search works."""
|
||||
import tempfile
|
||||
import os
|
||||
|
||||
# Create a temp file to simulate downloaded file
|
||||
temp_dir = tempfile.mkdtemp()
|
||||
@@ -333,23 +333,32 @@ class TestAudioSearchServiceDownload:
|
||||
with open(temp_file, 'w') as f:
|
||||
f.write("test")
|
||||
|
||||
mock_result = Mock()
|
||||
mock_result.title = "Waterloo"
|
||||
mock_result.artist = "ABBA"
|
||||
mock_result.provider = "YouTube"
|
||||
mock_result.url = "https://youtube.com/watch?v=abc123"
|
||||
mock_result.duration = 180
|
||||
mock_result.quality = "FLAC"
|
||||
mock_result.id = "abc123"
|
||||
mock_result = AudioSearchResult(
|
||||
title="Waterloo",
|
||||
artist="ABBA",
|
||||
provider="YouTube",
|
||||
url="https://youtube.com/watch?v=abc123",
|
||||
duration=180,
|
||||
quality="FLAC",
|
||||
source_id="abc123",
|
||||
index=0,
|
||||
)
|
||||
|
||||
mock_manager = Mock()
|
||||
mock_manager.search.return_value = [mock_result]
|
||||
mock_manager.download.return_value = temp_file
|
||||
mock_get_manager.return_value = mock_manager
|
||||
mock_fetch_result = AudioDownloadResult(
|
||||
filepath=temp_file,
|
||||
artist="ABBA",
|
||||
title="Waterloo",
|
||||
provider="YouTube",
|
||||
duration=180,
|
||||
quality="FLAC",
|
||||
)
|
||||
|
||||
service = AudioSearchService(redacted_api_key=None, ops_api_key=None)
|
||||
service._fetcher = Mock()
|
||||
service._fetcher.search.return_value = [mock_result]
|
||||
service._fetcher.download.return_value = mock_fetch_result
|
||||
|
||||
service = AudioSearchService()
|
||||
service.search("ABBA", "Waterloo")
|
||||
|
||||
result = service.download(0, temp_dir)
|
||||
|
||||
assert result.filepath == temp_file
|
||||
@@ -360,6 +369,27 @@ class TestAudioSearchServiceDownload:
|
||||
# Cleanup
|
||||
os.remove(temp_file)
|
||||
os.rmdir(temp_dir)
|
||||
|
||||
def test_download_invalid_index_raises_error(self):
|
||||
"""Test download with invalid index raises error."""
|
||||
mock_result = AudioSearchResult(
|
||||
title="Waterloo",
|
||||
artist="ABBA",
|
||||
provider="YouTube",
|
||||
url="https://youtube.com/watch?v=abc123",
|
||||
index=0,
|
||||
)
|
||||
|
||||
service = AudioSearchService(redacted_api_key=None, ops_api_key=None)
|
||||
service._fetcher = Mock()
|
||||
service._fetcher.search.return_value = [mock_result]
|
||||
|
||||
service.search("ABBA", "Waterloo")
|
||||
|
||||
with pytest.raises(DownloadError) as exc_info:
|
||||
service.download(99, "/tmp")
|
||||
|
||||
assert "No cached result for index 99" in str(exc_info.value)
|
||||
|
||||
|
||||
class TestGetAudioSearchService:
|
||||
@@ -384,3 +414,86 @@ class TestGetAudioSearchService:
|
||||
assert service1 is service2
|
||||
|
||||
|
||||
class TestFlacfetchIntegration:
|
||||
"""
|
||||
Integration tests that verify flacfetch imports work correctly.
|
||||
|
||||
These tests ensure the backend code is compatible with the installed
|
||||
flacfetch version and would catch issues like renamed classes.
|
||||
|
||||
Note: Some tests are marked with pytest.importorskip for flacfetch
|
||||
since it may not be installed in all test environments (e.g., CI).
|
||||
"""
|
||||
|
||||
def test_flacfetch_imports_work(self):
|
||||
"""Test that all flacfetch imports in audio_search_service work.
|
||||
|
||||
This test would have caught the YouTubeProvider -> YoutubeProvider rename.
|
||||
"""
|
||||
flacfetch = pytest.importorskip("flacfetch")
|
||||
|
||||
# These imports match what karaoke_gen.audio_fetcher does
|
||||
from flacfetch.core.manager import FetchManager
|
||||
from flacfetch.providers.youtube import YoutubeProvider
|
||||
from flacfetch.core.models import TrackQuery
|
||||
|
||||
# Verify the classes exist and are callable
|
||||
assert FetchManager is not None
|
||||
assert YoutubeProvider is not None
|
||||
assert TrackQuery is not None
|
||||
|
||||
def test_karaoke_gen_audio_fetcher_imports_work(self):
|
||||
"""Test that karaoke_gen.audio_fetcher imports work.
|
||||
|
||||
Since backend now imports from karaoke_gen, this is the critical test.
|
||||
This should work even without flacfetch installed (lazy import).
|
||||
"""
|
||||
from karaoke_gen.audio_fetcher import (
|
||||
FlacFetcher,
|
||||
AudioSearchResult,
|
||||
AudioFetchResult,
|
||||
AudioFetcherError,
|
||||
NoResultsError,
|
||||
DownloadError,
|
||||
)
|
||||
|
||||
assert FlacFetcher is not None
|
||||
assert AudioSearchResult is not None
|
||||
assert AudioFetchResult is not None
|
||||
assert AudioFetcherError is not None
|
||||
assert NoResultsError is not None
|
||||
assert DownloadError is not None
|
||||
|
||||
def test_audio_search_service_can_initialize_fetcher(self):
|
||||
"""Test AudioSearchService can initialize its FlacFetcher.
|
||||
|
||||
This verifies the actual initialization code path works.
|
||||
"""
|
||||
pytest.importorskip("flacfetch")
|
||||
|
||||
service = AudioSearchService(
|
||||
redacted_api_key=None,
|
||||
ops_api_key=None,
|
||||
)
|
||||
|
||||
# Verify FlacFetcher was initialized
|
||||
assert service._fetcher is not None
|
||||
|
||||
# FlacFetcher can initialize its manager (tests actual flacfetch)
|
||||
manager = service._fetcher._get_manager()
|
||||
assert manager is not None
|
||||
|
||||
def test_shared_classes_are_same_as_karaoke_gen(self):
|
||||
"""Verify backend uses the same classes as karaoke_gen."""
|
||||
from karaoke_gen.audio_fetcher import (
|
||||
AudioSearchResult as KGAudioSearchResult,
|
||||
AudioFetchResult as KGAudioFetchResult,
|
||||
NoResultsError as KGNoResultsError,
|
||||
DownloadError as KGDownloadError,
|
||||
)
|
||||
|
||||
# These should be the exact same classes, not copies
|
||||
assert AudioSearchResult is KGAudioSearchResult
|
||||
assert AudioDownloadResult is KGAudioFetchResult
|
||||
assert NoResultsError is KGNoResultsError
|
||||
assert DownloadError is KGDownloadError
|
||||
@@ -963,6 +963,228 @@ class TestDurationValidation:
|
||||
assert inspect.iscoroutinefunction(_validate_audio_durations)
|
||||
|
||||
|
||||
class TestTwoPhaseWorkflowModels:
|
||||
"""Test Pydantic models for two-phase workflow (Batch 6)."""
|
||||
|
||||
def test_create_job_with_upload_urls_request_has_prep_only(self):
|
||||
"""Test that CreateJobWithUploadUrlsRequest has prep_only field."""
|
||||
from backend.api.routes.file_upload import CreateJobWithUploadUrlsRequest, FileUploadRequest
|
||||
|
||||
request = CreateJobWithUploadUrlsRequest(
|
||||
artist="Test Artist",
|
||||
title="Test Song",
|
||||
files=[
|
||||
FileUploadRequest(filename="test.flac", content_type="audio/flac", file_type="audio")
|
||||
],
|
||||
prep_only=True
|
||||
)
|
||||
|
||||
assert request.prep_only is True
|
||||
|
||||
def test_create_job_with_upload_urls_request_prep_only_default_false(self):
|
||||
"""Test that prep_only defaults to False."""
|
||||
from backend.api.routes.file_upload import CreateJobWithUploadUrlsRequest, FileUploadRequest
|
||||
|
||||
request = CreateJobWithUploadUrlsRequest(
|
||||
artist="Test Artist",
|
||||
title="Test Song",
|
||||
files=[
|
||||
FileUploadRequest(filename="test.flac", content_type="audio/flac", file_type="audio")
|
||||
]
|
||||
)
|
||||
|
||||
assert request.prep_only is False
|
||||
|
||||
def test_create_job_with_upload_urls_request_has_keep_brand_code(self):
|
||||
"""Test that CreateJobWithUploadUrlsRequest has keep_brand_code field."""
|
||||
from backend.api.routes.file_upload import CreateJobWithUploadUrlsRequest, FileUploadRequest
|
||||
|
||||
request = CreateJobWithUploadUrlsRequest(
|
||||
artist="Test Artist",
|
||||
title="Test Song",
|
||||
files=[
|
||||
FileUploadRequest(filename="test.flac", content_type="audio/flac", file_type="audio")
|
||||
],
|
||||
keep_brand_code="NOMAD-1234"
|
||||
)
|
||||
|
||||
assert request.keep_brand_code == "NOMAD-1234"
|
||||
|
||||
def test_create_job_with_upload_urls_request_keep_brand_code_default_none(self):
|
||||
"""Test that keep_brand_code defaults to None."""
|
||||
from backend.api.routes.file_upload import CreateJobWithUploadUrlsRequest, FileUploadRequest
|
||||
|
||||
request = CreateJobWithUploadUrlsRequest(
|
||||
artist="Test Artist",
|
||||
title="Test Song",
|
||||
files=[
|
||||
FileUploadRequest(filename="test.flac", content_type="audio/flac", file_type="audio")
|
||||
]
|
||||
)
|
||||
|
||||
assert request.keep_brand_code is None
|
||||
|
||||
|
||||
class TestFinaliseOnlyFileTypes:
|
||||
"""Test finalise-only file types (Batch 6)."""
|
||||
|
||||
def test_finalise_only_file_types_exists(self):
|
||||
"""Test that FINALISE_ONLY_FILE_TYPES is defined."""
|
||||
from backend.api.routes.file_upload import FINALISE_ONLY_FILE_TYPES
|
||||
|
||||
assert FINALISE_ONLY_FILE_TYPES is not None
|
||||
assert isinstance(FINALISE_ONLY_FILE_TYPES, dict)
|
||||
|
||||
def test_finalise_only_file_types_has_with_vocals(self):
|
||||
"""Test that with_vocals is a valid finalise-only file type."""
|
||||
from backend.api.routes.file_upload import FINALISE_ONLY_FILE_TYPES
|
||||
|
||||
assert 'with_vocals' in FINALISE_ONLY_FILE_TYPES
|
||||
assert '.mkv' in FINALISE_ONLY_FILE_TYPES['with_vocals']
|
||||
assert '.mov' in FINALISE_ONLY_FILE_TYPES['with_vocals']
|
||||
|
||||
def test_finalise_only_file_types_has_title_screen(self):
|
||||
"""Test that title_screen is a valid finalise-only file type."""
|
||||
from backend.api.routes.file_upload import FINALISE_ONLY_FILE_TYPES
|
||||
|
||||
assert 'title_screen' in FINALISE_ONLY_FILE_TYPES
|
||||
|
||||
def test_finalise_only_file_types_has_end_screen(self):
|
||||
"""Test that end_screen is a valid finalise-only file type."""
|
||||
from backend.api.routes.file_upload import FINALISE_ONLY_FILE_TYPES
|
||||
|
||||
assert 'end_screen' in FINALISE_ONLY_FILE_TYPES
|
||||
|
||||
def test_finalise_only_file_types_has_instrumentals(self):
|
||||
"""Test that instrumental types are valid finalise-only file types."""
|
||||
from backend.api.routes.file_upload import FINALISE_ONLY_FILE_TYPES
|
||||
|
||||
assert 'instrumental_clean' in FINALISE_ONLY_FILE_TYPES
|
||||
assert 'instrumental_backing' in FINALISE_ONLY_FILE_TYPES
|
||||
|
||||
def test_finalise_only_file_types_has_lrc(self):
|
||||
"""Test that lrc is a valid finalise-only file type."""
|
||||
from backend.api.routes.file_upload import FINALISE_ONLY_FILE_TYPES
|
||||
|
||||
assert 'lrc' in FINALISE_ONLY_FILE_TYPES
|
||||
assert '.lrc' in FINALISE_ONLY_FILE_TYPES['lrc']
|
||||
|
||||
|
||||
class TestFinaliseOnlyModels:
|
||||
"""Test Pydantic models for finalise-only flow (Batch 6)."""
|
||||
|
||||
def test_finalise_only_file_request_model(self):
|
||||
"""Test FinaliseOnlyFileRequest model."""
|
||||
from backend.api.routes.file_upload import FinaliseOnlyFileRequest
|
||||
|
||||
file_req = FinaliseOnlyFileRequest(
|
||||
filename="with_vocals.mkv",
|
||||
content_type="video/mkv",
|
||||
file_type="with_vocals"
|
||||
)
|
||||
|
||||
assert file_req.filename == "with_vocals.mkv"
|
||||
assert file_req.content_type == "video/mkv"
|
||||
assert file_req.file_type == "with_vocals"
|
||||
|
||||
def test_create_finalise_only_job_request_model(self):
|
||||
"""Test CreateFinaliseOnlyJobRequest model."""
|
||||
from backend.api.routes.file_upload import CreateFinaliseOnlyJobRequest, FinaliseOnlyFileRequest
|
||||
|
||||
request = CreateFinaliseOnlyJobRequest(
|
||||
artist="Test Artist",
|
||||
title="Test Song",
|
||||
files=[
|
||||
FinaliseOnlyFileRequest(filename="with_vocals.mkv", content_type="video/mkv", file_type="with_vocals"),
|
||||
FinaliseOnlyFileRequest(filename="title.mov", content_type="video/quicktime", file_type="title_screen"),
|
||||
FinaliseOnlyFileRequest(filename="end.mov", content_type="video/quicktime", file_type="end_screen"),
|
||||
FinaliseOnlyFileRequest(filename="instrumental.flac", content_type="audio/flac", file_type="instrumental_clean"),
|
||||
],
|
||||
enable_cdg=True,
|
||||
enable_txt=True,
|
||||
brand_prefix="NOMAD",
|
||||
keep_brand_code="NOMAD-1234"
|
||||
)
|
||||
|
||||
assert request.artist == "Test Artist"
|
||||
assert request.title == "Test Song"
|
||||
assert len(request.files) == 4
|
||||
assert request.keep_brand_code == "NOMAD-1234"
|
||||
|
||||
def test_create_finalise_only_job_request_optional_fields(self):
|
||||
"""Test CreateFinaliseOnlyJobRequest optional fields default correctly."""
|
||||
from backend.api.routes.file_upload import CreateFinaliseOnlyJobRequest, FinaliseOnlyFileRequest
|
||||
|
||||
request = CreateFinaliseOnlyJobRequest(
|
||||
artist="Artist",
|
||||
title="Title",
|
||||
files=[
|
||||
FinaliseOnlyFileRequest(filename="with_vocals.mkv", content_type="video/mkv", file_type="with_vocals"),
|
||||
]
|
||||
)
|
||||
|
||||
assert request.enable_cdg is True
|
||||
assert request.enable_txt is True
|
||||
assert request.brand_prefix is None
|
||||
assert request.keep_brand_code is None
|
||||
assert request.enable_youtube_upload is False
|
||||
assert request.dropbox_path is None
|
||||
assert request.gdrive_folder_id is None
|
||||
|
||||
|
||||
class TestFinaliseOnlyGCSPaths:
|
||||
"""Test GCS path generation for finalise-only files (Batch 6)."""
|
||||
|
||||
def test_with_vocals_gcs_path(self):
|
||||
"""Test GCS path generation for with_vocals file."""
|
||||
from backend.api.routes.file_upload import _get_gcs_path_for_finalise_file
|
||||
|
||||
path = _get_gcs_path_for_finalise_file("test123", "with_vocals", "video.mkv")
|
||||
assert path == "jobs/test123/videos/with_vocals.mkv"
|
||||
|
||||
def test_title_screen_gcs_path(self):
|
||||
"""Test GCS path generation for title_screen file."""
|
||||
from backend.api.routes.file_upload import _get_gcs_path_for_finalise_file
|
||||
|
||||
path = _get_gcs_path_for_finalise_file("test123", "title_screen", "title.mov")
|
||||
assert path == "jobs/test123/screens/title.mov"
|
||||
|
||||
def test_end_screen_gcs_path(self):
|
||||
"""Test GCS path generation for end_screen file."""
|
||||
from backend.api.routes.file_upload import _get_gcs_path_for_finalise_file
|
||||
|
||||
path = _get_gcs_path_for_finalise_file("test123", "end_screen", "end.mov")
|
||||
assert path == "jobs/test123/screens/end.mov"
|
||||
|
||||
def test_instrumental_clean_gcs_path(self):
|
||||
"""Test GCS path generation for instrumental_clean file."""
|
||||
from backend.api.routes.file_upload import _get_gcs_path_for_finalise_file
|
||||
|
||||
path = _get_gcs_path_for_finalise_file("test123", "instrumental_clean", "clean.flac")
|
||||
assert path == "jobs/test123/stems/instrumental_clean.flac"
|
||||
|
||||
def test_instrumental_backing_gcs_path(self):
|
||||
"""Test GCS path generation for instrumental_backing file."""
|
||||
from backend.api.routes.file_upload import _get_gcs_path_for_finalise_file
|
||||
|
||||
path = _get_gcs_path_for_finalise_file("test123", "instrumental_backing", "backing.flac")
|
||||
assert path == "jobs/test123/stems/instrumental_with_backing.flac"
|
||||
|
||||
def test_lrc_gcs_path(self):
|
||||
"""Test GCS path generation for lrc file."""
|
||||
from backend.api.routes.file_upload import _get_gcs_path_for_finalise_file
|
||||
|
||||
path = _get_gcs_path_for_finalise_file("test123", "lrc", "karaoke.lrc")
|
||||
assert path == "jobs/test123/lyrics/karaoke.lrc"
|
||||
|
||||
def test_title_jpg_gcs_path(self):
|
||||
"""Test GCS path generation for title_jpg file."""
|
||||
from backend.api.routes.file_upload import _get_gcs_path_for_finalise_file
|
||||
|
||||
path = _get_gcs_path_for_finalise_file("test123", "title_jpg", "title.jpg")
|
||||
assert path == "jobs/test123/screens/title.jpg"
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# Batch 4: YouTube URL Input Tests
|
||||
# ============================================================================
|
||||
|
||||
@@ -670,6 +670,249 @@ class TestExistingInstrumentalModelFields:
|
||||
assert job.existing_instrumental_gcs_path == "uploads/test123/audio/my_instrumental.flac"
|
||||
|
||||
|
||||
class TestTwoPhaseWorkflowFields:
|
||||
"""Test two-phase workflow fields in Job and JobCreate models (Batch 6)."""
|
||||
|
||||
def test_job_has_prep_only_field(self):
|
||||
"""Test that Job model has prep_only field."""
|
||||
job = Job(
|
||||
job_id="test123",
|
||||
status=JobStatus.PENDING,
|
||||
created_at=datetime.now(UTC),
|
||||
updated_at=datetime.now(UTC),
|
||||
prep_only=True
|
||||
)
|
||||
|
||||
assert hasattr(job, 'prep_only')
|
||||
assert job.prep_only is True
|
||||
|
||||
def test_job_prep_only_defaults_to_false(self):
|
||||
"""Test that prep_only defaults to False."""
|
||||
job = Job(
|
||||
job_id="test123",
|
||||
status=JobStatus.PENDING,
|
||||
created_at=datetime.now(UTC),
|
||||
updated_at=datetime.now(UTC)
|
||||
)
|
||||
|
||||
assert job.prep_only is False
|
||||
|
||||
def test_job_has_finalise_only_field(self):
|
||||
"""Test that Job model has finalise_only field."""
|
||||
job = Job(
|
||||
job_id="test123",
|
||||
status=JobStatus.PENDING,
|
||||
created_at=datetime.now(UTC),
|
||||
updated_at=datetime.now(UTC),
|
||||
finalise_only=True
|
||||
)
|
||||
|
||||
assert hasattr(job, 'finalise_only')
|
||||
assert job.finalise_only is True
|
||||
|
||||
def test_job_finalise_only_defaults_to_false(self):
|
||||
"""Test that finalise_only defaults to False."""
|
||||
job = Job(
|
||||
job_id="test123",
|
||||
status=JobStatus.PENDING,
|
||||
created_at=datetime.now(UTC),
|
||||
updated_at=datetime.now(UTC)
|
||||
)
|
||||
|
||||
assert job.finalise_only is False
|
||||
|
||||
def test_job_has_keep_brand_code_field(self):
|
||||
"""Test that Job model has keep_brand_code field."""
|
||||
job = Job(
|
||||
job_id="test123",
|
||||
status=JobStatus.PENDING,
|
||||
created_at=datetime.now(UTC),
|
||||
updated_at=datetime.now(UTC),
|
||||
keep_brand_code="NOMAD-1234"
|
||||
)
|
||||
|
||||
assert hasattr(job, 'keep_brand_code')
|
||||
assert job.keep_brand_code == "NOMAD-1234"
|
||||
|
||||
def test_job_keep_brand_code_defaults_to_none(self):
|
||||
"""Test that keep_brand_code defaults to None."""
|
||||
job = Job(
|
||||
job_id="test123",
|
||||
status=JobStatus.PENDING,
|
||||
created_at=datetime.now(UTC),
|
||||
updated_at=datetime.now(UTC)
|
||||
)
|
||||
|
||||
assert job.keep_brand_code is None
|
||||
|
||||
def test_job_create_has_two_phase_workflow_fields(self):
|
||||
"""Test that JobCreate model has two-phase workflow fields."""
|
||||
job_create = JobCreate(
|
||||
artist="Artist",
|
||||
title="Title",
|
||||
prep_only=True,
|
||||
finalise_only=False,
|
||||
keep_brand_code="BRAND-0001"
|
||||
)
|
||||
|
||||
assert job_create.prep_only is True
|
||||
assert job_create.finalise_only is False
|
||||
assert job_create.keep_brand_code == "BRAND-0001"
|
||||
|
||||
def test_two_phase_workflow_roundtrip_serialization(self):
|
||||
"""Test that two-phase workflow fields survive serialization/deserialization."""
|
||||
job = Job(
|
||||
job_id="test123",
|
||||
status=JobStatus.PENDING,
|
||||
created_at=datetime.now(UTC),
|
||||
updated_at=datetime.now(UTC),
|
||||
prep_only=True,
|
||||
finalise_only=False,
|
||||
keep_brand_code="NOMAD-5678"
|
||||
)
|
||||
|
||||
# Serialize to dict (simulates writing to Firestore)
|
||||
job_dict = job.model_dump()
|
||||
|
||||
# Convert to JSON and back (simulates Firestore storage)
|
||||
json_str = json.dumps(job_dict, default=str)
|
||||
restored_dict = json.loads(json_str)
|
||||
|
||||
# Deserialize back to Job (simulates reading from Firestore)
|
||||
restored_job = Job(**restored_dict)
|
||||
|
||||
assert restored_job.prep_only is True
|
||||
assert restored_job.finalise_only is False
|
||||
assert restored_job.keep_brand_code == "NOMAD-5678"
|
||||
|
||||
|
||||
class TestPrepCompleteStatus:
|
||||
"""Test PREP_COMPLETE status and state transitions (Batch 6)."""
|
||||
|
||||
def test_prep_complete_status_exists(self):
|
||||
"""Test that PREP_COMPLETE status exists in JobStatus enum."""
|
||||
assert hasattr(JobStatus, 'PREP_COMPLETE')
|
||||
assert JobStatus.PREP_COMPLETE.value == "prep_complete"
|
||||
|
||||
def test_job_can_have_prep_complete_status(self):
|
||||
"""Test that Job can be created with PREP_COMPLETE status."""
|
||||
job = Job(
|
||||
job_id="test123",
|
||||
status=JobStatus.PREP_COMPLETE,
|
||||
created_at=datetime.now(UTC),
|
||||
updated_at=datetime.now(UTC)
|
||||
)
|
||||
|
||||
assert job.status == JobStatus.PREP_COMPLETE
|
||||
|
||||
def test_state_transitions_review_complete_to_prep_complete(self):
|
||||
"""Test that REVIEW_COMPLETE can transition to PREP_COMPLETE."""
|
||||
from backend.models.job import STATE_TRANSITIONS
|
||||
|
||||
valid_transitions = STATE_TRANSITIONS.get(JobStatus.REVIEW_COMPLETE, [])
|
||||
assert JobStatus.PREP_COMPLETE in valid_transitions
|
||||
|
||||
def test_state_transitions_prep_complete_to_awaiting_instrumental(self):
|
||||
"""Test that PREP_COMPLETE can transition to AWAITING_INSTRUMENTAL_SELECTION."""
|
||||
from backend.models.job import STATE_TRANSITIONS
|
||||
|
||||
valid_transitions = STATE_TRANSITIONS.get(JobStatus.PREP_COMPLETE, [])
|
||||
assert JobStatus.AWAITING_INSTRUMENTAL_SELECTION in valid_transitions
|
||||
|
||||
def test_state_transitions_pending_to_awaiting_instrumental(self):
|
||||
"""Test that PENDING can transition to AWAITING_INSTRUMENTAL_SELECTION (for finalise-only)."""
|
||||
from backend.models.job import STATE_TRANSITIONS
|
||||
|
||||
valid_transitions = STATE_TRANSITIONS.get(JobStatus.PENDING, [])
|
||||
assert JobStatus.AWAITING_INSTRUMENTAL_SELECTION in valid_transitions
|
||||
|
||||
def test_critical_statuses_include_prep_complete(self):
|
||||
"""Test that PREP_COMPLETE is in the list of job statuses."""
|
||||
all_statuses = [status.value for status in JobStatus]
|
||||
assert "prep_complete" in all_statuses
|
||||
|
||||
|
||||
class TestJobWithFullTwoPhaseConfig:
|
||||
"""Integration tests for two-phase workflow job configuration."""
|
||||
|
||||
def test_prep_only_job_full_config(self):
|
||||
"""Test creating a prep-only job with full configuration."""
|
||||
job = Job(
|
||||
job_id="prep123",
|
||||
status=JobStatus.PENDING,
|
||||
created_at=datetime.now(UTC),
|
||||
updated_at=datetime.now(UTC),
|
||||
artist="Test Artist",
|
||||
title="Test Song",
|
||||
prep_only=True,
|
||||
enable_cdg=True,
|
||||
enable_txt=True,
|
||||
brand_prefix="NOMAD",
|
||||
)
|
||||
|
||||
assert job.prep_only is True
|
||||
assert job.finalise_only is False
|
||||
assert job.brand_prefix == "NOMAD"
|
||||
|
||||
def test_finalise_only_job_full_config(self):
|
||||
"""Test creating a finalise-only job with full configuration."""
|
||||
job = Job(
|
||||
job_id="final123",
|
||||
status=JobStatus.AWAITING_INSTRUMENTAL_SELECTION,
|
||||
created_at=datetime.now(UTC),
|
||||
updated_at=datetime.now(UTC),
|
||||
artist="Test Artist",
|
||||
title="Test Song",
|
||||
finalise_only=True,
|
||||
keep_brand_code="NOMAD-1234",
|
||||
enable_youtube_upload=True,
|
||||
dropbox_path="/Karaoke/Tracks",
|
||||
state_data={
|
||||
"audio_complete": True,
|
||||
"lyrics_complete": True,
|
||||
"finalise_only": True,
|
||||
}
|
||||
)
|
||||
|
||||
assert job.finalise_only is True
|
||||
assert job.keep_brand_code == "NOMAD-1234"
|
||||
assert job.state_data["finalise_only"] is True
|
||||
|
||||
def test_prep_complete_job_with_file_urls(self):
|
||||
"""Test a job that has reached PREP_COMPLETE status with all prep outputs."""
|
||||
job = Job(
|
||||
job_id="prepcomp123",
|
||||
status=JobStatus.PREP_COMPLETE,
|
||||
created_at=datetime.now(UTC),
|
||||
updated_at=datetime.now(UTC),
|
||||
artist="ABBA",
|
||||
title="Waterloo",
|
||||
prep_only=True,
|
||||
file_urls={
|
||||
"stems": {
|
||||
"instrumental_clean": "gs://bucket/jobs/prepcomp123/stems/instrumental_clean.flac",
|
||||
"instrumental_with_backing": "gs://bucket/jobs/prepcomp123/stems/instrumental_with_backing.flac",
|
||||
},
|
||||
"videos": {
|
||||
"with_vocals": "gs://bucket/jobs/prepcomp123/videos/with_vocals.mkv",
|
||||
},
|
||||
"screens": {
|
||||
"title": "gs://bucket/jobs/prepcomp123/screens/title.mov",
|
||||
"end": "gs://bucket/jobs/prepcomp123/screens/end.mov",
|
||||
},
|
||||
"lyrics": {
|
||||
"lrc": "gs://bucket/jobs/prepcomp123/lyrics/karaoke.lrc",
|
||||
"ass": "gs://bucket/jobs/prepcomp123/lyrics/karaoke.ass",
|
||||
},
|
||||
}
|
||||
)
|
||||
|
||||
assert job.status == JobStatus.PREP_COMPLETE
|
||||
assert job.prep_only is True
|
||||
assert "with_vocals" in job.file_urls["videos"]
|
||||
assert "title" in job.file_urls["screens"]
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
pytest.main([__file__, "-v"])
|
||||
|
||||
@@ -447,11 +447,24 @@ async def upload_lyrics_results(
|
||||
corrections_data = json.load(f)
|
||||
|
||||
# Store metadata in state_data
|
||||
job_manager.update_state_data(job_id, 'lyrics_metadata', {
|
||||
# Include countdown padding info for instrumental synchronization
|
||||
lyrics_metadata = {
|
||||
'segment_count': len(corrections_data.get('corrected_segments', [])),
|
||||
'has_corrections': True,
|
||||
'ready_for_review': True
|
||||
})
|
||||
'ready_for_review': True,
|
||||
}
|
||||
|
||||
# Add countdown padding info from transcription result
|
||||
# This is needed by video_worker to pad instrumentals for sync
|
||||
if transcription_result.get("countdown_padding_added"):
|
||||
lyrics_metadata['has_countdown_padding'] = True
|
||||
lyrics_metadata['countdown_padding_seconds'] = transcription_result.get("countdown_padding_seconds", 3.0)
|
||||
logger.info(f"Job {job_id}: Countdown padding detected: {lyrics_metadata['countdown_padding_seconds']}s")
|
||||
else:
|
||||
lyrics_metadata['has_countdown_padding'] = False
|
||||
lyrics_metadata['countdown_padding_seconds'] = 0.0
|
||||
|
||||
job_manager.update_state_data(job_id, 'lyrics_metadata', lyrics_metadata)
|
||||
except Exception as e:
|
||||
logger.warning(f"Job {job_id}: Could not parse corrections JSON: {e}")
|
||||
else:
|
||||
|
||||
@@ -270,16 +270,27 @@ async def process_render_video(job_id: str) -> bool:
|
||||
job_log.info("Analyzing backing vocals for instrumental selection...")
|
||||
await _analyze_backing_vocals(job_id, job_manager, storage, job_log)
|
||||
|
||||
# 12. Transition to awaiting instrumental selection
|
||||
job_manager.transition_to_state(
|
||||
job_id=job_id,
|
||||
new_status=JobStatus.AWAITING_INSTRUMENTAL_SELECTION,
|
||||
progress=80,
|
||||
message="Video rendered - select your instrumental"
|
||||
)
|
||||
|
||||
job_log.info("=== RENDER VIDEO WORKER COMPLETE ===")
|
||||
logger.info(f"Job {job_id}: Video render complete, awaiting instrumental selection")
|
||||
# 12. Transition based on prep_only flag
|
||||
if getattr(job, 'prep_only', False):
|
||||
# Prep-only mode: stop here and mark as prep complete
|
||||
job_manager.transition_to_state(
|
||||
job_id=job_id,
|
||||
new_status=JobStatus.PREP_COMPLETE,
|
||||
progress=100,
|
||||
message="Prep phase complete - download outputs to continue locally"
|
||||
)
|
||||
job_log.info("=== RENDER VIDEO WORKER COMPLETE (PREP ONLY) ===")
|
||||
logger.info(f"Job {job_id}: Prep-only video render complete")
|
||||
else:
|
||||
# Normal mode: proceed to instrumental selection
|
||||
job_manager.transition_to_state(
|
||||
job_id=job_id,
|
||||
new_status=JobStatus.AWAITING_INSTRUMENTAL_SELECTION,
|
||||
progress=80,
|
||||
message="Video rendered - select your instrumental"
|
||||
)
|
||||
job_log.info("=== RENDER VIDEO WORKER COMPLETE ===")
|
||||
logger.info(f"Job {job_id}: Video render complete, awaiting instrumental selection")
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
|
||||
@@ -162,6 +162,14 @@ async def generate_video(job_id: str) -> bool:
|
||||
message="Encoding videos (15-20 min)"
|
||||
)
|
||||
|
||||
# Get countdown padding info from lyrics metadata
|
||||
# This ensures instrumental is padded to match vocals if countdown was added
|
||||
lyrics_metadata = job.state_data.get('lyrics_metadata', {})
|
||||
countdown_padding_seconds = None
|
||||
if lyrics_metadata.get('has_countdown_padding'):
|
||||
countdown_padding_seconds = lyrics_metadata.get('countdown_padding_seconds', 3.0)
|
||||
job_log.info(f"Countdown padding detected: {countdown_padding_seconds}s - instrumental will be padded if needed")
|
||||
|
||||
# Log finalization parameters
|
||||
job_log.info("Creating KaraokeFinalise with parameters:")
|
||||
job_log.info(f" enable_cdg: {getattr(job, 'enable_cdg', False)}")
|
||||
@@ -169,6 +177,7 @@ async def generate_video(job_id: str) -> bool:
|
||||
job_log.info(f" brand_prefix: {getattr(job, 'brand_prefix', None)}")
|
||||
job_log.info(f" discord_webhook: {'configured' if getattr(job, 'discord_webhook_url', None) else 'not configured'}")
|
||||
job_log.info(f" instrumental source: {instrumental_source}")
|
||||
job_log.info(f" countdown_padding_seconds: {countdown_padding_seconds}")
|
||||
if existing_instrumental_path:
|
||||
job_log.info(f" using user-provided instrumental (selection was: {instrumental_selection})")
|
||||
|
||||
@@ -209,6 +218,8 @@ async def generate_video(job_id: str) -> bool:
|
||||
non_interactive=True,
|
||||
server_side_mode=True,
|
||||
selected_instrumental_file=instrumental_file,
|
||||
# Audio synchronization - ensure instrumental matches vocal padding
|
||||
countdown_padding_seconds=countdown_padding_seconds,
|
||||
)
|
||||
|
||||
# Call process() - this does ALL the work:
|
||||
@@ -324,6 +335,13 @@ async def _handle_native_distribution(
|
||||
brand_code = result.get('brand_code')
|
||||
base_name = f"{job.artist} - {job.title}"
|
||||
|
||||
# Check if we should preserve existing brand code (Batch 6: --keep-brand-code)
|
||||
keep_brand_code = getattr(job, 'keep_brand_code', None)
|
||||
if keep_brand_code:
|
||||
brand_code = keep_brand_code
|
||||
result['brand_code'] = brand_code
|
||||
job_log.info(f"Using preserved brand code: {brand_code}")
|
||||
|
||||
# Upload to Dropbox using native SDK
|
||||
dropbox_path = getattr(job, 'dropbox_path', None)
|
||||
brand_prefix = getattr(job, 'brand_prefix', None)
|
||||
|
||||
@@ -1,22 +1,23 @@
|
||||
# Cloud Build configuration for base image
|
||||
#
|
||||
# This builds the base image with all Python dependencies pre-installed.
|
||||
# Run this manually when poetry.lock changes:
|
||||
# Run this manually when poetry.lock OR Dockerfile.base changes:
|
||||
# gcloud builds submit --config=cloudbuild-base.yaml --project=nomadkaraoke
|
||||
#
|
||||
# The base image is used by the main Dockerfile for fast app builds.
|
||||
# The poetry.lock hash is stored as a label for change detection.
|
||||
# A combined hash of poetry.lock + Dockerfile.base is stored as a label for change detection.
|
||||
|
||||
steps:
|
||||
# Calculate poetry.lock hash for change detection
|
||||
# Calculate combined hash for change detection (poetry.lock + Dockerfile.base)
|
||||
- name: 'gcr.io/cloud-builders/docker'
|
||||
entrypoint: 'bash'
|
||||
args:
|
||||
- '-c'
|
||||
- |
|
||||
POETRY_LOCK_HASH=$$(sha256sum poetry.lock | cut -d' ' -f1)
|
||||
echo "Poetry.lock hash: $$POETRY_LOCK_HASH"
|
||||
echo "$$POETRY_LOCK_HASH" > /workspace/POETRY_LOCK_HASH
|
||||
# Hash both files to detect changes in either
|
||||
CONTENT_HASH=$$(cat poetry.lock backend/Dockerfile.base | sha256sum | cut -d' ' -f1)
|
||||
echo "Combined content hash (poetry.lock + Dockerfile.base): $$CONTENT_HASH"
|
||||
echo "$$CONTENT_HASH" > /workspace/CONTENT_HASH
|
||||
|
||||
# Build base image with all dependencies
|
||||
- name: 'gcr.io/cloud-builders/docker'
|
||||
@@ -24,11 +25,11 @@ steps:
|
||||
args:
|
||||
- '-c'
|
||||
- |
|
||||
POETRY_LOCK_HASH=$$(cat /workspace/POETRY_LOCK_HASH)
|
||||
CONTENT_HASH=$$(cat /workspace/CONTENT_HASH)
|
||||
docker build \
|
||||
--build-arg BUILD_DATE=$BUILD_ID \
|
||||
--build-arg BUILD_ID=$BUILD_ID \
|
||||
--build-arg POETRY_LOCK_HASH=$$POETRY_LOCK_HASH \
|
||||
--build-arg BASE_CONTENT_HASH=$$CONTENT_HASH \
|
||||
-t us-central1-docker.pkg.dev/$PROJECT_ID/karaoke-repo/karaoke-backend-base:latest \
|
||||
-t us-central1-docker.pkg.dev/$PROJECT_ID/karaoke-repo/karaoke-backend-base:$BUILD_ID \
|
||||
-f backend/Dockerfile.base \
|
||||
|
||||
@@ -76,7 +76,7 @@ steps:
|
||||
--max-instances 50 \
|
||||
--min-instances 0 \
|
||||
--set-env-vars "GOOGLE_CLOUD_PROJECT=$PROJECT_ID,GCS_BUCKET_NAME=karaoke-gen-storage-$PROJECT_ID,FIRESTORE_COLLECTION=jobs,ENVIRONMENT=production,AUDIO_SEPARATOR_API_URL=https://nomadkaraoke--audio-separator-api.modal.run,KARAOKE_GEN_VERSION=$$VERSION,DEFAULT_DROPBOX_PATH=/MediaUnsynced/Karaoke/Tracks-Organized,DEFAULT_GDRIVE_FOLDER_ID=1laRKAyxo0v817SstfM5XkpbWiNKNAMSX,ENABLE_CLOUD_TASKS=true,CLOUD_RUN_SERVICE_URL=https://api.nomadkaraoke.com,GCP_REGION=us-central1" \
|
||||
--set-secrets "AUDIOSHAKE_API_TOKEN=audioshake-api-key:latest,GENIUS_API_TOKEN=genius-api-key:latest,SPOTIFY_COOKIE_SP_DC=spotify-cookie:latest,RAPIDAPI_KEY=rapidapi-key:latest,DEFAULT_DISCORD_WEBHOOK_URL=discord-releases-webhook:latest,ADMIN_TOKENS=admin-tokens:latest"
|
||||
--set-secrets "AUDIOSHAKE_API_TOKEN=audioshake-api-key:latest,GENIUS_API_TOKEN=genius-api-key:latest,SPOTIFY_COOKIE_SP_DC=spotify-cookie:latest,RAPIDAPI_KEY=rapidapi-key:latest,DEFAULT_DISCORD_WEBHOOK_URL=discord-releases-webhook:latest,ADMIN_TOKENS=admin-tokens:latest,REDACTED_API_KEY=redacted-api-key:latest,OPS_API_KEY=ops-api-key:latest,FLACFETCH_API_URL=flacfetch-api-url:latest,FLACFETCH_API_KEY=flacfetch-api-key:latest"
|
||||
|
||||
images:
|
||||
- 'us-central1-docker.pkg.dev/$PROJECT_ID/karaoke-repo/karaoke-backend:latest'
|
||||
|
||||
@@ -0,0 +1,35 @@
|
||||
# Codecov Configuration
|
||||
# Docs: https://docs.codecov.com/docs/codecovyml-reference
|
||||
|
||||
coverage:
|
||||
# Coverage value precision (2 decimal places)
|
||||
precision: 2
|
||||
round: down
|
||||
# Green range starts at 70% (our target)
|
||||
range: "70...100"
|
||||
|
||||
status:
|
||||
# Project-level coverage status check
|
||||
project:
|
||||
default:
|
||||
target: 70% # Pass if coverage >= 70%
|
||||
threshold: 2% # Allow 2% drop without failing
|
||||
if_ci_failed: error
|
||||
|
||||
# Patch coverage (new/changed lines only)
|
||||
patch:
|
||||
default:
|
||||
target: 70% # New code should also meet 70%
|
||||
threshold: 5% # More lenient for patches
|
||||
|
||||
# Disable PR comments entirely since we're satisfied with 70%+ coverage
|
||||
# Status checks will still appear on the PR
|
||||
comment: false
|
||||
|
||||
# Alternative: Uncomment below to only comment when coverage changes
|
||||
# comment:
|
||||
# layout: "diff, flags, files"
|
||||
# behavior: default
|
||||
# require_changes: true # Only comment if coverage actually changes
|
||||
# require_base: true # Require base report to exist
|
||||
|
||||
@@ -421,19 +421,27 @@ Bump the patch version in `pyproject.toml` before committing.
|
||||
|
||||
---
|
||||
|
||||
### Batch 6: Two-Phase Workflow (HIGH)
|
||||
### Batch 6: Two-Phase Workflow (HIGH) ✅ COMPLETE
|
||||
**Parameters:** W1 `--prep-only`, W2 `--finalise-only`, F15 `--keep-brand-code`
|
||||
|
||||
**Scope:**
|
||||
- **prep-only:** Remote CLI submits with `prep_only=true`. Backend runs through review, then stops. CLI downloads all outputs and exits.
|
||||
- **finalise-only:** Remote CLI checks local folder for prep outputs, uploads ALL files, sends `finalise_only=true`. Backend runs finalisation only.
|
||||
- **keep-brand-code:** Remote CLI extracts brand code from local folder name, sends to backend to preserve.
|
||||
**Status:** ✅ Complete (2025-12-11)
|
||||
|
||||
**Files to modify:**
|
||||
- `karaoke_gen/utils/remote_cli.py` - prep-only flow, finalise-only upload flow, brand code extraction
|
||||
- `backend/api/routes/file_upload.py` - accept prep_only, finalise_only flags
|
||||
- `backend/api/routes/` - new endpoint for finalise-only upload (multiple files)
|
||||
- `backend/workers/orchestrator.py` or job state machine - conditional worker execution
|
||||
**Implementation Summary:**
|
||||
- **prep-only:** Added `prep_only` field to Job model. When set, backend transitions to new `PREP_COMPLETE` status after review and video rendering (with_vocals.mkv). CLI downloads all prep outputs.
|
||||
- **finalise-only:** Added new endpoint `/api/jobs/create-finalise-only` for uploading prep outputs. Remote CLI detects files in prep folder, uploads them via signed URLs, and monitors finalisation.
|
||||
- **keep-brand-code:** Remote CLI extracts brand code from folder name (e.g., "NOMAD-1234 - Artist - Title"), sends to backend. Video worker uses preserved brand code for distribution.
|
||||
|
||||
**Files modified:**
|
||||
- `backend/models/job.py` - Added `PREP_COMPLETE` status, `prep_only`, `finalise_only`, `keep_brand_code` fields, updated state transitions
|
||||
- `backend/api/routes/file_upload.py` - Added `prep_only`, `keep_brand_code` to job creation, new finalise-only endpoints
|
||||
- `backend/workers/render_video_worker.py` - Conditional transition to PREP_COMPLETE for prep-only jobs
|
||||
- `backend/workers/video_worker.py` - Use preserved brand code when set
|
||||
- `backend/services/job_manager.py` - Pass new fields through job creation
|
||||
- `karaoke_gen/utils/remote_cli.py` - Full implementation of prep-only, finalise-only, and keep-brand-code flows
|
||||
|
||||
**Tests added:**
|
||||
- `backend/tests/test_models.py` - Tests for new fields and PREP_COMPLETE status
|
||||
- `backend/tests/test_file_upload.py` - Tests for finalise-only models and endpoints
|
||||
|
||||
**Complexity:** High (significant workflow changes, new upload flow)
|
||||
|
||||
@@ -673,6 +681,8 @@ The karaoke-gen system supports multiple interfaces to the same core functionali
|
||||
| `dropbox-oauth-credentials` | ✅ | Dropbox API OAuth tokens |
|
||||
| `gdrive-service-account` | ✅ | Google Drive service account |
|
||||
| `discord-webhook-url` | ✅ | Default Discord webhook |
|
||||
| `redacted-api-key` | ⏳ | Redacted tracker API key (flacfetch audio search) |
|
||||
| `ops-api-key` | ⏳ | OPS/Orpheus tracker API key (flacfetch audio search) |
|
||||
|
||||
### Default Distribution Settings
|
||||
|
||||
@@ -932,7 +942,7 @@ DEFAULT_DISCORD_WEBHOOK_URL=https://discord.com/...
|
||||
|
||||
### Medium-Term: Workflow Features
|
||||
|
||||
1. **Two-Phase Workflow** (Batch 6)
|
||||
1. **Two-Phase Workflow** (Batch 6) ✅ COMPLETE
|
||||
- `--prep-only` and `--finalise-only` modes
|
||||
|
||||
3. **Style Override** (Batch 7)
|
||||
|
||||
@@ -0,0 +1,141 @@
|
||||
# Refactor: Unify Audio Fetcher Code
|
||||
|
||||
**Created:** 2025-12-20
|
||||
**Completed:** 2025-12-20
|
||||
**Priority:** MEDIUM (prevents future bugs like YouTubeProvider -> YoutubeProvider)
|
||||
**Status:** ✅ Completed
|
||||
|
||||
## Problem
|
||||
|
||||
The codebase has **two separate implementations** of flacfetch integration:
|
||||
1. `karaoke_gen/audio_fetcher.py` - Used by local CLI
|
||||
2. `backend/services/audio_search_service.py` - Used by cloud backend
|
||||
|
||||
This violates DRY and caused a bug where the backend's import wasn't updated when flacfetch renamed `YouTubeProvider` to `YoutubeProvider`.
|
||||
|
||||
## Current State
|
||||
|
||||
### Duplicated Code
|
||||
|
||||
| Component | Local (`audio_fetcher.py`) | Backend (`audio_search_service.py`) |
|
||||
|-----------|---------------------------|-------------------------------------|
|
||||
| `_get_manager()` | ✅ 40 lines | ❌ 35 lines (copy) |
|
||||
| Provider setup | ✅ Redacted, OPS, YouTube | ❌ Same, diverged |
|
||||
| `search()` | ✅ Full implementation | ❌ Similar, diverged |
|
||||
| `download()` | ✅ With downloaders | ⚠️ Different, simpler |
|
||||
| `AudioSearchResult` | ✅ Dataclass | ❌ Duplicate, different fields |
|
||||
| `AudioDownloadResult` | ✅ (`AudioFetchResult`) | ❌ Duplicate |
|
||||
| Exceptions | ✅ 4 types | ❌ 3 types, different names |
|
||||
|
||||
### Drift Examples
|
||||
- Backend missing `raw_result` field on `AudioSearchResult`
|
||||
- Backend has `index` field, local doesn't
|
||||
- Backend exceptions inherit from `AudioSearchError`, local from `AudioFetcherError`
|
||||
- Backend missing `UserCancelledError`
|
||||
- Backend missing downloader registration (TorrentDownloader, YoutubeDownloader)
|
||||
|
||||
## Proposed Solution
|
||||
|
||||
### Option 1: Backend imports from karaoke_gen (Recommended)
|
||||
|
||||
The backend already depends on `karaoke_gen` (installed via `pip install -e .` in Dockerfile).
|
||||
|
||||
```python
|
||||
# backend/services/audio_search_service.py - REFACTORED
|
||||
|
||||
from karaoke_gen.audio_fetcher import (
|
||||
FlacFetcher,
|
||||
AudioSearchResult,
|
||||
AudioFetchResult,
|
||||
AudioFetcherError,
|
||||
NoResultsError,
|
||||
DownloadError,
|
||||
)
|
||||
|
||||
class AudioSearchService:
|
||||
"""
|
||||
Thin wrapper around karaoke_gen.audio_fetcher.FlacFetcher.
|
||||
|
||||
Adds backend-specific functionality:
|
||||
- Firestore serialization (to_dict/from_dict)
|
||||
- GCS integration for downloads
|
||||
- Job state management
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
redacted_api_key: Optional[str] = None,
|
||||
ops_api_key: Optional[str] = None,
|
||||
):
|
||||
self._fetcher = FlacFetcher(
|
||||
redacted_api_key=redacted_api_key,
|
||||
ops_api_key=ops_api_key,
|
||||
)
|
||||
|
||||
def search(self, artist: str, title: str) -> List[AudioSearchResult]:
|
||||
"""Delegate to FlacFetcher.search()."""
|
||||
return self._fetcher.search(artist, title)
|
||||
|
||||
def select_best(self, results: List[AudioSearchResult]) -> int:
|
||||
"""Delegate to FlacFetcher.select_best()."""
|
||||
return self._fetcher.select_best(results)
|
||||
|
||||
def download(
|
||||
self,
|
||||
result: AudioSearchResult,
|
||||
output_dir: str,
|
||||
output_filename: Optional[str] = None,
|
||||
) -> AudioFetchResult:
|
||||
"""Delegate to FlacFetcher.download()."""
|
||||
return self._fetcher.download(result, output_dir, output_filename)
|
||||
```
|
||||
|
||||
### Changes Required to karaoke_gen.audio_fetcher
|
||||
|
||||
1. **Add `to_dict()` method to `AudioSearchResult`** - For Firestore serialization
|
||||
2. **Add `from_dict()` classmethod** - For deserialization
|
||||
3. **Ensure `select_best()` is a standalone method** - Currently buried in interactive flow
|
||||
4. **Export all public classes from `__init__.py`**
|
||||
|
||||
### Changes Required to backend
|
||||
|
||||
1. **Remove duplicate dataclasses** - Use imports from karaoke_gen
|
||||
2. **Remove duplicate `_get_manager()`** - Delegate to FlacFetcher
|
||||
3. **Remove duplicate exception classes** - Use karaoke_gen exceptions
|
||||
4. **Update tests** - Point to real classes, not mocks
|
||||
|
||||
## Benefits
|
||||
|
||||
1. **Single source of truth** - Bug fixes apply everywhere
|
||||
2. **No more drift** - Dataclasses, exceptions stay in sync
|
||||
3. **Better test coverage** - karaoke_gen has integration tests for flacfetch imports
|
||||
4. **Less code to maintain** - Backend becomes thin wrapper
|
||||
|
||||
## Migration Steps
|
||||
|
||||
1. [x] Add `to_dict()` / `from_dict()` to `AudioSearchResult` in karaoke_gen
|
||||
2. [x] Extract `select_best()` as standalone method in FlacFetcher
|
||||
3. [x] Update karaoke_gen `__init__.py` exports (with lazy imports)
|
||||
4. [x] Refactor backend to import from karaoke_gen
|
||||
5. [x] Update backend tests
|
||||
6. [x] Delete duplicate code from backend (~150 lines removed)
|
||||
7. [x] Add integration test that catches import divergence
|
||||
|
||||
## Related Files
|
||||
|
||||
- `karaoke_gen/audio_fetcher.py` - Source of truth (keep)
|
||||
- `backend/services/audio_search_service.py` - Refactor to thin wrapper
|
||||
- `backend/api/routes/audio_search.py` - Update imports
|
||||
- `backend/tests/test_audio_search.py` - Update tests
|
||||
|
||||
## Estimated Effort
|
||||
|
||||
- **Time:** 2-4 hours
|
||||
- **Risk:** Low (well-defined changes, good test coverage)
|
||||
- **Dependencies:** None
|
||||
|
||||
## Related Architecture Docs
|
||||
|
||||
- `docs/01-reference/ARCHITECTURE.md` - "LyricsTranscriber Integration" section shows similar pattern
|
||||
- `docs/00-current-plan/SCALABLE-ARCHITECTURE-PLAN.md` - "Shared pipeline architecture" goal
|
||||
|
||||
@@ -0,0 +1,729 @@
|
||||
# Flacfetch HTTP API Service Implementation Plan
|
||||
|
||||
**Created:** 2025-12-20
|
||||
**Updated:** 2025-12-20
|
||||
**Status:** In Progress
|
||||
**Priority:** Medium
|
||||
**Estimated Effort:** 3-4 days
|
||||
|
||||
## Problem Statement
|
||||
|
||||
BitTorrent downloads don't work reliably in Cloud Run due to:
|
||||
- No inbound peer connections (NAT/firewall)
|
||||
- Ephemeral containers with no stable IP
|
||||
- DHT peer discovery blocked
|
||||
- Container timeout limits (max 60 min)
|
||||
|
||||
This prevents downloading lossless audio from private trackers (Redacted, OPS) via the remote backend.
|
||||
|
||||
## Solution Overview
|
||||
|
||||
Add an HTTP API mode to **flacfetch** (our audio fetching library) and deploy it on a dedicated GCP VM with:
|
||||
- Full BitTorrent peer connectivity via Transmission daemon
|
||||
- Static IP for tracker whitelist (seedbox-like)
|
||||
- Indefinite seeding of downloaded torrents
|
||||
- Automatic disk cleanup when space runs low
|
||||
- YouTube downloads also handled (single service for all audio acquisition)
|
||||
|
||||
This approach provides clean separation of concerns:
|
||||
- **flacfetch**: Handles ALL audio acquisition (torrents + YouTube)
|
||||
- **karaoke-gen backend**: Orchestrates karaoke generation pipeline, calls flacfetch API
|
||||
|
||||
```
|
||||
┌─────────────────────────────────────────────────────────────────────────────┐
|
||||
│ FLACFETCH SERVICE ARCHITECTURE │
|
||||
├─────────────────────────────────────────────────────────────────────────────┤
|
||||
│ │
|
||||
│ Cloud Run Backend Flacfetch VM (e2-small) │
|
||||
│ ┌────────────────────┐ ┌─────────────────────────┐ │
|
||||
│ │ │ │ │ │
|
||||
│ │ karaoke-gen │ 1. Search │ flacfetch HTTP API │ │
|
||||
│ │ AudioSearchService │ ────────────▶ │ POST /search │ │
|
||||
│ │ │ │ │ │
|
||||
│ │ │ 2. Results │ Providers: │ │
|
||||
│ │ │ ◀──────────── │ • Redacted (FLAC) │ │
|
||||
│ │ │ │ • OPS (FLAC) │ │
|
||||
│ │ │ 3. Download │ • YouTube (fallback) │ │
|
||||
│ │ │ ────────────▶ │ │ │
|
||||
│ │ │ │ POST /download │ │
|
||||
│ │ │ 4. Status │ GET /download/{id} │ │
|
||||
│ │ │ ◀──────────── │ │ │
|
||||
│ │ │ (polling) │ Transmission Daemon │ │
|
||||
│ │ │ │ • Full peer connect │ │
|
||||
│ │ │ 5. Complete │ • DHT enabled │ │
|
||||
│ │ │ ◀──────────── │ • Indefinite seeding │ │
|
||||
│ │ │ (file path) │ │ │
|
||||
│ └────────────────────┘ └───────────┬─────────────┘ │
|
||||
│ │ │ │
|
||||
│ │ │ 6. Upload to GCS │
|
||||
│ │ │ │
|
||||
│ ▼ ▼ │
|
||||
│ ┌─────────────────────────────────────────────────────────────────┐ │
|
||||
│ │ Google Cloud Storage │ │
|
||||
│ │ │ │
|
||||
│ │ uploads/{job_id}/audio/{filename}.flac │ │
|
||||
│ │ │ │
|
||||
│ └─────────────────────────────────────────────────────────────────┘ │
|
||||
│ │
|
||||
└─────────────────────────────────────────────────────────────────────────────┘
|
||||
```
|
||||
|
||||
## Key Design Decisions
|
||||
|
||||
### 1. HTTP API in flacfetch (not separate service)
|
||||
- **Why**: Clean separation of concerns, reusable by future projects, single source of truth
|
||||
- **How**: Add `flacfetch/api/` module with FastAPI, new CLI mode `flacfetch serve`
|
||||
|
||||
### 2. Indefinite Seeding
|
||||
- **Why**: VM is always-on anyway, helps maintain tracker ratio, acts like a seedbox
|
||||
- **Current behavior**: Torrent removed after download (line 317-321 in torrent.py)
|
||||
- **New behavior**: Torrent kept seeding, only removed by cleanup or explicit delete
|
||||
|
||||
### 3. Static IP
|
||||
- **Why**: Required for tracker account IP whitelist, consistent for firewall rules
|
||||
- **Cost**: ~$3/month additional
|
||||
|
||||
### 4. Disk Space Management
|
||||
- **Strategy**: Auto-cleanup oldest torrents when free space < 5GB threshold
|
||||
- **API**: Manual cleanup endpoints + automatic background cleanup
|
||||
|
||||
### 5. Instance Type: e2-small
|
||||
- **Specs**: 0.5 vCPU, 2GB RAM, ~$12/month
|
||||
- **Why**: Sufficient for I/O-bound workload, newer C3/N4 require 2+ vCPUs (overkill)
|
||||
- **Disk**: 30GB SSD (20GB for torrents + headroom)
|
||||
|
||||
### 6. Authentication
|
||||
- **Method**: Static API key in `X-API-Key` header
|
||||
- **Firewall**: Permissive (allows future web UI), auth enforced at app level
|
||||
|
||||
## Implementation Phases
|
||||
|
||||
### Phase 1: Add HTTP API to flacfetch
|
||||
|
||||
**Location:** `./flacfetch/flacfetch/api/`
|
||||
|
||||
**New Directory Structure:**
|
||||
```
|
||||
flacfetch/
|
||||
├── flacfetch/
|
||||
│ ├── api/ # NEW
|
||||
│ │ ├── __init__.py
|
||||
│ │ ├── main.py # FastAPI app entry point
|
||||
│ │ ├── auth.py # API key authentication
|
||||
│ │ ├── models.py # Pydantic request/response models
|
||||
│ │ ├── routes/
|
||||
│ │ │ ├── __init__.py
|
||||
│ │ │ ├── search.py # POST /search
|
||||
│ │ │ ├── download.py # POST /download, GET /download/{id}/status
|
||||
│ │ │ ├── torrents.py # GET /torrents, DELETE /torrents/{id}
|
||||
│ │ │ └── health.py # GET /health, GET /disk-usage
|
||||
│ │ └── services/
|
||||
│ │ ├── __init__.py
|
||||
│ │ ├── download_manager.py # Track active downloads
|
||||
│ │ └── disk_manager.py # Disk cleanup logic
|
||||
│ ├── core/
|
||||
│ ├── downloaders/
|
||||
│ │ └── torrent.py # MODIFIED: optional keep-seeding mode
|
||||
│ ├── interface/
|
||||
│ │ └── cli.py # MODIFIED: add 'serve' subcommand
|
||||
│ └── providers/
|
||||
└── pyproject.toml # MODIFIED: add fastapi, uvicorn deps
|
||||
```
|
||||
|
||||
**API Endpoints:**
|
||||
|
||||
```yaml
|
||||
# All endpoints require X-API-Key header
|
||||
|
||||
# Search for audio
|
||||
POST /search
|
||||
Request:
|
||||
{ "artist": "ABBA", "title": "Waterloo" }
|
||||
Response:
|
||||
{
|
||||
"search_id": "abc123",
|
||||
"results": [
|
||||
{
|
||||
"index": 0,
|
||||
"title": "Waterloo",
|
||||
"artist": "ABBA",
|
||||
"provider": "Redacted",
|
||||
"quality": "FLAC 16bit CD",
|
||||
"seeders": 45,
|
||||
"size_bytes": 31457280,
|
||||
"target_file": "02. Waterloo.flac",
|
||||
...
|
||||
},
|
||||
...
|
||||
]
|
||||
}
|
||||
|
||||
# Start download
|
||||
POST /download
|
||||
Request:
|
||||
{
|
||||
"search_id": "abc123", # From previous search
|
||||
"result_index": 0, # Which result to download
|
||||
"output_filename": "ABBA - Waterloo", # Optional
|
||||
"upload_to_gcs": true, # Upload to GCS when complete
|
||||
"gcs_path": "uploads/job123/audio/" # Required if upload_to_gcs
|
||||
}
|
||||
Response:
|
||||
{
|
||||
"download_id": "dl_xyz789",
|
||||
"status": "queued"
|
||||
}
|
||||
|
||||
# Check download status
|
||||
GET /download/{download_id}/status
|
||||
Response:
|
||||
{
|
||||
"download_id": "dl_xyz789",
|
||||
"status": "downloading", # queued, downloading, uploading, seeding, complete, failed
|
||||
"progress": 45.2,
|
||||
"peers": 3,
|
||||
"download_speed_kbps": 1250.5,
|
||||
"eta_seconds": 120,
|
||||
"provider": "Redacted",
|
||||
"title": "ABBA - Waterloo",
|
||||
"output_path": null, # Set when complete (local path)
|
||||
"gcs_path": null, # Set when uploaded to GCS
|
||||
"error": null
|
||||
}
|
||||
|
||||
# List all torrents (for management)
|
||||
GET /torrents
|
||||
Response:
|
||||
{
|
||||
"torrents": [
|
||||
{
|
||||
"id": 1,
|
||||
"name": "ABBA - Waterloo [FLAC]",
|
||||
"status": "seeding",
|
||||
"progress": 100.0,
|
||||
"size_bytes": 314572800,
|
||||
"uploaded_bytes": 628145600, # Seeding stats
|
||||
"ratio": 2.0,
|
||||
"added_at": "2025-12-20T10:30:00Z"
|
||||
},
|
||||
...
|
||||
],
|
||||
"total_size_bytes": 5368709120,
|
||||
"count": 15
|
||||
}
|
||||
|
||||
# Delete a torrent (manual cleanup)
|
||||
DELETE /torrents/{torrent_id}
|
||||
Query params: ?delete_data=true # Also delete downloaded files
|
||||
Response:
|
||||
{ "status": "deleted" }
|
||||
|
||||
# Trigger cleanup (free disk space)
|
||||
POST /torrents/cleanup
|
||||
Request:
|
||||
{
|
||||
"strategy": "oldest", # oldest, largest, lowest_ratio
|
||||
"target_free_gb": 10 # Keep removing until this much free
|
||||
}
|
||||
Response:
|
||||
{
|
||||
"removed_count": 3,
|
||||
"freed_bytes": 1073741824,
|
||||
"free_space_gb": 10.5
|
||||
}
|
||||
|
||||
# Health check
|
||||
GET /health
|
||||
Response:
|
||||
{
|
||||
"status": "healthy",
|
||||
"transmission": {
|
||||
"available": true,
|
||||
"version": "4.0.5",
|
||||
"active_torrents": 5
|
||||
},
|
||||
"disk": {
|
||||
"total_gb": 30,
|
||||
"used_gb": 18,
|
||||
"free_gb": 12
|
||||
},
|
||||
"providers": {
|
||||
"redacted": true,
|
||||
"ops": true,
|
||||
"youtube": true
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**Torrent Downloader Changes:**
|
||||
|
||||
```python
|
||||
# flacfetch/downloaders/torrent.py
|
||||
|
||||
class TorrentDownloader(Downloader):
|
||||
def __init__(self, ..., keep_seeding: bool = False):
|
||||
"""
|
||||
Args:
|
||||
keep_seeding: If True, don't remove torrent after download.
|
||||
Used in server mode for indefinite seeding.
|
||||
"""
|
||||
self.keep_seeding = keep_seeding
|
||||
|
||||
def download(self, release, output_path, output_filename=None):
|
||||
# ... existing download logic ...
|
||||
|
||||
# After download complete:
|
||||
if self.keep_seeding:
|
||||
# Don't remove, just return the file path
|
||||
logger.info(f"Download complete, keeping torrent for seeding: {torrent.name}")
|
||||
else:
|
||||
# Original behavior: stop and remove
|
||||
self.client.stop_torrent(torrent.id)
|
||||
self.client.remove_torrent(torrent.id, delete_data=True)
|
||||
```
|
||||
|
||||
**CLI Changes:**
|
||||
|
||||
```bash
|
||||
# New serve subcommand
|
||||
flacfetch serve --port 8080 --host 0.0.0.0
|
||||
|
||||
# Or via environment
|
||||
FLACFETCH_API_PORT=8080 flacfetch serve
|
||||
```
|
||||
|
||||
### Phase 2: Infrastructure (Pulumi)
|
||||
|
||||
**Location:** `./infrastructure/__main__.py`
|
||||
|
||||
**New Resources:**
|
||||
```python
|
||||
# Static IP for flacfetch service (for tracker whitelist)
|
||||
flacfetch_ip = gcp.compute.Address(
|
||||
"flacfetch-ip",
|
||||
name="flacfetch-static-ip",
|
||||
region="us-central1",
|
||||
)
|
||||
|
||||
# Service account for flacfetch VM
|
||||
flacfetch_sa = gcp.serviceaccount.Account(
|
||||
"flacfetch-sa",
|
||||
account_id="flacfetch-service",
|
||||
display_name="Flacfetch Service Account",
|
||||
)
|
||||
|
||||
# GCS write permissions for flacfetch
|
||||
gcp.storage.BucketIAMMember(
|
||||
"flacfetch-gcs-writer",
|
||||
bucket=bucket.name,
|
||||
role="roles/storage.objectCreator",
|
||||
member=pulumi.Output.concat("serviceAccount:", flacfetch_sa.email),
|
||||
)
|
||||
|
||||
# Flacfetch VM
|
||||
flacfetch_vm = gcp.compute.Instance(
|
||||
"flacfetch-service",
|
||||
machine_type="e2-small",
|
||||
zone="us-central1-a",
|
||||
boot_disk=gcp.compute.InstanceBootDiskArgs(
|
||||
initialize_params=gcp.compute.InstanceBootDiskInitializeParamsArgs(
|
||||
image="debian-cloud/debian-12",
|
||||
size=30, # GB
|
||||
type="pd-ssd",
|
||||
),
|
||||
),
|
||||
network_interfaces=[gcp.compute.InstanceNetworkInterfaceArgs(
|
||||
network="default",
|
||||
access_configs=[gcp.compute.InstanceNetworkInterfaceAccessConfigArgs(
|
||||
nat_ip=flacfetch_ip.address, # Static IP
|
||||
)],
|
||||
)],
|
||||
service_account=gcp.compute.InstanceServiceAccountArgs(
|
||||
email=flacfetch_sa.email,
|
||||
scopes=["cloud-platform"],
|
||||
),
|
||||
metadata_startup_script=FLACFETCH_STARTUP_SCRIPT,
|
||||
tags=["flacfetch-service"],
|
||||
)
|
||||
|
||||
# Firewall for flacfetch
|
||||
flacfetch_firewall = gcp.compute.Firewall(
|
||||
"flacfetch-firewall",
|
||||
network="default",
|
||||
allows=[
|
||||
# BitTorrent peer connections
|
||||
gcp.compute.FirewallAllowArgs(protocol="tcp", ports=["51413"]),
|
||||
gcp.compute.FirewallAllowArgs(protocol="udp", ports=["51413"]),
|
||||
# Flacfetch HTTP API (auth required at app level)
|
||||
gcp.compute.FirewallAllowArgs(protocol="tcp", ports=["8080"]),
|
||||
],
|
||||
source_ranges=["0.0.0.0/0"], # Permissive, auth at app level
|
||||
target_tags=["flacfetch-service"],
|
||||
)
|
||||
|
||||
# Store API key in Secret Manager
|
||||
flacfetch_api_key = gcp.secretmanager.Secret(
|
||||
"flacfetch-api-key",
|
||||
secret_id="flacfetch-api-key",
|
||||
replication=gcp.secretmanager.SecretReplicationArgs(
|
||||
auto=gcp.secretmanager.SecretReplicationAutoArgs(),
|
||||
),
|
||||
)
|
||||
|
||||
# Export for use
|
||||
pulumi.export("flacfetch_static_ip", flacfetch_ip.address)
|
||||
pulumi.export("flacfetch_service_url", pulumi.Output.concat("http://", flacfetch_ip.address, ":8080"))
|
||||
```
|
||||
|
||||
**Startup Script:**
|
||||
```bash
|
||||
#!/bin/bash
|
||||
set -e
|
||||
|
||||
# Install dependencies
|
||||
apt-get update
|
||||
apt-get install -y python3-pip python3-venv transmission-daemon ffmpeg git
|
||||
|
||||
# Configure Transmission
|
||||
systemctl stop transmission-daemon
|
||||
cat > /etc/transmission-daemon/settings.json << 'EOF'
|
||||
{
|
||||
"download-dir": "/var/lib/transmission-daemon/downloads",
|
||||
"incomplete-dir": "/var/lib/transmission-daemon/.incomplete",
|
||||
"incomplete-dir-enabled": true,
|
||||
"rpc-authentication-required": false,
|
||||
"rpc-bind-address": "127.0.0.1",
|
||||
"rpc-enabled": true,
|
||||
"rpc-port": 9091,
|
||||
"rpc-whitelist-enabled": false,
|
||||
"peer-port": 51413,
|
||||
"port-forwarding-enabled": false,
|
||||
"speed-limit-down": 0,
|
||||
"speed-limit-down-enabled": false,
|
||||
"speed-limit-up": 0,
|
||||
"speed-limit-up-enabled": false,
|
||||
"ratio-limit-enabled": false,
|
||||
"umask": 2
|
||||
}
|
||||
EOF
|
||||
systemctl start transmission-daemon
|
||||
|
||||
# Install flacfetch
|
||||
cd /opt
|
||||
git clone https://github.com/nomadkaraoke/flacfetch.git
|
||||
cd flacfetch
|
||||
python3 -m venv venv
|
||||
source venv/bin/activate
|
||||
pip install -e ".[api]"
|
||||
|
||||
# Get secrets from metadata/Secret Manager
|
||||
FLACFETCH_API_KEY=$(gcloud secrets versions access latest --secret=flacfetch-api-key)
|
||||
REDACTED_API_KEY=$(gcloud secrets versions access latest --secret=redacted-api-key)
|
||||
OPS_API_KEY=$(gcloud secrets versions access latest --secret=ops-api-key)
|
||||
GCS_BUCKET=$(curl -s "http://metadata.google.internal/computeMetadata/v1/instance/attributes/gcs-bucket" -H "Metadata-Flavor: Google")
|
||||
|
||||
# Create systemd service
|
||||
cat > /etc/systemd/system/flacfetch.service << EOF
|
||||
[Unit]
|
||||
Description=Flacfetch HTTP API Service
|
||||
After=network.target transmission-daemon.service
|
||||
|
||||
[Service]
|
||||
Type=simple
|
||||
User=root
|
||||
WorkingDirectory=/opt/flacfetch
|
||||
Environment="FLACFETCH_API_KEY=${FLACFETCH_API_KEY}"
|
||||
Environment="REDACTED_API_KEY=${REDACTED_API_KEY}"
|
||||
Environment="OPS_API_KEY=${OPS_API_KEY}"
|
||||
Environment="GCS_BUCKET=${GCS_BUCKET}"
|
||||
Environment="FLACFETCH_KEEP_SEEDING=true"
|
||||
Environment="FLACFETCH_MIN_FREE_GB=5"
|
||||
ExecStart=/opt/flacfetch/venv/bin/flacfetch serve --host 0.0.0.0 --port 8080
|
||||
Restart=always
|
||||
RestartSec=10
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
EOF
|
||||
|
||||
systemctl daemon-reload
|
||||
systemctl enable flacfetch
|
||||
systemctl start flacfetch
|
||||
```
|
||||
|
||||
### Phase 3: Backend Integration
|
||||
|
||||
**New File:** `backend/services/flacfetch_client.py`
|
||||
|
||||
```python
|
||||
"""
|
||||
Client for the remote flacfetch HTTP API service.
|
||||
|
||||
Used when FLACFETCH_API_URL is configured, otherwise falls back to local flacfetch.
|
||||
"""
|
||||
import asyncio
|
||||
import logging
|
||||
from typing import Optional, List, Dict, Any
|
||||
|
||||
import httpx
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class FlacfetchServiceError(Exception):
|
||||
"""Error communicating with flacfetch service."""
|
||||
pass
|
||||
|
||||
|
||||
class FlacfetchClient:
|
||||
"""Client for remote flacfetch HTTP API."""
|
||||
|
||||
def __init__(self, base_url: str, api_key: str, timeout: int = 30):
|
||||
self.base_url = base_url.rstrip('/')
|
||||
self.api_key = api_key
|
||||
self.timeout = timeout
|
||||
|
||||
def _headers(self) -> Dict[str, str]:
|
||||
return {"X-API-Key": self.api_key}
|
||||
|
||||
async def health_check(self) -> Dict[str, Any]:
|
||||
"""Check if service is healthy."""
|
||||
async with httpx.AsyncClient() as client:
|
||||
resp = await client.get(
|
||||
f"{self.base_url}/health",
|
||||
headers=self._headers(),
|
||||
timeout=10,
|
||||
)
|
||||
resp.raise_for_status()
|
||||
return resp.json()
|
||||
|
||||
async def search(self, artist: str, title: str) -> Dict[str, Any]:
|
||||
"""Search for audio."""
|
||||
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,
|
||||
)
|
||||
resp.raise_for_status()
|
||||
return resp.json()
|
||||
|
||||
async def download(
|
||||
self,
|
||||
search_id: str,
|
||||
result_index: int,
|
||||
output_filename: Optional[str] = None,
|
||||
gcs_path: Optional[str] = None,
|
||||
) -> str:
|
||||
"""
|
||||
Start download and return download_id.
|
||||
|
||||
If gcs_path is provided, file will be uploaded to GCS.
|
||||
"""
|
||||
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()
|
||||
return resp.json()["download_id"]
|
||||
|
||||
async def get_download_status(self, download_id: str) -> Dict[str, Any]:
|
||||
"""Get download status."""
|
||||
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()
|
||||
|
||||
async def wait_for_download(
|
||||
self,
|
||||
download_id: str,
|
||||
timeout: int = 600,
|
||||
poll_interval: int = 2,
|
||||
) -> Dict[str, Any]:
|
||||
"""
|
||||
Wait for download to complete.
|
||||
|
||||
Returns final status dict with output_path or gcs_path.
|
||||
Raises FlacfetchServiceError on failure or timeout.
|
||||
"""
|
||||
elapsed = 0
|
||||
while elapsed < timeout:
|
||||
status = await self.get_download_status(download_id)
|
||||
|
||||
if status["status"] == "complete":
|
||||
return status
|
||||
elif status["status"] == "failed":
|
||||
raise FlacfetchServiceError(f"Download failed: {status.get('error')}")
|
||||
|
||||
await asyncio.sleep(poll_interval)
|
||||
elapsed += poll_interval
|
||||
|
||||
raise FlacfetchServiceError(f"Download timed out after {timeout}s")
|
||||
|
||||
|
||||
# Singleton
|
||||
_client: Optional[FlacfetchClient] = None
|
||||
|
||||
|
||||
def get_flacfetch_client() -> Optional[FlacfetchClient]:
|
||||
"""Get flacfetch client if configured."""
|
||||
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,
|
||||
)
|
||||
return _client
|
||||
```
|
||||
|
||||
**Modify:** `backend/services/audio_search_service.py` to use remote client when available.
|
||||
|
||||
**Modify:** `backend/config.py` to add new settings:
|
||||
```python
|
||||
flacfetch_api_url: Optional[str] = None # e.g., http://10.0.0.5:8080
|
||||
flacfetch_api_key: Optional[str] = None
|
||||
```
|
||||
|
||||
### Phase 4: Monitoring & Reliability
|
||||
|
||||
**Tasks:**
|
||||
- [ ] Add Cloud Monitoring alert for VM CPU/memory
|
||||
- [ ] Add alert for disk space < 5GB
|
||||
- [ ] Add alert for flacfetch service down (health check fails)
|
||||
- [ ] Configure Cloud Logging export from VM
|
||||
- [ ] Add Grafana dashboard (optional)
|
||||
|
||||
**Automatic Disk Cleanup:**
|
||||
The disk manager runs as a background task in the flacfetch API service:
|
||||
```python
|
||||
# Check every 5 minutes, cleanup if free space < threshold
|
||||
async def background_cleanup_task():
|
||||
while True:
|
||||
await asyncio.sleep(300)
|
||||
free_gb = get_free_space_gb()
|
||||
if free_gb < MIN_FREE_GB:
|
||||
cleanup_oldest_torrents(target_free_gb=MIN_FREE_GB + 5)
|
||||
```
|
||||
|
||||
### Phase 5: Testing & Documentation
|
||||
|
||||
**Testing:**
|
||||
- [ ] Unit tests for flacfetch API endpoints
|
||||
- [ ] Unit tests for disk manager
|
||||
- [ ] Integration test: search → download → GCS upload
|
||||
- [ ] Mock tests for karaoke-gen backend client
|
||||
|
||||
**Documentation:**
|
||||
- [ ] Update `docs/01-reference/ARCHITECTURE.md` with flacfetch service
|
||||
- [ ] Add `flacfetch/README.md` HTTP API section
|
||||
- [ ] Document deployment process
|
||||
- [ ] Document environment variables
|
||||
|
||||
## Environment Variables
|
||||
|
||||
### Flacfetch Service (VM)
|
||||
```bash
|
||||
# API Configuration
|
||||
FLACFETCH_API_KEY=<secret> # Required for API auth
|
||||
FLACFETCH_API_PORT=8080 # Default: 8080
|
||||
FLACFETCH_API_HOST=0.0.0.0 # Default: 0.0.0.0
|
||||
|
||||
# Tracker API Keys
|
||||
REDACTED_API_KEY=<key> # For Redacted provider
|
||||
OPS_API_KEY=<key> # For OPS provider
|
||||
|
||||
# GCS Upload (optional)
|
||||
GCS_BUCKET=karaoke-uploads # For uploading completed downloads
|
||||
GOOGLE_CLOUD_PROJECT=nomadkaraoke
|
||||
|
||||
# Transmission
|
||||
TRANSMISSION_HOST=localhost # Default: localhost
|
||||
TRANSMISSION_PORT=9091 # Default: 9091
|
||||
|
||||
# Behavior
|
||||
FLACFETCH_KEEP_SEEDING=true # Keep torrents seeding after download
|
||||
FLACFETCH_MIN_FREE_GB=5 # Minimum free disk space before cleanup
|
||||
FLACFETCH_DOWNLOAD_DIR=/var/lib/transmission-daemon/downloads
|
||||
```
|
||||
|
||||
### Cloud Run Backend
|
||||
```bash
|
||||
# New variables
|
||||
FLACFETCH_API_URL=http://10.128.0.5:8080 # Internal IP of flacfetch VM
|
||||
FLACFETCH_API_KEY=<same-secret>
|
||||
```
|
||||
|
||||
## Security Considerations
|
||||
|
||||
1. **API Authentication**: Static API key in `X-API-Key` header
|
||||
2. **Firewall**: Permissive for future web UI, auth enforced at application level
|
||||
3. **GCS**: Service account with `storage.objectCreator` role only
|
||||
4. **Transmission**: RPC bound to localhost only, no external access
|
||||
5. **Static IP**: Can be whitelisted on tracker accounts
|
||||
|
||||
## Rollback Plan
|
||||
|
||||
If flacfetch service fails:
|
||||
1. Set `FLACFETCH_API_URL=""` in Cloud Run (disables remote service)
|
||||
2. Backend falls back to local flacfetch (YouTube only in Cloud Run)
|
||||
3. Users see warning that lossless downloads may be slower/unavailable
|
||||
|
||||
## Cost Estimate
|
||||
|
||||
| Resource | Monthly Cost |
|
||||
|----------|--------------|
|
||||
| e2-small VM | ~$12 |
|
||||
| Static IP | ~$3 |
|
||||
| 30GB SSD | ~$5 |
|
||||
| Network egress | ~$2-5 |
|
||||
| **Total** | **~$22-25/month** |
|
||||
|
||||
## Success Criteria
|
||||
|
||||
- [ ] Flacfetch HTTP API accepts search requests and returns results
|
||||
- [ ] Downloads complete successfully for Redacted/OPS sources
|
||||
- [ ] Downloaded files upload to GCS automatically
|
||||
- [ ] Torrents continue seeding after download
|
||||
- [ ] Disk cleanup triggers automatically when space is low
|
||||
- [ ] Remote CLI shows download progress from flacfetch service
|
||||
- [ ] Fallback to local flacfetch works when service unavailable
|
||||
- [ ] Static IP can be whitelisted on tracker accounts
|
||||
|
||||
## Timeline
|
||||
|
||||
| Phase | Duration | Dependencies |
|
||||
|-------|----------|--------------|
|
||||
| Phase 1: Flacfetch HTTP API | 1.5 days | None |
|
||||
| Phase 2: Infrastructure | 0.5 day | Phase 1 |
|
||||
| Phase 3: Backend Integration | 0.5 day | Phase 1, 2 |
|
||||
| Phase 4: Monitoring | 0.5 day | Phase 2 |
|
||||
| Phase 5: Testing & Docs | 0.5 day | Phase 1-3 |
|
||||
| **Total** | **3.5 days** | |
|
||||
|
||||
## References
|
||||
|
||||
- [Transmission RPC Spec](https://github.com/transmission/transmission/blob/main/docs/rpc-spec.md)
|
||||
- [transmission-rpc Python library](https://github.com/Trim21/transmission-rpc)
|
||||
- [FastAPI Documentation](https://fastapi.tiangolo.com/)
|
||||
- [flacfetch source code](./flacfetch/)
|
||||
@@ -94,6 +94,14 @@ echo -n "your-genius-key" | \
|
||||
# Add Audio Separator API URL
|
||||
echo -n "https://your-modal-url" | \
|
||||
gcloud secrets versions add audio-separator-api-url --data-file=-
|
||||
|
||||
# Add Redacted API key (for flacfetch audio search - private tracker)
|
||||
echo -n "your-redacted-api-key" | \
|
||||
gcloud secrets versions add redacted-api-key --data-file=-
|
||||
|
||||
# Add OPS API key (for flacfetch audio search - private tracker)
|
||||
echo -n "your-ops-api-key" | \
|
||||
gcloud secrets versions add ops-api-key --data-file=-
|
||||
```
|
||||
|
||||
Or use Pulumi config secrets:
|
||||
|
||||
@@ -428,6 +428,24 @@ audio_separator_secret = secretmanager.Secret(
|
||||
),
|
||||
)
|
||||
|
||||
# Redacted API Key Secret (for flacfetch audio search)
|
||||
redacted_api_key_secret = secretmanager.Secret(
|
||||
"redacted-api-key",
|
||||
secret_id="redacted-api-key",
|
||||
replication=secretmanager.SecretReplicationArgs(
|
||||
auto=secretmanager.SecretReplicationAutoArgs(),
|
||||
),
|
||||
)
|
||||
|
||||
# OPS API Key Secret (for flacfetch audio search)
|
||||
ops_api_key_secret = secretmanager.Secret(
|
||||
"ops-api-key",
|
||||
secret_id="ops-api-key",
|
||||
replication=secretmanager.SecretReplicationArgs(
|
||||
auto=secretmanager.SecretReplicationAutoArgs(),
|
||||
),
|
||||
)
|
||||
|
||||
# Create Cloud Run Domain Mapping
|
||||
# Maps api.nomadkaraoke.com to the karaoke-backend service
|
||||
domain_mapping = cloudrun.DomainMapping(
|
||||
@@ -479,3 +497,244 @@ domain_mapping.statuses.apply(
|
||||
})
|
||||
)
|
||||
|
||||
# ==================== Flacfetch Service (Torrent Downloads) ====================
|
||||
# A dedicated VM running flacfetch with Transmission daemon for BitTorrent downloads.
|
||||
# This is required because Cloud Run doesn't support inbound peer connections for torrents.
|
||||
# The VM has a static IP for tracker whitelist and runs indefinitely for seeding.
|
||||
|
||||
# Static IP for flacfetch (for tracker account whitelist)
|
||||
flacfetch_ip = gcp.compute.Address(
|
||||
"flacfetch-ip",
|
||||
name="flacfetch-static-ip",
|
||||
region="us-central1",
|
||||
address_type="EXTERNAL",
|
||||
description="Static IP for flacfetch service (torrent downloads)",
|
||||
)
|
||||
|
||||
# Service account for flacfetch VM
|
||||
flacfetch_sa = serviceaccount.Account(
|
||||
"flacfetch-sa",
|
||||
account_id="flacfetch-service",
|
||||
display_name="Flacfetch Service Account",
|
||||
description="Service account for flacfetch torrent/audio download VM",
|
||||
)
|
||||
|
||||
# Grant flacfetch service account GCS write permissions
|
||||
flacfetch_storage_iam = gcp.storage.BucketIAMMember(
|
||||
"flacfetch-storage-writer",
|
||||
bucket=bucket.name,
|
||||
role="roles/storage.objectCreator",
|
||||
member=flacfetch_sa.email.apply(lambda email: f"serviceAccount:{email}"),
|
||||
)
|
||||
|
||||
# Grant flacfetch service account GCS read permissions (for uploads folder)
|
||||
flacfetch_storage_reader_iam = gcp.storage.BucketIAMMember(
|
||||
"flacfetch-storage-reader",
|
||||
bucket=bucket.name,
|
||||
role="roles/storage.objectViewer",
|
||||
member=flacfetch_sa.email.apply(lambda email: f"serviceAccount:{email}"),
|
||||
)
|
||||
|
||||
# Grant flacfetch service account Secret Manager access
|
||||
flacfetch_secrets_iam = gcp.projects.IAMMember(
|
||||
"flacfetch-secrets-access",
|
||||
project=project_id,
|
||||
role="roles/secretmanager.secretAccessor",
|
||||
member=flacfetch_sa.email.apply(lambda email: f"serviceAccount:{email}"),
|
||||
)
|
||||
|
||||
# Flacfetch API key secret (for authenticating API requests)
|
||||
flacfetch_api_key_secret = secretmanager.Secret(
|
||||
"flacfetch-api-key",
|
||||
secret_id="flacfetch-api-key",
|
||||
replication=secretmanager.SecretReplicationArgs(
|
||||
auto=secretmanager.SecretReplicationAutoArgs(),
|
||||
),
|
||||
)
|
||||
|
||||
# Flacfetch API URL secret (the static IP address of the flacfetch VM)
|
||||
# This is stored as a secret to avoid committing infrastructure IPs to the repo
|
||||
flacfetch_api_url_secret = secretmanager.Secret(
|
||||
"flacfetch-api-url",
|
||||
secret_id="flacfetch-api-url",
|
||||
replication=secretmanager.SecretReplicationArgs(
|
||||
auto=secretmanager.SecretReplicationAutoArgs(),
|
||||
),
|
||||
)
|
||||
|
||||
# Startup script for the flacfetch VM
|
||||
# This installs and configures Transmission daemon and the flacfetch service
|
||||
FLACFETCH_STARTUP_SCRIPT = """#!/bin/bash
|
||||
set -e
|
||||
|
||||
# Log to a file for debugging
|
||||
exec > >(tee /var/log/flacfetch-startup.log) 2>&1
|
||||
echo "Starting flacfetch setup at $(date)"
|
||||
|
||||
# Install dependencies
|
||||
apt-get update
|
||||
apt-get install -y python3-pip python3-venv transmission-daemon ffmpeg git curl
|
||||
|
||||
# Configure Transmission
|
||||
echo "Configuring Transmission daemon..."
|
||||
systemctl stop transmission-daemon || true
|
||||
|
||||
# Create transmission directories
|
||||
mkdir -p /var/lib/transmission-daemon/downloads
|
||||
mkdir -p /var/lib/transmission-daemon/.config/transmission-daemon
|
||||
chown -R debian-transmission:debian-transmission /var/lib/transmission-daemon
|
||||
|
||||
# Configure transmission settings
|
||||
cat > /var/lib/transmission-daemon/.config/transmission-daemon/settings.json << 'SETTINGS'
|
||||
{
|
||||
"download-dir": "/var/lib/transmission-daemon/downloads",
|
||||
"incomplete-dir": "/var/lib/transmission-daemon/.incomplete",
|
||||
"incomplete-dir-enabled": true,
|
||||
"rpc-authentication-required": false,
|
||||
"rpc-bind-address": "127.0.0.1",
|
||||
"rpc-enabled": true,
|
||||
"rpc-port": 9091,
|
||||
"rpc-whitelist-enabled": false,
|
||||
"peer-port": 51413,
|
||||
"port-forwarding-enabled": false,
|
||||
"speed-limit-down": 0,
|
||||
"speed-limit-down-enabled": false,
|
||||
"speed-limit-up": 0,
|
||||
"speed-limit-up-enabled": false,
|
||||
"ratio-limit-enabled": false,
|
||||
"umask": 2,
|
||||
"encryption": 1
|
||||
}
|
||||
SETTINGS
|
||||
|
||||
chown debian-transmission:debian-transmission /var/lib/transmission-daemon/.config/transmission-daemon/settings.json
|
||||
systemctl start transmission-daemon
|
||||
echo "Transmission daemon started"
|
||||
|
||||
# Install flacfetch
|
||||
echo "Installing flacfetch..."
|
||||
cd /opt
|
||||
|
||||
# Clone flacfetch (we'll use the repo from GitHub)
|
||||
if [ ! -d "flacfetch" ]; then
|
||||
git clone https://github.com/nomadkaraoke/flacfetch.git
|
||||
fi
|
||||
cd flacfetch
|
||||
|
||||
# Create and activate virtual environment
|
||||
python3 -m venv venv
|
||||
source venv/bin/activate
|
||||
|
||||
# Install flacfetch with API dependencies
|
||||
pip install -e ".[api]"
|
||||
|
||||
# Get secrets from Secret Manager
|
||||
echo "Fetching secrets from Secret Manager..."
|
||||
FLACFETCH_API_KEY=$(gcloud secrets versions access latest --secret=flacfetch-api-key 2>/dev/null || echo "")
|
||||
REDACTED_API_KEY=$(gcloud secrets versions access latest --secret=redacted-api-key 2>/dev/null || echo "")
|
||||
OPS_API_KEY=$(gcloud secrets versions access latest --secret=ops-api-key 2>/dev/null || echo "")
|
||||
|
||||
# Get bucket name from project metadata
|
||||
GCS_BUCKET=$(gcloud compute project-info describe --format='value(commonInstanceMetadata.items.gcs-bucket)' 2>/dev/null || echo "")
|
||||
if [ -z "$GCS_BUCKET" ]; then
|
||||
# Fallback: construct from project ID
|
||||
PROJECT_ID=$(curl -s "http://metadata.google.internal/computeMetadata/v1/project/project-id" -H "Metadata-Flavor: Google")
|
||||
GCS_BUCKET="karaoke-gen-storage-${PROJECT_ID}"
|
||||
fi
|
||||
|
||||
echo "Using GCS bucket: $GCS_BUCKET"
|
||||
|
||||
# Create systemd service for flacfetch
|
||||
echo "Creating systemd service..."
|
||||
cat > /etc/systemd/system/flacfetch.service << SYSTEMD
|
||||
[Unit]
|
||||
Description=Flacfetch HTTP API Service
|
||||
After=network.target transmission-daemon.service
|
||||
Requires=transmission-daemon.service
|
||||
|
||||
[Service]
|
||||
Type=simple
|
||||
User=root
|
||||
WorkingDirectory=/opt/flacfetch
|
||||
Environment="FLACFETCH_API_KEY=${FLACFETCH_API_KEY}"
|
||||
Environment="REDACTED_API_KEY=${REDACTED_API_KEY}"
|
||||
Environment="OPS_API_KEY=${OPS_API_KEY}"
|
||||
Environment="GCS_BUCKET=${GCS_BUCKET}"
|
||||
Environment="FLACFETCH_KEEP_SEEDING=true"
|
||||
Environment="FLACFETCH_MIN_FREE_GB=5"
|
||||
Environment="FLACFETCH_DOWNLOAD_DIR=/var/lib/transmission-daemon/downloads"
|
||||
Environment="TRANSMISSION_HOST=localhost"
|
||||
Environment="TRANSMISSION_PORT=9091"
|
||||
ExecStart=/opt/flacfetch/venv/bin/flacfetch serve --host 0.0.0.0 --port 8080
|
||||
Restart=always
|
||||
RestartSec=10
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
SYSTEMD
|
||||
|
||||
systemctl daemon-reload
|
||||
systemctl enable flacfetch
|
||||
systemctl start flacfetch
|
||||
|
||||
echo "Flacfetch service started at $(date)"
|
||||
echo "Setup complete!"
|
||||
"""
|
||||
|
||||
# Flacfetch VM instance
|
||||
flacfetch_vm = gcp.compute.Instance(
|
||||
"flacfetch-service",
|
||||
name="flacfetch-service",
|
||||
machine_type="e2-small", # 0.5 vCPU, 2GB RAM - sufficient for I/O-bound workload
|
||||
zone="us-central1-a",
|
||||
boot_disk=gcp.compute.InstanceBootDiskArgs(
|
||||
initialize_params=gcp.compute.InstanceBootDiskInitializeParamsArgs(
|
||||
image="debian-cloud/debian-12",
|
||||
size=30, # GB - for torrent storage + headroom
|
||||
type="pd-ssd", # SSD for faster I/O
|
||||
),
|
||||
),
|
||||
network_interfaces=[gcp.compute.InstanceNetworkInterfaceArgs(
|
||||
network="default",
|
||||
access_configs=[gcp.compute.InstanceNetworkInterfaceAccessConfigArgs(
|
||||
nat_ip=flacfetch_ip.address, # Static IP
|
||||
)],
|
||||
)],
|
||||
service_account=gcp.compute.InstanceServiceAccountArgs(
|
||||
email=flacfetch_sa.email,
|
||||
scopes=["cloud-platform"],
|
||||
),
|
||||
metadata_startup_script=FLACFETCH_STARTUP_SCRIPT,
|
||||
metadata={
|
||||
"gcs-bucket": bucket.name, # Pass bucket name to startup script
|
||||
},
|
||||
tags=["flacfetch-service"],
|
||||
allow_stopping_for_update=True,
|
||||
)
|
||||
|
||||
# Firewall rule for flacfetch
|
||||
# - Port 51413 TCP/UDP: BitTorrent peer connections
|
||||
# - Port 8080 TCP: Flacfetch HTTP API (auth required at app level)
|
||||
flacfetch_firewall = gcp.compute.Firewall(
|
||||
"flacfetch-firewall",
|
||||
name="flacfetch-firewall",
|
||||
network="default",
|
||||
allows=[
|
||||
# BitTorrent peer connections
|
||||
gcp.compute.FirewallAllowArgs(protocol="tcp", ports=["51413"]),
|
||||
gcp.compute.FirewallAllowArgs(protocol="udp", ports=["51413"]),
|
||||
# Flacfetch HTTP API (auth required at app level)
|
||||
gcp.compute.FirewallAllowArgs(protocol="tcp", ports=["8080"]),
|
||||
],
|
||||
source_ranges=["0.0.0.0/0"], # Permissive, auth enforced at app level
|
||||
target_tags=["flacfetch-service"],
|
||||
description="Firewall rules for flacfetch torrent/API service",
|
||||
)
|
||||
|
||||
# Export flacfetch values
|
||||
pulumi.export("flacfetch_static_ip", flacfetch_ip.address)
|
||||
pulumi.export("flacfetch_service_url", flacfetch_ip.address.apply(
|
||||
lambda ip: f"http://{ip}:8080"
|
||||
))
|
||||
pulumi.export("flacfetch_service_account", flacfetch_sa.email)
|
||||
|
||||
@@ -4,4 +4,35 @@ import warnings
|
||||
warnings.filterwarnings("ignore", category=SyntaxWarning, module="pydub.*")
|
||||
warnings.filterwarnings("ignore", category=SyntaxWarning, module="syrics.*")
|
||||
|
||||
from .karaoke_gen import KaraokePrep
|
||||
# Lazy imports to avoid loading heavy dependencies when not needed.
|
||||
# KaraokePrep has many dependencies (lyrics_transcriber, etc.) which may not
|
||||
# be available in all contexts (e.g., backend which only needs audio_fetcher).
|
||||
#
|
||||
# Use explicit imports instead:
|
||||
# from karaoke_gen.karaoke_gen import KaraokePrep
|
||||
# from karaoke_gen.audio_fetcher import FlacFetcher, AudioSearchResult, ...
|
||||
|
||||
__all__ = [
|
||||
"KaraokePrep",
|
||||
# Audio fetcher
|
||||
"FlacFetcher",
|
||||
"AudioSearchResult",
|
||||
"AudioFetchResult",
|
||||
"AudioFetcherError",
|
||||
"NoResultsError",
|
||||
"DownloadError",
|
||||
"UserCancelledError",
|
||||
]
|
||||
|
||||
|
||||
def __getattr__(name):
|
||||
"""Lazy import for heavy modules."""
|
||||
if name == "KaraokePrep":
|
||||
from .karaoke_gen import KaraokePrep
|
||||
return KaraokePrep
|
||||
elif name in ("FlacFetcher", "AudioSearchResult", "AudioFetchResult",
|
||||
"AudioFetcherError", "NoResultsError", "DownloadError",
|
||||
"UserCancelledError"):
|
||||
from . import audio_fetcher
|
||||
return getattr(audio_fetcher, name)
|
||||
raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
|
||||
@@ -7,15 +7,29 @@ using flacfetch, replacing the previous direct yt-dlp usage.
|
||||
|
||||
import logging
|
||||
import os
|
||||
import signal
|
||||
import sys
|
||||
import tempfile
|
||||
import threading
|
||||
from abc import ABC, abstractmethod
|
||||
from dataclasses import dataclass
|
||||
from typing import List, Optional
|
||||
from concurrent.futures import ThreadPoolExecutor, TimeoutError as FuturesTimeoutError
|
||||
from dataclasses import dataclass, asdict, field
|
||||
from typing import List, Optional, Dict, Any
|
||||
|
||||
# Global flag to track if user requested cancellation via Ctrl+C
|
||||
_interrupt_requested = False
|
||||
|
||||
|
||||
@dataclass
|
||||
class AudioSearchResult:
|
||||
"""Represents a single search result for audio."""
|
||||
"""Represents a single search result for audio.
|
||||
|
||||
Used by both local CLI and cloud backend. Supports serialization
|
||||
for Firestore storage via to_dict()/from_dict().
|
||||
|
||||
For rich display, this class can serialize the full flacfetch Release
|
||||
data so remote CLIs can use flacfetch's shared display functions.
|
||||
"""
|
||||
|
||||
title: str
|
||||
artist: str
|
||||
@@ -24,13 +38,75 @@ class AudioSearchResult:
|
||||
duration: Optional[int] = None # Duration in seconds
|
||||
quality: Optional[str] = None # e.g., "FLAC", "320kbps", etc.
|
||||
source_id: Optional[str] = None # Unique ID from the source
|
||||
# Raw result object from the provider (for download)
|
||||
raw_result: Optional[object] = None
|
||||
index: int = 0 # Index in the results list (for API selection)
|
||||
seeders: Optional[int] = None # Number of seeders (for torrent sources)
|
||||
target_file: Optional[str] = None # Target filename in the release
|
||||
# Raw result object from the provider (for download) - not serialized
|
||||
raw_result: Optional[object] = field(default=None, repr=False)
|
||||
|
||||
def to_dict(self) -> Dict[str, Any]:
|
||||
"""Convert to dict for JSON/Firestore serialization.
|
||||
|
||||
Includes full flacfetch Release data if available, enabling
|
||||
remote CLIs to use flacfetch's shared display functions.
|
||||
"""
|
||||
result = {
|
||||
"title": self.title,
|
||||
"artist": self.artist,
|
||||
"url": self.url,
|
||||
"provider": self.provider,
|
||||
"duration": self.duration,
|
||||
"quality": self.quality,
|
||||
"source_id": self.source_id,
|
||||
"index": self.index,
|
||||
"seeders": self.seeders,
|
||||
"target_file": self.target_file,
|
||||
}
|
||||
|
||||
# If we have a raw_result (flacfetch Release), include its full data
|
||||
# This enables rich display on the remote CLI
|
||||
if self.raw_result:
|
||||
try:
|
||||
release_dict = self.raw_result.to_dict()
|
||||
# Merge Release fields into result (they may override basic fields)
|
||||
for key in ['year', 'label', 'edition_info', 'release_type', 'channel',
|
||||
'view_count', 'size_bytes', 'target_file_size', 'track_pattern',
|
||||
'match_score', 'formatted_size', 'formatted_duration',
|
||||
'formatted_views', 'is_lossless', 'quality_str', 'quality']:
|
||||
if key in release_dict:
|
||||
# Use 'quality_data' for the quality dict to avoid confusion with quality string
|
||||
result_key = 'quality_data' if key == 'quality' else key
|
||||
result[result_key] = release_dict[key]
|
||||
except AttributeError:
|
||||
pass # raw_result doesn't have to_dict() method
|
||||
|
||||
return result
|
||||
|
||||
@classmethod
|
||||
def from_dict(cls, data: Dict[str, Any]) -> "AudioSearchResult":
|
||||
"""Create from dict (e.g., from Firestore)."""
|
||||
return cls(
|
||||
title=data.get("title", ""),
|
||||
artist=data.get("artist", ""),
|
||||
url=data.get("url", ""),
|
||||
provider=data.get("provider", "Unknown"),
|
||||
duration=data.get("duration"),
|
||||
quality=data.get("quality"),
|
||||
source_id=data.get("source_id"),
|
||||
index=data.get("index", 0),
|
||||
seeders=data.get("seeders"),
|
||||
target_file=data.get("target_file"),
|
||||
raw_result=None, # Not stored in serialized form
|
||||
)
|
||||
|
||||
|
||||
@dataclass
|
||||
class AudioFetchResult:
|
||||
"""Result of an audio fetch operation."""
|
||||
"""Result of an audio fetch operation.
|
||||
|
||||
Used by both local CLI and cloud backend. Supports serialization
|
||||
for Firestore storage via to_dict()/from_dict().
|
||||
"""
|
||||
|
||||
filepath: str
|
||||
artist: str
|
||||
@@ -38,6 +114,22 @@ class AudioFetchResult:
|
||||
provider: str
|
||||
duration: Optional[int] = None
|
||||
quality: Optional[str] = None
|
||||
|
||||
def to_dict(self) -> Dict[str, Any]:
|
||||
"""Convert to dict for JSON/Firestore serialization."""
|
||||
return asdict(self)
|
||||
|
||||
@classmethod
|
||||
def from_dict(cls, data: Dict[str, Any]) -> "AudioFetchResult":
|
||||
"""Create from dict (e.g., from Firestore)."""
|
||||
return cls(
|
||||
filepath=data.get("filepath", ""),
|
||||
artist=data.get("artist", ""),
|
||||
title=data.get("title", ""),
|
||||
provider=data.get("provider", "Unknown"),
|
||||
duration=data.get("duration"),
|
||||
quality=data.get("quality"),
|
||||
)
|
||||
|
||||
|
||||
class AudioFetcherError(Exception):
|
||||
@@ -58,6 +150,19 @@ class DownloadError(AudioFetcherError):
|
||||
pass
|
||||
|
||||
|
||||
class UserCancelledError(AudioFetcherError):
|
||||
"""Raised when user explicitly cancels the operation (e.g., enters 0 or Ctrl+C)."""
|
||||
|
||||
pass
|
||||
|
||||
|
||||
def _check_interrupt():
|
||||
"""Check if interrupt was requested and raise UserCancelledError if so."""
|
||||
global _interrupt_requested
|
||||
if _interrupt_requested:
|
||||
raise UserCancelledError("Operation cancelled by user")
|
||||
|
||||
|
||||
class AudioFetcher(ABC):
|
||||
"""Abstract base class for audio fetching implementations."""
|
||||
|
||||
@@ -140,6 +245,8 @@ class FlacFetchAudioFetcher(AudioFetcher):
|
||||
|
||||
This provides access to multiple audio sources including private music trackers
|
||||
and YouTube, with intelligent prioritization of high-quality sources.
|
||||
|
||||
Also exported as FlacFetcher for shorter name.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
@@ -163,6 +270,47 @@ class FlacFetchAudioFetcher(AudioFetcher):
|
||||
self._ops_api_key = ops_api_key or os.environ.get("OPS_API_KEY")
|
||||
self._provider_priority = provider_priority
|
||||
self._manager = None
|
||||
self._transmission_available = None # Cached result of Transmission check
|
||||
|
||||
def _check_transmission_available(self) -> bool:
|
||||
"""
|
||||
Check if Transmission daemon is available for torrent downloads.
|
||||
|
||||
This prevents adding tracker providers (Redacted/OPS) when Transmission
|
||||
isn't running, which would result in search results that can't be downloaded.
|
||||
|
||||
Returns:
|
||||
True if Transmission is available and responsive, False otherwise.
|
||||
"""
|
||||
if self._transmission_available is not None:
|
||||
self.logger.info(f"[Transmission] Using cached status: available={self._transmission_available}")
|
||||
return self._transmission_available
|
||||
|
||||
host = os.environ.get("TRANSMISSION_HOST", "localhost")
|
||||
port = int(os.environ.get("TRANSMISSION_PORT", "9091"))
|
||||
self.logger.info(f"[Transmission] Checking availability at {host}:{port}")
|
||||
|
||||
try:
|
||||
import transmission_rpc
|
||||
self.logger.info(f"[Transmission] transmission_rpc imported successfully")
|
||||
|
||||
client = transmission_rpc.Client(host=host, port=port, timeout=5)
|
||||
self.logger.info(f"[Transmission] Client created, calling session_stats()...")
|
||||
|
||||
# Simple test to verify connection works
|
||||
stats = client.session_stats()
|
||||
self.logger.info(f"[Transmission] Connected! Download dir: {getattr(stats, 'download_dir', 'unknown')}")
|
||||
|
||||
self._transmission_available = True
|
||||
except ImportError as e:
|
||||
self._transmission_available = False
|
||||
self.logger.warning(f"[Transmission] transmission_rpc not installed: {e}")
|
||||
except Exception as e:
|
||||
self._transmission_available = False
|
||||
self.logger.warning(f"[Transmission] Connection failed to {host}:{port}: {type(e).__name__}: {e}")
|
||||
|
||||
self.logger.info(f"[Transmission] Final status: available={self._transmission_available}")
|
||||
return self._transmission_available
|
||||
|
||||
def _get_manager(self):
|
||||
"""Lazily initialize and return the FetchManager."""
|
||||
@@ -173,30 +321,46 @@ class FlacFetchAudioFetcher(AudioFetcher):
|
||||
from flacfetch.downloaders.youtube import YoutubeDownloader
|
||||
|
||||
# Try to import TorrentDownloader (has optional dependencies)
|
||||
TorrentDownloader = None
|
||||
try:
|
||||
from flacfetch.downloaders.torrent import TorrentDownloader
|
||||
except ImportError:
|
||||
TorrentDownloader = None
|
||||
self.logger.debug("TorrentDownloader not available (missing dependencies)")
|
||||
|
||||
self._manager = FetchManager()
|
||||
|
||||
# Only add tracker providers if we can actually download from them
|
||||
# This requires both TorrentDownloader and a running Transmission daemon
|
||||
has_torrent_downloader = TorrentDownloader is not None
|
||||
transmission_available = self._check_transmission_available()
|
||||
can_use_trackers = has_torrent_downloader and transmission_available
|
||||
|
||||
self.logger.info(
|
||||
f"[FlacFetcher] Provider setup: TorrentDownloader={has_torrent_downloader}, "
|
||||
f"Transmission={transmission_available}, can_use_trackers={can_use_trackers}"
|
||||
)
|
||||
|
||||
if not can_use_trackers and (self._redacted_api_key or self._ops_api_key):
|
||||
self.logger.warning(
|
||||
"[FlacFetcher] Tracker providers (Redacted/OPS) DISABLED: "
|
||||
f"TorrentDownloader={has_torrent_downloader}, Transmission={transmission_available}. "
|
||||
"Only YouTube sources will be used."
|
||||
)
|
||||
|
||||
# Add providers and downloaders based on available API keys
|
||||
if self._redacted_api_key:
|
||||
if self._redacted_api_key and can_use_trackers:
|
||||
from flacfetch.providers.redacted import RedactedProvider
|
||||
|
||||
self._manager.add_provider(RedactedProvider(api_key=self._redacted_api_key))
|
||||
if TorrentDownloader:
|
||||
self._manager.register_downloader("Redacted", TorrentDownloader())
|
||||
self.logger.debug("Added Redacted provider")
|
||||
self._manager.register_downloader("Redacted", TorrentDownloader())
|
||||
self.logger.info("[FlacFetcher] Added Redacted provider with TorrentDownloader")
|
||||
|
||||
if self._ops_api_key:
|
||||
if self._ops_api_key and can_use_trackers:
|
||||
from flacfetch.providers.ops import OPSProvider
|
||||
|
||||
self._manager.add_provider(OPSProvider(api_key=self._ops_api_key))
|
||||
if TorrentDownloader:
|
||||
self._manager.register_downloader("OPS", TorrentDownloader())
|
||||
self.logger.debug("Added OPS provider")
|
||||
self._manager.register_downloader("OPS", TorrentDownloader())
|
||||
self.logger.info("[FlacFetcher] Added OPS provider with TorrentDownloader")
|
||||
|
||||
# Always add YouTube as a fallback provider with its downloader
|
||||
self._manager.add_provider(YoutubeProvider())
|
||||
@@ -232,7 +396,7 @@ class FlacFetchAudioFetcher(AudioFetcher):
|
||||
|
||||
# Convert to our AudioSearchResult format
|
||||
search_results = []
|
||||
for result in results:
|
||||
for i, result in enumerate(results):
|
||||
# Get quality as string if it's a Quality object
|
||||
quality = getattr(result, "quality", None)
|
||||
quality_str = str(quality) if quality else None
|
||||
@@ -246,6 +410,9 @@ class FlacFetchAudioFetcher(AudioFetcher):
|
||||
duration=getattr(result, "duration_seconds", None),
|
||||
quality=quality_str,
|
||||
source_id=getattr(result, "info_hash", None),
|
||||
index=i, # Set index for API selection
|
||||
seeders=getattr(result, "seeders", None),
|
||||
target_file=getattr(result, "target_file", None),
|
||||
raw_result=result,
|
||||
)
|
||||
)
|
||||
@@ -309,6 +476,40 @@ class FlacFetchAudioFetcher(AudioFetcher):
|
||||
except Exception as e:
|
||||
raise DownloadError(f"Failed to download {result.artist} - {result.title}: {e}") from e
|
||||
|
||||
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 determine the best source.
|
||||
This is useful for automated/non-interactive usage.
|
||||
|
||||
Args:
|
||||
results: List of AudioSearchResult objects from search()
|
||||
|
||||
Returns:
|
||||
Index of the best result in the list
|
||||
"""
|
||||
if not results:
|
||||
return 0
|
||||
|
||||
manager = self._get_manager()
|
||||
|
||||
# Get raw results that have raw_result set
|
||||
raw_results = [r.raw_result for r in results if r.raw_result is not None]
|
||||
|
||||
if raw_results:
|
||||
try:
|
||||
best = manager.select_best(raw_results)
|
||||
# Find index of best result
|
||||
for i, r in enumerate(results):
|
||||
if r.raw_result == best:
|
||||
return i
|
||||
except Exception as e:
|
||||
self.logger.warning(f"select_best failed, using first result: {e}")
|
||||
|
||||
# Fallback: return first result
|
||||
return 0
|
||||
|
||||
def search_and_download(
|
||||
self,
|
||||
artist: str,
|
||||
@@ -336,6 +537,7 @@ class FlacFetchAudioFetcher(AudioFetcher):
|
||||
Raises:
|
||||
NoResultsError: If no results are found
|
||||
DownloadError: If download fails
|
||||
UserCancelledError: If user cancels (Ctrl+C or enters 0)
|
||||
"""
|
||||
from flacfetch.core.models import TrackQuery
|
||||
|
||||
@@ -343,7 +545,9 @@ class FlacFetchAudioFetcher(AudioFetcher):
|
||||
query = TrackQuery(artist=artist, title=title)
|
||||
|
||||
self.logger.info(f"Searching for: {artist} - {title}")
|
||||
results = manager.search(query)
|
||||
|
||||
# Run search in a thread so we can handle Ctrl+C
|
||||
results = self._interruptible_search(manager, query)
|
||||
|
||||
if not results:
|
||||
raise NoResultsError(f"No results found for: {artist} - {title}")
|
||||
@@ -358,6 +562,8 @@ class FlacFetchAudioFetcher(AudioFetcher):
|
||||
# Interactive mode: present options to user
|
||||
selected = self._interactive_select(results, artist, title)
|
||||
|
||||
# Note: _interactive_select now raises UserCancelledError instead of returning None
|
||||
# This check is kept as a safety net
|
||||
if selected is None:
|
||||
raise NoResultsError(f"No result selected for: {artist} - {title}")
|
||||
|
||||
@@ -371,13 +577,15 @@ class FlacFetchAudioFetcher(AudioFetcher):
|
||||
self.logger.info(f"Downloading from {getattr(selected, 'source_name', 'Unknown')}...")
|
||||
|
||||
try:
|
||||
filepath = manager.download(
|
||||
# Use interruptible download so Ctrl+C works during torrent downloads
|
||||
filepath = self._interruptible_download(
|
||||
manager,
|
||||
selected,
|
||||
output_path=output_dir,
|
||||
output_filename=output_filename,
|
||||
)
|
||||
|
||||
if filepath is None:
|
||||
if not filepath:
|
||||
raise DownloadError(f"Download returned no file path for: {artist} - {title}")
|
||||
|
||||
self.logger.info(f"Downloaded to: {filepath}")
|
||||
@@ -395,9 +603,179 @@ class FlacFetchAudioFetcher(AudioFetcher):
|
||||
quality=quality_str,
|
||||
)
|
||||
|
||||
except (UserCancelledError, KeyboardInterrupt):
|
||||
# Let cancellation exceptions propagate without wrapping
|
||||
raise
|
||||
except Exception as e:
|
||||
raise DownloadError(f"Failed to download {artist} - {title}: {e}") from e
|
||||
|
||||
def _interruptible_search(self, manager, query) -> list:
|
||||
"""
|
||||
Run search in a way that can be interrupted by Ctrl+C.
|
||||
|
||||
The flacfetch search is a blocking network operation that doesn't
|
||||
respond to SIGINT while running. This method runs it in a background
|
||||
thread and periodically checks for interrupts.
|
||||
|
||||
Args:
|
||||
manager: The FetchManager instance
|
||||
query: The TrackQuery to search for
|
||||
|
||||
Returns:
|
||||
List of search results
|
||||
|
||||
Raises:
|
||||
UserCancelledError: If user presses Ctrl+C during search
|
||||
"""
|
||||
global _interrupt_requested
|
||||
_interrupt_requested = False
|
||||
result_container = {"results": None, "error": None}
|
||||
|
||||
def do_search():
|
||||
try:
|
||||
result_container["results"] = manager.search(query)
|
||||
except Exception as e:
|
||||
result_container["error"] = e
|
||||
|
||||
# Set up signal handler for immediate response to Ctrl+C
|
||||
original_handler = signal.getsignal(signal.SIGINT)
|
||||
|
||||
def interrupt_handler(signum, frame):
|
||||
global _interrupt_requested
|
||||
_interrupt_requested = True
|
||||
# Print immediately so user knows it was received
|
||||
print("\nCancelling... please wait", file=sys.stderr)
|
||||
|
||||
signal.signal(signal.SIGINT, interrupt_handler)
|
||||
|
||||
try:
|
||||
# Start search in background thread
|
||||
search_thread = threading.Thread(target=do_search, daemon=True)
|
||||
search_thread.start()
|
||||
|
||||
# Wait for completion with periodic interrupt checks
|
||||
while search_thread.is_alive():
|
||||
search_thread.join(timeout=0.1) # Check every 100ms
|
||||
if _interrupt_requested:
|
||||
# Don't wait for thread - it's a daemon and will be killed
|
||||
raise UserCancelledError("Search cancelled by user (Ctrl+C)")
|
||||
|
||||
# Check for errors from the search
|
||||
if result_container["error"] is not None:
|
||||
raise result_container["error"]
|
||||
|
||||
return result_container["results"]
|
||||
|
||||
finally:
|
||||
# Restore original signal handler
|
||||
signal.signal(signal.SIGINT, original_handler)
|
||||
_interrupt_requested = False
|
||||
|
||||
def _interruptible_download(self, manager, selected, output_path: str, output_filename: str) -> str:
|
||||
"""
|
||||
Run download in a way that can be interrupted by Ctrl+C.
|
||||
|
||||
The flacfetch/transmission download is a blocking operation that doesn't
|
||||
respond to SIGINT while running (especially for torrent downloads).
|
||||
This method runs it in a background thread and periodically checks for interrupts.
|
||||
|
||||
Args:
|
||||
manager: The FetchManager instance
|
||||
selected: The selected result to download
|
||||
output_path: Directory to save the file
|
||||
output_filename: Filename to save as
|
||||
|
||||
Returns:
|
||||
Path to the downloaded file
|
||||
|
||||
Raises:
|
||||
UserCancelledError: If user presses Ctrl+C during download
|
||||
DownloadError: If download fails
|
||||
"""
|
||||
global _interrupt_requested
|
||||
_interrupt_requested = False
|
||||
result_container = {"filepath": None, "error": None}
|
||||
was_cancelled = False
|
||||
|
||||
def do_download():
|
||||
try:
|
||||
result_container["filepath"] = manager.download(
|
||||
selected,
|
||||
output_path=output_path,
|
||||
output_filename=output_filename,
|
||||
)
|
||||
except Exception as e:
|
||||
result_container["error"] = e
|
||||
|
||||
# Set up signal handler for immediate response to Ctrl+C
|
||||
original_handler = signal.getsignal(signal.SIGINT)
|
||||
|
||||
def interrupt_handler(signum, frame):
|
||||
global _interrupt_requested
|
||||
_interrupt_requested = True
|
||||
# Print immediately so user knows it was received
|
||||
print("\nCancelling download... please wait (may take a few seconds)", file=sys.stderr)
|
||||
|
||||
signal.signal(signal.SIGINT, interrupt_handler)
|
||||
|
||||
try:
|
||||
# Start download in background thread
|
||||
download_thread = threading.Thread(target=do_download, daemon=True)
|
||||
download_thread.start()
|
||||
|
||||
# Wait for completion with periodic interrupt checks
|
||||
while download_thread.is_alive():
|
||||
download_thread.join(timeout=0.2) # Check every 200ms
|
||||
if _interrupt_requested:
|
||||
was_cancelled = True
|
||||
# Clean up any pending torrents before raising
|
||||
self._cleanup_transmission_torrents(selected)
|
||||
raise UserCancelledError("Download cancelled by user (Ctrl+C)")
|
||||
|
||||
# Check for errors from the download
|
||||
if result_container["error"] is not None:
|
||||
raise result_container["error"]
|
||||
|
||||
return result_container["filepath"]
|
||||
|
||||
finally:
|
||||
# Restore original signal handler
|
||||
signal.signal(signal.SIGINT, original_handler)
|
||||
_interrupt_requested = False
|
||||
|
||||
def _cleanup_transmission_torrents(self, selected) -> None:
|
||||
"""
|
||||
Clean up any torrents in Transmission that were started for this download.
|
||||
|
||||
Called when a download is cancelled to remove incomplete torrents and their data.
|
||||
|
||||
Args:
|
||||
selected: The selected result that was being downloaded
|
||||
"""
|
||||
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)
|
||||
|
||||
# Get the release name to match against torrents
|
||||
release_name = getattr(selected, 'name', None) or getattr(selected, 'title', None)
|
||||
if not release_name:
|
||||
self.logger.debug("[Transmission] No release name to match for cleanup")
|
||||
return
|
||||
|
||||
# Find and remove matching incomplete torrents
|
||||
torrents = client.get_torrents()
|
||||
for torrent in torrents:
|
||||
# Match by name similarity and incomplete status
|
||||
if torrent.progress < 100 and release_name.lower() in torrent.name.lower():
|
||||
self.logger.info(f"[Transmission] Removing cancelled torrent: {torrent.name}")
|
||||
client.remove_torrent(torrent.id, delete_data=True)
|
||||
|
||||
except Exception as e:
|
||||
# Don't fail the cancellation if cleanup fails
|
||||
self.logger.debug(f"[Transmission] Cleanup failed (non-fatal): {e}")
|
||||
|
||||
def _interactive_select(self, results: list, artist: str, title: str) -> object:
|
||||
"""
|
||||
Present search results to the user for interactive selection.
|
||||
@@ -411,19 +789,25 @@ class FlacFetchAudioFetcher(AudioFetcher):
|
||||
|
||||
Returns:
|
||||
The selected Release object
|
||||
|
||||
Raises:
|
||||
UserCancelledError: If user cancels selection
|
||||
"""
|
||||
try:
|
||||
# Use flacfetch's built-in CLIHandler for rich display
|
||||
from flacfetch.interface.cli import CLIHandler
|
||||
|
||||
handler = CLIHandler(target_artist=artist)
|
||||
return handler.select_release(results)
|
||||
result = handler.select_release(results)
|
||||
if result is None:
|
||||
# User selected 0 to cancel
|
||||
raise UserCancelledError("Selection cancelled by user")
|
||||
return result
|
||||
except ImportError:
|
||||
# Fallback to basic display if CLIHandler not available
|
||||
return self._basic_interactive_select(results, artist, title)
|
||||
except (KeyboardInterrupt, EOFError):
|
||||
print("\nCancelled")
|
||||
return None
|
||||
raise UserCancelledError("Selection cancelled by user (Ctrl+C)")
|
||||
except (AttributeError, TypeError):
|
||||
# Fallback if results aren't proper Release objects (e.g., in tests)
|
||||
return self._basic_interactive_select(results, artist, title)
|
||||
@@ -439,42 +823,13 @@ class FlacFetchAudioFetcher(AudioFetcher):
|
||||
|
||||
Returns:
|
||||
The selected Release object
|
||||
|
||||
Raises:
|
||||
UserCancelledError: If user cancels selection
|
||||
"""
|
||||
print(f"\n{'=' * 60}")
|
||||
print(f"Search Results for: {artist} - {title}")
|
||||
print(f"{'=' * 60}\n")
|
||||
|
||||
for i, result in enumerate(results, 1):
|
||||
# Use correct flacfetch attribute names
|
||||
source_name = getattr(result, "source_name", "Unknown")
|
||||
result_title = getattr(result, "title", "Unknown")
|
||||
result_artist = getattr(result, "artist", "Unknown")
|
||||
quality = getattr(result, "quality", None)
|
||||
duration_seconds = getattr(result, "duration_seconds", None)
|
||||
seeders = getattr(result, "seeders", None)
|
||||
target_file = getattr(result, "target_file", None)
|
||||
|
||||
# Format duration if available
|
||||
duration_str = ""
|
||||
if duration_seconds:
|
||||
minutes = duration_seconds // 60
|
||||
seconds = duration_seconds % 60
|
||||
duration_str = f" [{minutes}:{seconds:02d}]"
|
||||
|
||||
# Format quality - it's a Quality object with __str__
|
||||
quality_str = f" ({quality})" if quality else ""
|
||||
|
||||
# Format seeders for torrent sources
|
||||
seeders_str = f" Seeders: {seeders}" if seeders is not None else ""
|
||||
|
||||
# Format target file
|
||||
file_str = f' "{target_file}"' if target_file else ""
|
||||
|
||||
print(f" {i}. [{source_name}] {result_artist} - {result_title}{quality_str}{duration_str}{seeders_str}{file_str}")
|
||||
|
||||
print()
|
||||
print(" 0. Cancel")
|
||||
print()
|
||||
# Use flacfetch's shared display function
|
||||
from flacfetch import print_releases
|
||||
print_releases(results, target_artist=artist, use_colors=True)
|
||||
|
||||
while True:
|
||||
try:
|
||||
@@ -482,7 +837,7 @@ class FlacFetchAudioFetcher(AudioFetcher):
|
||||
|
||||
if choice == "0":
|
||||
self.logger.info("User cancelled selection")
|
||||
return None
|
||||
raise UserCancelledError("Selection cancelled by user")
|
||||
|
||||
choice_num = int(choice)
|
||||
if 1 <= choice_num <= len(results):
|
||||
@@ -496,7 +851,11 @@ class FlacFetchAudioFetcher(AudioFetcher):
|
||||
print("Please enter a valid number")
|
||||
except KeyboardInterrupt:
|
||||
print("\nCancelled")
|
||||
return None
|
||||
raise UserCancelledError("Selection cancelled by user (Ctrl+C)")
|
||||
|
||||
|
||||
# Alias for shorter name - used by backend and other consumers
|
||||
FlacFetcher = FlacFetchAudioFetcher
|
||||
|
||||
|
||||
def create_audio_fetcher(
|
||||
|
||||
@@ -771,8 +771,16 @@ class AudioProcessor:
|
||||
padded_result["other_stems"] = separation_result.get("other_stems", {})
|
||||
padded_result["backing_vocals"] = separation_result.get("backing_vocals", {})
|
||||
|
||||
self.logger.info(
|
||||
f"✓ Countdown padding applied to {len(padded_result['combined_instrumentals']) + 1} instrumental file(s)"
|
||||
)
|
||||
# Count actual padded files (don't assume clean instrumental was padded)
|
||||
padded_count = (1 if padded_result["clean_instrumental"].get("instrumental") else 0) + len(padded_result["combined_instrumentals"])
|
||||
|
||||
if padded_count > 0:
|
||||
self.logger.info(
|
||||
f"✓ Countdown padding applied to {padded_count} instrumental file(s)"
|
||||
)
|
||||
else:
|
||||
self.logger.warning(
|
||||
"No instrumental files found to pad. Check that audio separation completed successfully."
|
||||
)
|
||||
|
||||
return padded_result
|
||||
@@ -47,6 +47,7 @@ class KaraokeFinalise:
|
||||
user_youtube_credentials=None, # Add support for pre-stored credentials
|
||||
server_side_mode=False, # New parameter for server-side deployment
|
||||
selected_instrumental_file=None, # Add support for pre-selected instrumental file
|
||||
countdown_padding_seconds=None, # Padding applied to vocals; instrumental must match
|
||||
):
|
||||
self.log_level = log_level
|
||||
self.log_formatter = log_formatter
|
||||
@@ -108,6 +109,7 @@ class KaraokeFinalise:
|
||||
self.user_youtube_credentials = user_youtube_credentials
|
||||
self.server_side_mode = server_side_mode
|
||||
self.selected_instrumental_file = selected_instrumental_file
|
||||
self.countdown_padding_seconds = countdown_padding_seconds
|
||||
|
||||
self.suffixes = {
|
||||
"title_mov": " (Title).mov",
|
||||
@@ -424,6 +426,15 @@ class KaraokeFinalise:
|
||||
# Check if any videos were found
|
||||
if "items" in response and len(response["items"]) > 0:
|
||||
for item in response["items"]:
|
||||
# YouTube search API sometimes returns results from other channels even with channelId filter
|
||||
# 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']} (channel: {result_channel_id})"
|
||||
)
|
||||
continue
|
||||
|
||||
found_title = item["snippet"]["title"]
|
||||
|
||||
# In server-side mode, require an exact match to avoid false positives.
|
||||
@@ -723,6 +734,32 @@ class KaraokeFinalise:
|
||||
artist, title = base_name.split(" - ", 1)
|
||||
return base_name, artist, title
|
||||
|
||||
def _pad_audio_file(self, input_audio, output_audio, padding_seconds):
|
||||
"""
|
||||
Pad an audio file by prepending silence at the beginning.
|
||||
|
||||
Uses the same ffmpeg approach as LyricsTranscriber's CountdownProcessor
|
||||
to ensure consistent padding behavior.
|
||||
|
||||
Args:
|
||||
input_audio: Path to input audio file
|
||||
output_audio: Path for the padded output file
|
||||
padding_seconds: Amount of silence to prepend (in seconds)
|
||||
"""
|
||||
self.logger.info(f"Padding audio file with {padding_seconds}s of silence")
|
||||
|
||||
# Use ffmpeg to prepend silence - this matches the approach in audio_processor.py
|
||||
# adelay filter adds delay in milliseconds
|
||||
delay_ms = int(padding_seconds * 1000)
|
||||
|
||||
ffmpeg_command = (
|
||||
f'{self.ffmpeg_base_command} -i "{input_audio}" '
|
||||
f'-af "adelay={delay_ms}|{delay_ms}" '
|
||||
f'"{output_audio}"'
|
||||
)
|
||||
|
||||
self.execute_command(ffmpeg_command, f"Padding audio with {padding_seconds}s silence")
|
||||
|
||||
def execute_command(self, command, description):
|
||||
"""Execute a shell command and log the output. For general commands (rclone, etc.)"""
|
||||
self.logger.info(f"{description}")
|
||||
@@ -767,11 +804,32 @@ class KaraokeFinalise:
|
||||
|
||||
def remux_with_instrumental(self, with_vocals_file, instrumental_audio, output_file):
|
||||
"""Remux the video with instrumental audio to create karaoke version"""
|
||||
# Safety net: If countdown padding was applied to vocals, ensure instrumental is padded too
|
||||
actual_instrumental = instrumental_audio
|
||||
if self.countdown_padding_seconds and self.countdown_padding_seconds > 0:
|
||||
# Check if the instrumental file is already padded (has "(Padded)" in name)
|
||||
if "(Padded)" not in instrumental_audio:
|
||||
self.logger.warning(
|
||||
f"Countdown padding ({self.countdown_padding_seconds}s) was applied to vocals, "
|
||||
f"but instrumental doesn't appear to be padded. Creating padded version..."
|
||||
)
|
||||
# Create a padded version of the instrumental
|
||||
base, ext = os.path.splitext(instrumental_audio)
|
||||
padded_instrumental = f"{base} (Padded){ext}"
|
||||
|
||||
if not os.path.exists(padded_instrumental):
|
||||
self._pad_audio_file(instrumental_audio, padded_instrumental, self.countdown_padding_seconds)
|
||||
self.logger.info(f"Created padded instrumental: {padded_instrumental}")
|
||||
|
||||
actual_instrumental = padded_instrumental
|
||||
else:
|
||||
self.logger.info(f"Using already-padded instrumental: {instrumental_audio}")
|
||||
|
||||
# This operation is primarily I/O bound (remuxing), so hardware acceleration doesn't provide significant benefit
|
||||
# Keep the existing approach but use the new execute method
|
||||
ffmpeg_command = (
|
||||
f'{self.ffmpeg_base_command} -an -i "{with_vocals_file}" '
|
||||
f'-vn -i "{instrumental_audio}" -c:v copy -c:a pcm_s16le "{output_file}"'
|
||||
f'-vn -i "{actual_instrumental}" -c:v copy -c:a pcm_s16le "{output_file}"'
|
||||
)
|
||||
self.execute_command(ffmpeg_command, "Remuxing video with instrumental audio")
|
||||
|
||||
|
||||
@@ -29,7 +29,7 @@ from .audio_processor import AudioProcessor
|
||||
from .lyrics_processor import LyricsProcessor
|
||||
from .video_generator import VideoGenerator
|
||||
from .video_background_processor import VideoBackgroundProcessor
|
||||
from .audio_fetcher import create_audio_fetcher, AudioFetcherError, NoResultsError
|
||||
from .audio_fetcher import create_audio_fetcher, AudioFetcherError, NoResultsError, UserCancelledError
|
||||
|
||||
|
||||
class KaraokePrep:
|
||||
@@ -259,6 +259,101 @@ class KaraokePrep:
|
||||
self.artist = metadata_result["artist"]
|
||||
self.title = metadata_result["title"]
|
||||
|
||||
def _scan_directory_for_instrumentals(self, track_output_dir, artist_title):
|
||||
"""
|
||||
Scan the directory for existing instrumental files and build a separated_audio structure.
|
||||
|
||||
This is used when transcription was skipped (existing files found) but we need to
|
||||
pad instrumentals due to countdown padding.
|
||||
|
||||
Args:
|
||||
track_output_dir: The track output directory to scan
|
||||
artist_title: The "{artist} - {title}" string for matching files
|
||||
|
||||
Returns:
|
||||
Dictionary with separated_audio structure containing found instrumental paths
|
||||
"""
|
||||
self.logger.info(f"Scanning directory for existing instrumentals: {track_output_dir}")
|
||||
|
||||
separated_audio = {
|
||||
"clean_instrumental": {},
|
||||
"backing_vocals": {},
|
||||
"other_stems": {},
|
||||
"combined_instrumentals": {},
|
||||
}
|
||||
|
||||
# Search patterns for instrumental files
|
||||
# Files are named like: "{artist} - {title} (Instrumental {model}).flac"
|
||||
# Or with backing vocals: "{artist} - {title} (Instrumental +BV {model}).flac"
|
||||
|
||||
# Look for files in the track output directory
|
||||
search_dir = track_output_dir
|
||||
|
||||
# Find all instrumental files (not padded ones - we want the originals)
|
||||
instrumental_pattern = os.path.join(search_dir, f"{artist_title} (Instrumental*.flac")
|
||||
instrumental_files = glob.glob(instrumental_pattern)
|
||||
|
||||
# Also check for wav files
|
||||
instrumental_pattern_wav = os.path.join(search_dir, f"{artist_title} (Instrumental*.wav")
|
||||
instrumental_files.extend(glob.glob(instrumental_pattern_wav))
|
||||
|
||||
self.logger.debug(f"Found {len(instrumental_files)} instrumental files")
|
||||
|
||||
for filepath in instrumental_files:
|
||||
filename = os.path.basename(filepath)
|
||||
|
||||
# Skip already padded files
|
||||
if "(Padded)" in filename:
|
||||
self.logger.debug(f"Skipping already padded file: {filename}")
|
||||
continue
|
||||
|
||||
# Determine if it's a combined instrumental (+BV) or clean instrumental
|
||||
if "+BV" in filename or "+bv" in filename.lower():
|
||||
# Combined instrumental with backing vocals
|
||||
# Extract model name from filename
|
||||
# Pattern: "(Instrumental +BV {model}).flac"
|
||||
model_match = re.search(r'\(Instrumental \+BV ([^)]+)\)', filename)
|
||||
if model_match:
|
||||
model_name = model_match.group(1).strip()
|
||||
separated_audio["combined_instrumentals"][model_name] = filepath
|
||||
self.logger.info(f"Found combined instrumental: {filename}")
|
||||
else:
|
||||
# Clean instrumental (no backing vocals)
|
||||
# Pattern: "(Instrumental {model}).flac"
|
||||
model_match = re.search(r'\(Instrumental ([^)]+)\)', filename)
|
||||
if model_match:
|
||||
# Use as clean instrumental if we don't have one yet
|
||||
if not separated_audio["clean_instrumental"].get("instrumental"):
|
||||
separated_audio["clean_instrumental"]["instrumental"] = filepath
|
||||
self.logger.info(f"Found clean instrumental: {filename}")
|
||||
else:
|
||||
# Additional clean instrumentals go to combined_instrumentals for padding
|
||||
model_name = model_match.group(1).strip()
|
||||
separated_audio["combined_instrumentals"][model_name] = filepath
|
||||
self.logger.info(f"Found additional instrumental: {filename}")
|
||||
|
||||
# Also look for backing vocals files
|
||||
backing_vocals_pattern = os.path.join(search_dir, f"{artist_title} (Backing Vocals*.flac")
|
||||
backing_vocals_files = glob.glob(backing_vocals_pattern)
|
||||
backing_vocals_pattern_wav = os.path.join(search_dir, f"{artist_title} (Backing Vocals*.wav")
|
||||
backing_vocals_files.extend(glob.glob(backing_vocals_pattern_wav))
|
||||
|
||||
for filepath in backing_vocals_files:
|
||||
filename = os.path.basename(filepath)
|
||||
model_match = re.search(r'\(Backing Vocals ([^)]+)\)', filename)
|
||||
if model_match:
|
||||
model_name = model_match.group(1).strip()
|
||||
if model_name not in separated_audio["backing_vocals"]:
|
||||
separated_audio["backing_vocals"][model_name] = {"backing_vocals": filepath}
|
||||
self.logger.info(f"Found backing vocals: {filename}")
|
||||
|
||||
# Log summary
|
||||
clean_count = 1 if separated_audio["clean_instrumental"].get("instrumental") else 0
|
||||
combined_count = len(separated_audio["combined_instrumentals"])
|
||||
self.logger.info(f"Directory scan complete: {clean_count} clean instrumental, {combined_count} combined instrumentals")
|
||||
|
||||
return separated_audio
|
||||
|
||||
async def prep_single_track(self):
|
||||
# Add signal handler at the start
|
||||
loop = asyncio.get_running_loop()
|
||||
@@ -422,6 +517,9 @@ class KaraokePrep:
|
||||
# No still image for audio-only downloads
|
||||
processed_track["input_still_image"] = None
|
||||
|
||||
except UserCancelledError:
|
||||
# User cancelled - propagate up to CLI for graceful exit
|
||||
raise
|
||||
except NoResultsError as e:
|
||||
self.logger.error(f"No audio found: {e}")
|
||||
return None
|
||||
@@ -764,6 +862,18 @@ class KaraokePrep:
|
||||
f"Applying {padding_seconds}s padding to all instrumental files to sync with vocal countdown"
|
||||
)
|
||||
|
||||
# If separated_audio is empty (e.g., transcription was skipped but existing files have countdown),
|
||||
# scan the directory for existing instrumental files
|
||||
has_instrumentals = (
|
||||
processed_track["separated_audio"].get("clean_instrumental", {}).get("instrumental") or
|
||||
processed_track["separated_audio"].get("combined_instrumentals")
|
||||
)
|
||||
if not has_instrumentals:
|
||||
self.logger.info("No instrumentals in separated_audio, scanning directory for existing files...")
|
||||
processed_track["separated_audio"] = self._scan_directory_for_instrumentals(
|
||||
track_output_dir, artist_title
|
||||
)
|
||||
|
||||
# Apply padding using AudioProcessor
|
||||
padded_separation_result = self.audio_processor.apply_countdown_padding_to_instrumentals(
|
||||
separation_result=processed_track["separated_audio"],
|
||||
|
||||
@@ -11,6 +11,9 @@ from .utils import sanitize_filename
|
||||
|
||||
# Placeholder class or functions for lyrics processing
|
||||
class LyricsProcessor:
|
||||
# Standard countdown padding duration used by LyricsTranscriber
|
||||
COUNTDOWN_PADDING_SECONDS = 3.0
|
||||
|
||||
def __init__(
|
||||
self, logger, style_params_json, lyrics_file, skip_transcription, skip_transcription_review, render_video, subtitle_offset_ms
|
||||
):
|
||||
@@ -22,6 +25,60 @@ class LyricsProcessor:
|
||||
self.render_video = render_video
|
||||
self.subtitle_offset_ms = subtitle_offset_ms
|
||||
|
||||
def _detect_countdown_padding_from_lrc(self, lrc_filepath):
|
||||
"""
|
||||
Detect if countdown padding was applied by checking the first lyric timestamp in the LRC file.
|
||||
|
||||
LRC format timestamps look like: [mm:ss.xx] or [mm:ss.xxx]
|
||||
If the first lyric timestamp is >= 3.0 seconds, countdown padding was likely applied.
|
||||
|
||||
Args:
|
||||
lrc_filepath: Path to the LRC file
|
||||
|
||||
Returns:
|
||||
Tuple of (countdown_padding_added: bool, countdown_padding_seconds: float)
|
||||
"""
|
||||
try:
|
||||
with open(lrc_filepath, 'r', encoding='utf-8') as f:
|
||||
content = f.read()
|
||||
|
||||
# Find all timestamp patterns in the LRC file
|
||||
# LRC timestamps: [mm:ss.xx] or [mm:ss.xxx]
|
||||
timestamp_pattern = r'\[(\d{1,2}):(\d{2})\.(\d{2,3})\]'
|
||||
matches = re.findall(timestamp_pattern, content)
|
||||
|
||||
if not matches:
|
||||
self.logger.debug("No timestamps found in LRC file")
|
||||
return (False, 0.0)
|
||||
|
||||
# Find the first non-metadata timestamp (metadata like [ar:Artist] doesn't have decimal)
|
||||
# We already filtered for decimal timestamps in our pattern
|
||||
first_timestamp = matches[0]
|
||||
minutes = int(first_timestamp[0])
|
||||
seconds = int(first_timestamp[1])
|
||||
# Handle both .xx and .xxx formats
|
||||
centiseconds = first_timestamp[2]
|
||||
if len(centiseconds) == 2:
|
||||
milliseconds = int(centiseconds) * 10
|
||||
else:
|
||||
milliseconds = int(centiseconds)
|
||||
|
||||
first_lyric_time = minutes * 60 + seconds + milliseconds / 1000.0
|
||||
|
||||
self.logger.debug(f"First lyric timestamp in LRC: {first_lyric_time:.3f}s")
|
||||
|
||||
# If first lyric is at or after 3 seconds, countdown padding was applied
|
||||
# Use a small buffer (2.5s) to account for songs that naturally start a bit late
|
||||
if first_lyric_time >= 2.5:
|
||||
self.logger.info(f"Detected countdown padding from LRC: first lyric at {first_lyric_time:.2f}s")
|
||||
return (True, self.COUNTDOWN_PADDING_SECONDS)
|
||||
|
||||
return (False, 0.0)
|
||||
|
||||
except Exception as e:
|
||||
self.logger.warning(f"Failed to detect countdown padding from LRC file: {e}")
|
||||
return (False, 0.0)
|
||||
|
||||
def find_best_split_point(self, line):
|
||||
"""
|
||||
Find the best split point in a line based on the specified criteria.
|
||||
@@ -138,23 +195,43 @@ class LyricsProcessor:
|
||||
lyrics_video_path = os.path.join(lyrics_dir, f"{sanitized_artist} - {sanitized_title} (With Vocals).mkv")
|
||||
lyrics_lrc_path = os.path.join(lyrics_dir, f"{sanitized_artist} - {sanitized_title} (Karaoke).lrc")
|
||||
|
||||
# If files exist in parent directory, return early
|
||||
# If files exist in parent directory, return early (but detect countdown padding first)
|
||||
if os.path.exists(parent_video_path) and os.path.exists(parent_lrc_path):
|
||||
self.logger.info(f"Found existing video and LRC files in parent directory, skipping transcription")
|
||||
self.logger.info("Found existing video and LRC files in parent directory, skipping transcription")
|
||||
|
||||
# Detect countdown padding from existing LRC file
|
||||
countdown_padding_added, countdown_padding_seconds = self._detect_countdown_padding_from_lrc(parent_lrc_path)
|
||||
|
||||
if countdown_padding_added:
|
||||
self.logger.info(f"Existing files have countdown padding: {countdown_padding_seconds}s")
|
||||
|
||||
return {
|
||||
"lrc_filepath": parent_lrc_path,
|
||||
"ass_filepath": parent_video_path,
|
||||
"countdown_padding_added": countdown_padding_added,
|
||||
"countdown_padding_seconds": countdown_padding_seconds,
|
||||
"padded_audio_filepath": None, # Original padded audio may not exist
|
||||
}
|
||||
|
||||
# If files exist in lyrics directory, copy to parent and return
|
||||
# If files exist in lyrics directory, copy to parent and return (but detect countdown padding first)
|
||||
if os.path.exists(lyrics_video_path) and os.path.exists(lyrics_lrc_path):
|
||||
self.logger.info(f"Found existing video and LRC files in lyrics directory, copying to parent")
|
||||
self.logger.info("Found existing video and LRC files in lyrics directory, copying to parent")
|
||||
os.makedirs(track_output_dir, exist_ok=True)
|
||||
shutil.copy2(lyrics_video_path, parent_video_path)
|
||||
shutil.copy2(lyrics_lrc_path, parent_lrc_path)
|
||||
|
||||
# Detect countdown padding from existing LRC file
|
||||
countdown_padding_added, countdown_padding_seconds = self._detect_countdown_padding_from_lrc(parent_lrc_path)
|
||||
|
||||
if countdown_padding_added:
|
||||
self.logger.info(f"Existing files have countdown padding: {countdown_padding_seconds}s")
|
||||
|
||||
return {
|
||||
"lrc_filepath": parent_lrc_path,
|
||||
"ass_filepath": parent_video_path,
|
||||
"countdown_padding_added": countdown_padding_added,
|
||||
"countdown_padding_seconds": countdown_padding_seconds,
|
||||
"padded_audio_filepath": None, # Original padded audio may not exist
|
||||
}
|
||||
|
||||
# Create lyrics directory if it doesn't exist
|
||||
|
||||
@@ -352,8 +352,10 @@ def create_parser(prog: str = "karaoke-gen") -> argparse.ArgumentParser:
|
||||
)
|
||||
remote_group.add_argument(
|
||||
"--review-ui-url",
|
||||
default=os.environ.get('REVIEW_UI_URL', 'https://lyrics.nomadkaraoke.com'),
|
||||
help="Lyrics review UI URL (default: https://lyrics.nomadkaraoke.com)",
|
||||
default=os.environ.get('REVIEW_UI_URL', os.environ.get('LYRICS_REVIEW_UI_URL', 'local')),
|
||||
help="Lyrics review UI URL. Use 'local' for bundled frontend (default), "
|
||||
"'http://localhost:5173' for Vite dev server, or 'https://lyrics.nomadkaraoke.com' for hosted. "
|
||||
"(env: REVIEW_UI_URL or LYRICS_REVIEW_UI_URL)",
|
||||
)
|
||||
remote_group.add_argument(
|
||||
"--poll-interval",
|
||||
|
||||
@@ -18,6 +18,7 @@ import glob
|
||||
import pyperclip
|
||||
from karaoke_gen import KaraokePrep
|
||||
from karaoke_gen.karaoke_finalise import KaraokeFinalise
|
||||
from karaoke_gen.audio_fetcher import UserCancelledError
|
||||
from karaoke_gen.instrumental_review import (
|
||||
AudioAnalyzer,
|
||||
WaveformGenerator,
|
||||
@@ -265,6 +266,13 @@ def run_instrumental_review(track: dict, logger: logging.Logger) -> str | None:
|
||||
else:
|
||||
logger.warning("Custom instrumental not found, falling back to clean")
|
||||
return clean_instrumental_path
|
||||
elif selection == "uploaded":
|
||||
uploaded_path = server.get_uploaded_instrumental_path()
|
||||
if uploaded_path and os.path.exists(uploaded_path):
|
||||
return uploaded_path
|
||||
else:
|
||||
logger.warning("Uploaded instrumental not found, falling back to clean")
|
||||
return clean_instrumental_path
|
||||
else:
|
||||
logger.warning(f"Unknown selection: {selection}, falling back to numeric selection")
|
||||
return None
|
||||
@@ -294,6 +302,11 @@ async def async_main():
|
||||
parser = create_parser(prog="karaoke-gen")
|
||||
args = parser.parse_args()
|
||||
|
||||
# Set review UI URL environment variable for the lyrics transcriber review server
|
||||
# This allows development against a local frontend dev server (e.g., http://localhost:5173)
|
||||
if hasattr(args, 'review_ui_url') and args.review_ui_url:
|
||||
os.environ['LYRICS_REVIEW_UI_URL'] = args.review_ui_url
|
||||
|
||||
# Process style overrides
|
||||
try:
|
||||
style_overrides = process_style_overrides(args.style_override, logger)
|
||||
@@ -385,7 +398,21 @@ async def async_main():
|
||||
kprep.input_media = input_audio_wav
|
||||
|
||||
# Run KaraokePrep
|
||||
tracks = await kprep.process()
|
||||
try:
|
||||
tracks = await kprep.process()
|
||||
except UserCancelledError:
|
||||
logger.info("Operation cancelled by user")
|
||||
return
|
||||
except KeyboardInterrupt:
|
||||
logger.info("Operation cancelled by user (Ctrl+C)")
|
||||
return
|
||||
|
||||
# Filter out None tracks (can happen if prep failed for some tracks)
|
||||
tracks = [t for t in tracks if t is not None] if tracks else []
|
||||
|
||||
if not tracks:
|
||||
logger.warning("No tracks to process")
|
||||
return
|
||||
|
||||
# Load CDG styles if CDG generation is enabled
|
||||
cdg_styles = None
|
||||
@@ -704,7 +731,21 @@ async def async_main():
|
||||
kprep = kprep_coroutine
|
||||
|
||||
# Create final tracks data structure
|
||||
tracks = await kprep.process()
|
||||
try:
|
||||
tracks = await kprep.process()
|
||||
except UserCancelledError:
|
||||
logger.info("Operation cancelled by user")
|
||||
return
|
||||
except KeyboardInterrupt:
|
||||
logger.info("Operation cancelled by user (Ctrl+C)")
|
||||
return
|
||||
|
||||
# Filter out None tracks (can happen if prep failed for some tracks)
|
||||
tracks = [t for t in tracks if t is not None] if tracks else []
|
||||
|
||||
if not tracks:
|
||||
logger.warning("No tracks to process")
|
||||
return
|
||||
|
||||
# If prep-only mode, we're done
|
||||
if args.prep_only:
|
||||
@@ -779,6 +820,12 @@ async def async_main():
|
||||
|
||||
logger.info(f"Selected instrumental file: {selected_instrumental_file}")
|
||||
|
||||
# Get countdown padding info from track (if vocals were padded, instrumental must match)
|
||||
countdown_padding_seconds = None
|
||||
if track.get("countdown_padding_added", False):
|
||||
countdown_padding_seconds = track.get("countdown_padding_seconds", 3.0)
|
||||
logger.info(f"Countdown padding detected: {countdown_padding_seconds}s (will be applied to instrumental if needed)")
|
||||
|
||||
# Load CDG styles if CDG generation is enabled
|
||||
cdg_styles = None
|
||||
if args.enable_cdg:
|
||||
@@ -823,6 +870,7 @@ async def async_main():
|
||||
keep_brand_code=getattr(args, 'keep_brand_code', False),
|
||||
non_interactive=args.yes,
|
||||
selected_instrumental_file=selected_instrumental_file,
|
||||
countdown_padding_seconds=countdown_padding_seconds,
|
||||
)
|
||||
|
||||
try:
|
||||
|
||||
@@ -36,6 +36,8 @@ from typing import Any, Dict, Optional
|
||||
import requests
|
||||
|
||||
from .cli_args import create_parser, process_style_overrides, is_url, is_file
|
||||
# Use flacfetch's shared display functions for consistent formatting
|
||||
from flacfetch import print_releases, Release
|
||||
|
||||
|
||||
class JobStatus(str, Enum):
|
||||
@@ -67,6 +69,7 @@ class JobStatus(str, Enum):
|
||||
UPLOADING = "uploading"
|
||||
NOTIFYING = "notifying"
|
||||
COMPLETE = "complete"
|
||||
PREP_COMPLETE = "prep_complete" # Batch 6: Prep-only jobs stop here
|
||||
FAILED = "failed"
|
||||
CANCELLED = "cancelled"
|
||||
ERROR = "error"
|
||||
@@ -272,6 +275,9 @@ class RemoteKaraokeClient:
|
||||
clean_instrumental_model: Optional[str] = None,
|
||||
backing_vocals_models: Optional[list] = None,
|
||||
other_stems_models: Optional[list] = None,
|
||||
# Two-phase workflow (Batch 6)
|
||||
prep_only: bool = False,
|
||||
keep_brand_code: Optional[str] = None,
|
||||
) -> Dict[str, Any]:
|
||||
"""
|
||||
Submit a new karaoke generation job from a YouTube/online URL.
|
||||
@@ -342,6 +348,11 @@ class RemoteKaraokeClient:
|
||||
create_request['backing_vocals_models'] = backing_vocals_models
|
||||
if other_stems_models:
|
||||
create_request['other_stems_models'] = other_stems_models
|
||||
# Two-phase workflow (Batch 6)
|
||||
if prep_only:
|
||||
create_request['prep_only'] = prep_only
|
||||
if keep_brand_code:
|
||||
create_request['keep_brand_code'] = keep_brand_code
|
||||
|
||||
self.logger.info(f"Creating URL-based job at {self.config.service_url}/api/jobs/create-from-url")
|
||||
|
||||
@@ -397,6 +408,9 @@ class RemoteKaraokeClient:
|
||||
other_stems_models: Optional[list] = None,
|
||||
# Existing instrumental (Batch 3)
|
||||
existing_instrumental: Optional[str] = None,
|
||||
# Two-phase workflow (Batch 6)
|
||||
prep_only: bool = False,
|
||||
keep_brand_code: Optional[str] = None,
|
||||
) -> Dict[str, Any]:
|
||||
"""
|
||||
Submit a new karaoke generation job with optional style configuration.
|
||||
@@ -541,6 +555,11 @@ class RemoteKaraokeClient:
|
||||
create_request['backing_vocals_models'] = backing_vocals_models
|
||||
if other_stems_models:
|
||||
create_request['other_stems_models'] = other_stems_models
|
||||
# Two-phase workflow (Batch 6)
|
||||
if prep_only:
|
||||
create_request['prep_only'] = prep_only
|
||||
if keep_brand_code:
|
||||
create_request['keep_brand_code'] = keep_brand_code
|
||||
|
||||
response = self._request('POST', '/api/jobs/create-with-upload-urls', json=create_request)
|
||||
|
||||
@@ -628,6 +647,255 @@ class RemoteKaraokeClient:
|
||||
|
||||
return result
|
||||
|
||||
def submit_finalise_only_job(
|
||||
self,
|
||||
prep_folder: str,
|
||||
artist: str,
|
||||
title: str,
|
||||
enable_cdg: bool = True,
|
||||
enable_txt: bool = True,
|
||||
brand_prefix: Optional[str] = None,
|
||||
keep_brand_code: Optional[str] = None,
|
||||
discord_webhook_url: Optional[str] = None,
|
||||
youtube_description: Optional[str] = None,
|
||||
enable_youtube_upload: bool = False,
|
||||
dropbox_path: Optional[str] = None,
|
||||
gdrive_folder_id: Optional[str] = None,
|
||||
) -> Dict[str, Any]:
|
||||
"""
|
||||
Submit a finalise-only job with prep output files.
|
||||
|
||||
This is used when the user previously ran --prep-only and now wants
|
||||
to continue with the finalisation phase using cloud resources.
|
||||
|
||||
Args:
|
||||
prep_folder: Path to the prep output folder containing stems, screens, etc.
|
||||
artist: Artist name
|
||||
title: Song title
|
||||
enable_cdg: Generate CDG+MP3 package
|
||||
enable_txt: Generate TXT+MP3 package
|
||||
brand_prefix: Brand code prefix (e.g., "NOMAD")
|
||||
keep_brand_code: Preserve existing brand code from folder name
|
||||
discord_webhook_url: Discord webhook for notifications
|
||||
youtube_description: YouTube video description
|
||||
enable_youtube_upload: Enable YouTube upload
|
||||
dropbox_path: Dropbox folder path for organized output
|
||||
gdrive_folder_id: Google Drive folder ID for public share
|
||||
"""
|
||||
prep_path = Path(prep_folder)
|
||||
|
||||
if not prep_path.exists() or not prep_path.is_dir():
|
||||
raise FileNotFoundError(f"Prep folder not found: {prep_folder}")
|
||||
|
||||
# Detect files in prep folder
|
||||
files_info = []
|
||||
local_files = {} # file_type -> local_path
|
||||
|
||||
base_name = f"{artist} - {title}"
|
||||
|
||||
# Required files - with_vocals video
|
||||
for ext in ['.mkv', '.mov', '.mp4']:
|
||||
with_vocals_path = prep_path / f"{base_name} (With Vocals){ext}"
|
||||
if with_vocals_path.exists():
|
||||
files_info.append({
|
||||
'filename': with_vocals_path.name,
|
||||
'content_type': f'video/{ext[1:]}',
|
||||
'file_type': 'with_vocals'
|
||||
})
|
||||
local_files['with_vocals'] = str(with_vocals_path)
|
||||
break
|
||||
|
||||
if 'with_vocals' not in local_files:
|
||||
raise FileNotFoundError(f"with_vocals video not found in {prep_folder}")
|
||||
|
||||
# Title screen
|
||||
for ext in ['.mov', '.mkv', '.mp4']:
|
||||
title_path = prep_path / f"{base_name} (Title){ext}"
|
||||
if title_path.exists():
|
||||
files_info.append({
|
||||
'filename': title_path.name,
|
||||
'content_type': f'video/{ext[1:]}',
|
||||
'file_type': 'title_screen'
|
||||
})
|
||||
local_files['title_screen'] = str(title_path)
|
||||
break
|
||||
|
||||
if 'title_screen' not in local_files:
|
||||
raise FileNotFoundError(f"title_screen video not found in {prep_folder}")
|
||||
|
||||
# End screen
|
||||
for ext in ['.mov', '.mkv', '.mp4']:
|
||||
end_path = prep_path / f"{base_name} (End){ext}"
|
||||
if end_path.exists():
|
||||
files_info.append({
|
||||
'filename': end_path.name,
|
||||
'content_type': f'video/{ext[1:]}',
|
||||
'file_type': 'end_screen'
|
||||
})
|
||||
local_files['end_screen'] = str(end_path)
|
||||
break
|
||||
|
||||
if 'end_screen' not in local_files:
|
||||
raise FileNotFoundError(f"end_screen video not found in {prep_folder}")
|
||||
|
||||
# Instrumentals (at least one required)
|
||||
stems_dir = prep_path / 'stems'
|
||||
if stems_dir.exists():
|
||||
for stem_file in stems_dir.iterdir():
|
||||
if 'Instrumental' in stem_file.name and stem_file.suffix.lower() == '.flac':
|
||||
if '+BV' not in stem_file.name:
|
||||
if 'instrumental_clean' not in local_files:
|
||||
files_info.append({
|
||||
'filename': stem_file.name,
|
||||
'content_type': 'audio/flac',
|
||||
'file_type': 'instrumental_clean'
|
||||
})
|
||||
local_files['instrumental_clean'] = str(stem_file)
|
||||
elif '+BV' in stem_file.name:
|
||||
if 'instrumental_backing' not in local_files:
|
||||
files_info.append({
|
||||
'filename': stem_file.name,
|
||||
'content_type': 'audio/flac',
|
||||
'file_type': 'instrumental_backing'
|
||||
})
|
||||
local_files['instrumental_backing'] = str(stem_file)
|
||||
|
||||
# Also check root for instrumental files
|
||||
for stem_file in prep_path.iterdir():
|
||||
if 'Instrumental' in stem_file.name and stem_file.suffix.lower() == '.flac':
|
||||
if '+BV' not in stem_file.name and 'instrumental_clean' not in local_files:
|
||||
files_info.append({
|
||||
'filename': stem_file.name,
|
||||
'content_type': 'audio/flac',
|
||||
'file_type': 'instrumental_clean'
|
||||
})
|
||||
local_files['instrumental_clean'] = str(stem_file)
|
||||
elif '+BV' in stem_file.name and 'instrumental_backing' not in local_files:
|
||||
files_info.append({
|
||||
'filename': stem_file.name,
|
||||
'content_type': 'audio/flac',
|
||||
'file_type': 'instrumental_backing'
|
||||
})
|
||||
local_files['instrumental_backing'] = str(stem_file)
|
||||
|
||||
if 'instrumental_clean' not in local_files and 'instrumental_backing' not in local_files:
|
||||
raise FileNotFoundError(f"No instrumental file found in {prep_folder}")
|
||||
|
||||
# Optional files - LRC
|
||||
lrc_path = prep_path / f"{base_name} (Karaoke).lrc"
|
||||
if lrc_path.exists():
|
||||
files_info.append({
|
||||
'filename': lrc_path.name,
|
||||
'content_type': 'text/plain',
|
||||
'file_type': 'lrc'
|
||||
})
|
||||
local_files['lrc'] = str(lrc_path)
|
||||
|
||||
# Optional - Title/End JPG/PNG
|
||||
for img_type, file_type in [('Title', 'title'), ('End', 'end')]:
|
||||
for ext in ['.jpg', '.png']:
|
||||
img_path = prep_path / f"{base_name} ({img_type}){ext}"
|
||||
if img_path.exists():
|
||||
files_info.append({
|
||||
'filename': img_path.name,
|
||||
'content_type': f'image/{ext[1:]}',
|
||||
'file_type': f'{file_type}_{ext[1:]}'
|
||||
})
|
||||
local_files[f'{file_type}_{ext[1:]}'] = str(img_path)
|
||||
|
||||
self.logger.info(f"Found {len(files_info)} files in prep folder")
|
||||
for file_type in local_files:
|
||||
self.logger.info(f" {file_type}: {Path(local_files[file_type]).name}")
|
||||
|
||||
# Create finalise-only job
|
||||
create_request = {
|
||||
'artist': artist,
|
||||
'title': title,
|
||||
'files': files_info,
|
||||
'enable_cdg': enable_cdg,
|
||||
'enable_txt': enable_txt,
|
||||
}
|
||||
|
||||
if brand_prefix:
|
||||
create_request['brand_prefix'] = brand_prefix
|
||||
if keep_brand_code:
|
||||
create_request['keep_brand_code'] = keep_brand_code
|
||||
if discord_webhook_url:
|
||||
create_request['discord_webhook_url'] = discord_webhook_url
|
||||
if youtube_description:
|
||||
create_request['youtube_description'] = youtube_description
|
||||
if enable_youtube_upload:
|
||||
create_request['enable_youtube_upload'] = enable_youtube_upload
|
||||
if dropbox_path:
|
||||
create_request['dropbox_path'] = dropbox_path
|
||||
if gdrive_folder_id:
|
||||
create_request['gdrive_folder_id'] = gdrive_folder_id
|
||||
|
||||
self.logger.info(f"Creating finalise-only job at {self.config.service_url}/api/jobs/create-finalise-only")
|
||||
|
||||
response = self._request('POST', '/api/jobs/create-finalise-only', json=create_request)
|
||||
|
||||
if response.status_code != 200:
|
||||
try:
|
||||
error_detail = response.json()
|
||||
except Exception:
|
||||
error_detail = response.text
|
||||
raise RuntimeError(f"Error creating finalise-only job: {error_detail}")
|
||||
|
||||
create_result = response.json()
|
||||
if create_result.get('status') != 'success':
|
||||
raise RuntimeError(f"Error creating finalise-only job: {create_result}")
|
||||
|
||||
job_id = create_result['job_id']
|
||||
upload_urls = create_result['upload_urls']
|
||||
|
||||
self.logger.info(f"Job {job_id} created. Uploading {len(upload_urls)} files directly to storage...")
|
||||
|
||||
# Upload each file
|
||||
uploaded_files = []
|
||||
for url_info in upload_urls:
|
||||
file_type = url_info['file_type']
|
||||
signed_url = url_info['upload_url']
|
||||
content_type = url_info['content_type']
|
||||
local_path = local_files.get(file_type)
|
||||
|
||||
if not local_path:
|
||||
self.logger.warning(f"No local file found for file_type: {file_type}")
|
||||
continue
|
||||
|
||||
file_size = os.path.getsize(local_path)
|
||||
file_size_mb = file_size / (1024 * 1024)
|
||||
self.logger.info(f" Uploading {file_type} ({file_size_mb:.1f} MB)...")
|
||||
|
||||
success = self._upload_file_to_signed_url(signed_url, local_path, content_type)
|
||||
if not success:
|
||||
raise RuntimeError(f"Failed to upload {file_type} to storage")
|
||||
|
||||
uploaded_files.append(file_type)
|
||||
self.logger.info(f" ✓ Uploaded {file_type}")
|
||||
|
||||
# Mark uploads complete
|
||||
self.logger.info(f"Notifying backend that uploads are complete...")
|
||||
|
||||
complete_request = {
|
||||
'uploaded_files': uploaded_files
|
||||
}
|
||||
|
||||
response = self._request('POST', f'/api/jobs/{job_id}/finalise-uploads-complete', json=complete_request)
|
||||
|
||||
if response.status_code != 200:
|
||||
try:
|
||||
error_detail = response.json()
|
||||
except Exception:
|
||||
error_detail = response.text
|
||||
raise RuntimeError(f"Error completing finalise-only uploads: {error_detail}")
|
||||
|
||||
result = response.json()
|
||||
if result.get('status') != 'success':
|
||||
raise RuntimeError(f"Error completing finalise-only uploads: {result}")
|
||||
|
||||
return result
|
||||
|
||||
def get_job(self, job_id: str) -> Dict[str, Any]:
|
||||
"""Get job status and details."""
|
||||
response = self._request('GET', f'/api/jobs/{job_id}')
|
||||
@@ -1054,6 +1322,7 @@ class JobMonitor:
|
||||
'uploading': 'Uploading to distribution services',
|
||||
'notifying': 'Sending notifications',
|
||||
'complete': 'All processing complete',
|
||||
'prep_complete': 'Prep phase complete - ready for local finalisation',
|
||||
'failed': 'Job failed',
|
||||
'cancelled': 'Job cancelled',
|
||||
}
|
||||
@@ -1062,6 +1331,54 @@ class JobMonitor:
|
||||
"""Get user-friendly description for a status."""
|
||||
return self.STATUS_DESCRIPTIONS.get(status, status)
|
||||
|
||||
def _show_download_progress(self, job_data: Dict[str, Any]) -> None:
|
||||
"""Show detailed download progress during audio download."""
|
||||
try:
|
||||
# Get provider from job state_data
|
||||
state_data = job_data.get('state_data', {})
|
||||
provider = state_data.get('selected_audio_provider', 'unknown')
|
||||
|
||||
# For non-torrent providers (YouTube), just show simple message
|
||||
if provider.lower() == 'youtube':
|
||||
self.logger.info(f" [Downloading from YouTube...]")
|
||||
return
|
||||
|
||||
# Query health endpoint for transmission status (torrent providers)
|
||||
health_url = f"{self.config.service_url}/api/health/detailed"
|
||||
response = requests.get(health_url, timeout=5)
|
||||
|
||||
if response.status_code == 200:
|
||||
health = response.json()
|
||||
transmission = health.get('dependencies', {}).get('transmission', {})
|
||||
|
||||
if transmission.get('available'):
|
||||
torrents = transmission.get('torrents', [])
|
||||
if torrents:
|
||||
# Show info about active torrents
|
||||
for t in torrents:
|
||||
progress = t.get('progress', 0)
|
||||
peers = t.get('peers', 0)
|
||||
speed = t.get('download_speed', 0)
|
||||
stalled = t.get('stalled', False)
|
||||
|
||||
if stalled:
|
||||
self.logger.info(f" [Downloading from {provider}] {progress:.1f}% - STALLED (no peers)")
|
||||
elif progress < 100:
|
||||
self.logger.info(f" [Downloading from {provider}] {progress:.1f}% @ {speed:.1f} KB/s ({peers} peers)")
|
||||
else:
|
||||
self.logger.info(f" [Downloading from {provider}] Complete, processing...")
|
||||
else:
|
||||
# No torrents - might be starting or YouTube download
|
||||
self.logger.info(f" [Downloading from {provider}] Starting download...")
|
||||
else:
|
||||
self.logger.info(f" [Downloading from {provider}] Transmission not available - download may fail")
|
||||
else:
|
||||
self.logger.info(f" [Downloading from {provider}]...")
|
||||
|
||||
except Exception as e:
|
||||
# Fall back to simple message
|
||||
self.logger.info(f" [Downloading audio...]")
|
||||
|
||||
def open_browser(self, url: str) -> None:
|
||||
"""Open URL in the default browser."""
|
||||
system = platform.system()
|
||||
@@ -1250,6 +1567,47 @@ class JobMonitor:
|
||||
except Exception as e:
|
||||
self.logger.error(f"Error submitting selection: {e}")
|
||||
|
||||
def _convert_api_result_to_release_dict(self, result: dict) -> dict:
|
||||
"""
|
||||
Convert API search result to a dict compatible with flacfetch's Release.from_dict().
|
||||
|
||||
This enables using flacfetch's shared display functions for consistent,
|
||||
rich formatting between local and remote CLIs.
|
||||
"""
|
||||
# Build quality dict from API response
|
||||
quality_data = result.get('quality_data') or {
|
||||
"format": "OTHER",
|
||||
"media": "OTHER",
|
||||
}
|
||||
|
||||
return {
|
||||
"title": result.get('title', ''),
|
||||
"artist": result.get('artist', ''),
|
||||
"source_name": result.get('provider', 'Unknown'),
|
||||
"download_url": result.get('url'),
|
||||
"info_hash": result.get('source_id'),
|
||||
"size_bytes": result.get('size_bytes'),
|
||||
"year": result.get('year'),
|
||||
"edition_info": result.get('edition_info'),
|
||||
"label": result.get('label'),
|
||||
"release_type": result.get('release_type'),
|
||||
"seeders": result.get('seeders'),
|
||||
"channel": result.get('channel'),
|
||||
"view_count": result.get('view_count'),
|
||||
"duration_seconds": result.get('duration'),
|
||||
"target_file": result.get('target_file'),
|
||||
"target_file_size": result.get('target_file_size'),
|
||||
"track_pattern": result.get('track_pattern'),
|
||||
"match_score": result.get('match_score', 0.0),
|
||||
"quality": quality_data,
|
||||
# Pre-computed fields
|
||||
"formatted_size": result.get('formatted_size'),
|
||||
"formatted_duration": result.get('formatted_duration'),
|
||||
"formatted_views": result.get('formatted_views'),
|
||||
"is_lossless": result.get('is_lossless', False),
|
||||
"quality_str": result.get('quality_str') or result.get('quality', ''),
|
||||
}
|
||||
|
||||
def handle_audio_selection(self, job_id: str) -> None:
|
||||
"""Handle audio source selection interaction (Batch 5)."""
|
||||
self.logger.info("=" * 60)
|
||||
@@ -1260,6 +1618,7 @@ class JobMonitor:
|
||||
# Get search results
|
||||
results_data = self.client.get_audio_search_results(job_id)
|
||||
results = results_data.get('results', [])
|
||||
artist = results_data.get('artist', 'Unknown')
|
||||
|
||||
if not results:
|
||||
self.logger.error("No search results available")
|
||||
@@ -1270,42 +1629,27 @@ class JobMonitor:
|
||||
self.logger.info("Non-interactive mode: Auto-selecting first result")
|
||||
selection_index = 0
|
||||
else:
|
||||
self.logger.info("")
|
||||
self.logger.info("Choose which audio source to download:")
|
||||
self.logger.info("")
|
||||
# Convert API results to Release-compatible dicts for flacfetch display
|
||||
# This gives us the same rich, colorized output as the local CLI
|
||||
release_dicts = [self._convert_api_result_to_release_dict(r) for r in results]
|
||||
|
||||
for result in results:
|
||||
index = result.get('index', 0)
|
||||
provider = result.get('provider', 'Unknown')
|
||||
artist = result.get('artist', 'Unknown')
|
||||
title = result.get('title', 'Unknown')
|
||||
quality = result.get('quality', '')
|
||||
duration = result.get('duration')
|
||||
|
||||
# Format duration if available
|
||||
duration_str = ""
|
||||
if duration:
|
||||
minutes = duration // 60
|
||||
seconds = duration % 60
|
||||
duration_str = f" [{minutes}:{seconds:02d}]"
|
||||
|
||||
quality_str = f" ({quality})" if quality else ""
|
||||
|
||||
self.logger.info(f" {index + 1}) [{provider}] {artist} - {title}{quality_str}{duration_str}")
|
||||
|
||||
self.logger.info("")
|
||||
# Use flacfetch's shared display function
|
||||
print_releases(release_dicts, target_artist=artist, use_colors=True)
|
||||
|
||||
selection_index = -1
|
||||
while selection_index < 0:
|
||||
try:
|
||||
choice = input(f"Enter your choice (1-{len(results)}): ").strip()
|
||||
choice = input(f"\nSelect a release (1-{len(results)}, 0 to cancel): ").strip()
|
||||
if choice == "0":
|
||||
self.logger.info("Selection cancelled by user")
|
||||
raise KeyboardInterrupt
|
||||
choice_num = int(choice)
|
||||
if 1 <= choice_num <= len(results):
|
||||
selection_index = choice_num - 1
|
||||
else:
|
||||
self.logger.error(f"Please enter a number between 1 and {len(results)}")
|
||||
print(f"Please enter a number between 0 and {len(results)}")
|
||||
except ValueError:
|
||||
self.logger.error("Please enter a valid number")
|
||||
print("Please enter a valid number")
|
||||
except KeyboardInterrupt:
|
||||
print()
|
||||
raise
|
||||
@@ -1771,9 +2115,15 @@ class JobMonitor:
|
||||
self._polls_without_updates = 0
|
||||
else:
|
||||
self._polls_without_updates += 1
|
||||
if self._polls_without_updates >= self._heartbeat_interval:
|
||||
description = self._get_status_description(status)
|
||||
self.logger.info(f" [Still processing: {description}]")
|
||||
# More frequent updates during audio download (every poll)
|
||||
heartbeat_threshold = 1 if status == 'downloading_audio' else self._heartbeat_interval
|
||||
if self._polls_without_updates >= heartbeat_threshold:
|
||||
if status == 'downloading_audio':
|
||||
# Show detailed download progress including transmission status
|
||||
self._show_download_progress(job_data)
|
||||
else:
|
||||
description = self._get_status_description(status)
|
||||
self.logger.info(f" [Still processing: {description}]")
|
||||
self._polls_without_updates = 0
|
||||
|
||||
# Handle human interaction points
|
||||
@@ -1809,6 +2159,24 @@ class JobMonitor:
|
||||
self.download_outputs(job_id, job_data)
|
||||
return 0
|
||||
|
||||
elif status == 'prep_complete':
|
||||
self.logger.info("")
|
||||
self.logger.info("=" * 60)
|
||||
self.logger.info("PREP PHASE COMPLETE!")
|
||||
self.logger.info("=" * 60)
|
||||
self.logger.info(f"Track: {artist} - {title}")
|
||||
self.logger.info("")
|
||||
self.logger.info("Downloading all prep outputs...")
|
||||
self.download_outputs(job_id, job_data)
|
||||
self.logger.info("")
|
||||
self.logger.info("To continue with finalisation, run:")
|
||||
# Use shlex.quote for proper shell escaping of artist/title
|
||||
import shlex
|
||||
escaped_artist = shlex.quote(artist)
|
||||
escaped_title = shlex.quote(title)
|
||||
self.logger.info(f" karaoke-gen-remote --finalise-only ./<output_folder> {escaped_artist} {escaped_title}")
|
||||
return 0
|
||||
|
||||
elif status in ['failed', 'error']:
|
||||
self.logger.info("")
|
||||
self.logger.error("=" * 60)
|
||||
@@ -1879,9 +2247,6 @@ def main():
|
||||
"""Main entry point for the remote CLI."""
|
||||
# Set up logging - same format as gen_cli.py
|
||||
logger = logging.getLogger(__name__)
|
||||
# Prevent log propagation to root logger to avoid duplicate logs
|
||||
# when external packages (like lyrics_converter) configure root logger handlers
|
||||
logger.propagate = False
|
||||
log_handler = logging.StreamHandler()
|
||||
log_formatter = logging.Formatter(
|
||||
fmt="%(asctime)s.%(msecs)03d - %(levelname)s - %(module)s - %(message)s",
|
||||
@@ -2200,10 +2565,112 @@ def main():
|
||||
logger.error(f"Error deleting job: {e}")
|
||||
return 1
|
||||
|
||||
# Warn about unsupported features
|
||||
# Handle finalise-only mode (Batch 6)
|
||||
if args.finalise_only:
|
||||
logger.error("--finalise-only is not supported in remote mode")
|
||||
return 1
|
||||
logger.info("=" * 60)
|
||||
logger.info("Karaoke Generator (Remote) - Finalise Only Mode")
|
||||
logger.info("=" * 60)
|
||||
|
||||
# For finalise-only, we expect the current directory to be the prep output folder
|
||||
# OR a folder path as the first argument
|
||||
prep_folder = "."
|
||||
artist_arg_idx = 0
|
||||
|
||||
if args.args:
|
||||
# Check if first argument is a directory
|
||||
if os.path.isdir(args.args[0]):
|
||||
prep_folder = args.args[0]
|
||||
artist_arg_idx = 1
|
||||
|
||||
# Get artist and title from arguments
|
||||
if len(args.args) > artist_arg_idx + 1:
|
||||
artist = args.args[artist_arg_idx]
|
||||
title = args.args[artist_arg_idx + 1]
|
||||
elif len(args.args) > artist_arg_idx:
|
||||
logger.error("Finalise-only mode requires both Artist and Title")
|
||||
return 1
|
||||
else:
|
||||
# Try to extract from folder name
|
||||
folder_name = os.path.basename(os.path.abspath(prep_folder))
|
||||
parts = folder_name.split(" - ", 2)
|
||||
if len(parts) >= 2:
|
||||
# Format: "BRAND-XXXX - Artist - Title" or "Artist - Title"
|
||||
if "-" in parts[0] and parts[0].split("-")[1].isdigit():
|
||||
# Has brand code
|
||||
artist = parts[1] if len(parts) > 2 else "Unknown"
|
||||
title = parts[2] if len(parts) > 2 else parts[1]
|
||||
else:
|
||||
artist = parts[0]
|
||||
title = parts[1]
|
||||
logger.info(f"Extracted from folder name: {artist} - {title}")
|
||||
else:
|
||||
logger.error("Could not extract Artist and Title from folder name")
|
||||
logger.error("Please provide: karaoke-gen-remote --finalise-only <folder> \"Artist\" \"Title\"")
|
||||
return 1
|
||||
else:
|
||||
logger.error("Finalise-only mode requires folder path and/or Artist and Title")
|
||||
return 1
|
||||
|
||||
# Extract brand code from folder name if --keep-brand-code is set
|
||||
keep_brand_code = None
|
||||
if getattr(args, 'keep_brand_code', False):
|
||||
folder_name = os.path.basename(os.path.abspath(prep_folder))
|
||||
parts = folder_name.split(" - ", 1)
|
||||
if parts and "-" in parts[0]:
|
||||
# Check if it's a brand code format (e.g., "NOMAD-1234")
|
||||
potential_brand = parts[0]
|
||||
brand_parts = potential_brand.split("-")
|
||||
if len(brand_parts) == 2 and brand_parts[1].isdigit():
|
||||
keep_brand_code = potential_brand
|
||||
logger.info(f"Preserving brand code: {keep_brand_code}")
|
||||
|
||||
logger.info(f"Prep folder: {os.path.abspath(prep_folder)}")
|
||||
logger.info(f"Artist: {artist}")
|
||||
logger.info(f"Title: {title}")
|
||||
if keep_brand_code:
|
||||
logger.info(f"Brand Code: {keep_brand_code} (preserved)")
|
||||
logger.info("")
|
||||
|
||||
# Read youtube description from file if provided
|
||||
youtube_description = None
|
||||
if args.youtube_description_file and os.path.isfile(args.youtube_description_file):
|
||||
try:
|
||||
with open(args.youtube_description_file, 'r') as f:
|
||||
youtube_description = f.read()
|
||||
except Exception as e:
|
||||
logger.warning(f"Failed to read YouTube description file: {e}")
|
||||
|
||||
try:
|
||||
result = client.submit_finalise_only_job(
|
||||
prep_folder=prep_folder,
|
||||
artist=artist,
|
||||
title=title,
|
||||
enable_cdg=args.enable_cdg,
|
||||
enable_txt=args.enable_txt,
|
||||
brand_prefix=args.brand_prefix,
|
||||
keep_brand_code=keep_brand_code,
|
||||
discord_webhook_url=args.discord_webhook_url,
|
||||
youtube_description=youtube_description,
|
||||
enable_youtube_upload=getattr(args, 'enable_youtube_upload', False),
|
||||
dropbox_path=getattr(args, 'dropbox_path', None),
|
||||
gdrive_folder_id=getattr(args, 'gdrive_folder_id', None),
|
||||
)
|
||||
job_id = result.get('job_id')
|
||||
logger.info(f"Finalise-only job submitted: {job_id}")
|
||||
logger.info("")
|
||||
|
||||
# Monitor job
|
||||
return monitor.monitor(job_id)
|
||||
|
||||
except FileNotFoundError as e:
|
||||
logger.error(str(e))
|
||||
return 1
|
||||
except RuntimeError as e:
|
||||
logger.error(str(e))
|
||||
return 1
|
||||
except Exception as e:
|
||||
logger.error(f"Error: {e}")
|
||||
return 1
|
||||
|
||||
if args.edit_lyrics:
|
||||
logger.error("--edit-lyrics is not yet supported in remote mode")
|
||||
@@ -2215,8 +2682,7 @@ def main():
|
||||
|
||||
# Warn about features that are not yet supported in remote mode
|
||||
ignored_features = []
|
||||
if args.prep_only:
|
||||
ignored_features.append("--prep-only")
|
||||
# Note: --prep-only is now supported in remote mode (Batch 6)
|
||||
if args.skip_separation:
|
||||
ignored_features.append("--skip-separation")
|
||||
if args.skip_transcription:
|
||||
@@ -2421,6 +2887,8 @@ def main():
|
||||
logger.info(f"Other Stems Models: {args.other_stems_models}")
|
||||
if getattr(args, 'existing_instrumental', None):
|
||||
logger.info(f"Existing Instrumental: {args.existing_instrumental}")
|
||||
if getattr(args, 'prep_only', False):
|
||||
logger.info(f"Mode: prep-only (will stop after review)")
|
||||
logger.info(f"Service URL: {config.service_url}")
|
||||
logger.info(f"Review UI: {config.review_ui_url}")
|
||||
if config.non_interactive:
|
||||
@@ -2437,6 +2905,18 @@ def main():
|
||||
except Exception as e:
|
||||
logger.warning(f"Failed to read YouTube description file: {e}")
|
||||
|
||||
# Extract brand code from current directory if --keep-brand-code is set
|
||||
keep_brand_code_value = None
|
||||
if getattr(args, 'keep_brand_code', False):
|
||||
cwd_name = os.path.basename(os.getcwd())
|
||||
parts = cwd_name.split(" - ", 1)
|
||||
if parts and "-" in parts[0]:
|
||||
potential_brand = parts[0]
|
||||
brand_parts = potential_brand.split("-")
|
||||
if len(brand_parts) == 2 and brand_parts[1].isdigit():
|
||||
keep_brand_code_value = potential_brand
|
||||
logger.info(f"Preserving brand code: {keep_brand_code_value}")
|
||||
|
||||
try:
|
||||
# Submit job - different endpoint for URL vs file
|
||||
if is_url_input:
|
||||
@@ -2469,6 +2949,9 @@ def main():
|
||||
clean_instrumental_model=getattr(args, 'clean_instrumental_model', None),
|
||||
backing_vocals_models=getattr(args, 'backing_vocals_models', None),
|
||||
other_stems_models=getattr(args, 'other_stems_models', None),
|
||||
# Two-phase workflow (Batch 6)
|
||||
prep_only=getattr(args, 'prep_only', False),
|
||||
keep_brand_code=keep_brand_code_value,
|
||||
)
|
||||
else:
|
||||
# File-based job submission
|
||||
@@ -2498,6 +2981,9 @@ def main():
|
||||
other_stems_models=getattr(args, 'other_stems_models', None),
|
||||
# Existing instrumental (Batch 3)
|
||||
existing_instrumental=getattr(args, 'existing_instrumental', None),
|
||||
# Two-phase workflow (Batch 6)
|
||||
prep_only=getattr(args, 'prep_only', False),
|
||||
keep_brand_code=keep_brand_code_value,
|
||||
)
|
||||
job_id = result.get('job_id')
|
||||
style_assets = result.get('style_assets_uploaded', [])
|
||||
|
||||
@@ -0,0 +1,336 @@
|
||||
# MidiCo Synchronizer Reference
|
||||
|
||||
This document provides a detailed reference for replicating the MidiCo Synchronizer user experience in our Nomad Karaoke lyrics review UI. The MidiCo Synchronizer is a native macOS application that provides a polished, intuitive interface for manually syncing lyrics to audio.
|
||||
|
||||
## Problem Statement
|
||||
|
||||
Sometimes transcribed lyrics are correct and start well-synced, but progressively drift out of sync towards the second half of the song. We need an efficient way to fix timing for multiple segments without having to re-sync everything from scratch.
|
||||
|
||||
## Overview of MidiCo Interface
|
||||
|
||||
MidiCo consists of two windows:
|
||||
1. **Main Audio Player Window** - Controls audio playback
|
||||
2. **Synchronizer Window** - Timeline-based lyrics sync interface
|
||||
|
||||

|
||||
|
||||
---
|
||||
|
||||
## 1. Audio Player Integration
|
||||
|
||||
The main MidiCo window provides an audio player that stays synchronized with the Synchronizer:
|
||||
|
||||
- **Play/Pause/Stop buttons** - Standard playback controls
|
||||
- **Rewind/Fast-forward buttons** - Skip through the track
|
||||
- **Progress slider** - Shows current position (00:00 format) and remaining time (-03:45 format)
|
||||
- **Volume slider** - Control audio volume
|
||||
- **Tempo/Pitch sliders** - Adjust playback speed and pitch (useful for difficult sections)
|
||||
|
||||
**Key behavior:** The playhead position is always synced between the audio player and the Synchronizer timeline.
|
||||
|
||||
---
|
||||
|
||||
## 2. Synchronizer Primary View
|
||||
|
||||
The Synchronizer window contains the main timeline interface for syncing lyrics.
|
||||
|
||||
### 2.1 Top Control Buttons
|
||||
|
||||
Four main control buttons at the top:
|
||||
|
||||
| Button | Function |
|
||||
|--------|----------|
|
||||
| **Voice no.1** | Select which vocal track to sync (for multi-voice karaoke) |
|
||||
| **Start Sync** | Begin sync mode - starts audio, shows upcoming words, listens for spacebar |
|
||||
| **Clear Sync** | Delete all sync data, reset to unsynced state |
|
||||
| **Edit Lyrics** | Open modal to edit the lyrics text directly |
|
||||
| **Import Lrc** | Import timing data from an LRC file |
|
||||
|
||||
### 2.2 Timeline View
|
||||
|
||||
The main rectangular timeline area is the core of the interface.
|
||||
|
||||

|
||||
|
||||
#### Time Bar (Top Strip)
|
||||
- Thin bar at the top showing time in `MM:SS` format
|
||||
- Small tick marks for decisecond precision
|
||||
- Clicking anywhere on the time bar sets the playhead position (without changing playback state)
|
||||
|
||||
#### Playhead Marker
|
||||
- Small arrow/triangle indicator in the time bar
|
||||
- White vertical line spanning the full height of the timeline
|
||||
- Shows current playback position
|
||||
- Synced with the audio player position
|
||||
|
||||
#### Timeline Background
|
||||
- Light gray gradient background
|
||||
- **Clicking on the background deselects any selected words**
|
||||
- **Click-drag creates a selection rectangle** for selecting multiple word blocks
|
||||
|
||||
#### Zoom Control
|
||||
- Horizontal slider below the timeline labeled "Zoom"
|
||||
- Smooth continuous zoom (approximately 50 notches)
|
||||
- **Most zoomed in:** ~4.5 seconds visible edge-to-edge
|
||||
- **Most zoomed out:** ~24 seconds visible edge-to-edge
|
||||
- Smooth, responsive zooming is critical for fast songs
|
||||
|
||||

|
||||
|
||||
#### Horizontal Scrolling
|
||||
- Timeline scrolls horizontally to show different parts of the song
|
||||
- Small horizontal scrollbar at the bottom of the timeline area
|
||||
- During sync mode, the timeline auto-scrolls to follow the playhead
|
||||
|
||||
### 2.3 Word Blocks
|
||||
|
||||
Synced words appear as **red rectangular blocks** on the timeline:
|
||||
|
||||
- Each block shows the word text above the red bar
|
||||
- If word text is too long to fit the width of the red bar, the alignment with the red blocks becomes "best effort". Words don't overlap, they're all readable above the red bars for that segment
|
||||
- Block width corresponds to the word's duration
|
||||
- Block horizontal position corresponds to the word's start time
|
||||
|
||||
#### Two-Level Word Layout (Alternating Segments)
|
||||
|
||||
Segments alternate between two vertical positions on the timeline. Each consecutive segment (in time order) is placed on the opposite level from the previous one:
|
||||
|
||||
- **Level 0 (top)**: 1st, 3rd, 5th, 7th... segments
|
||||
- **Level 1 (bottom)**: 2nd, 4th, 6th, 8th... segments
|
||||
|
||||

|
||||
|
||||
This alternating layout is critical because:
|
||||
|
||||
1. **Text never overlaps between consecutive segments** - Since each segment is on a different level, the text labels above the red blocks from one segment won't collide with text from the next segment, even if the text extends past its block width.
|
||||
|
||||
2. **All words remain readable** - Text is allowed to extend horizontally beyond the red block boundaries. Because consecutive segments are always on different vertical levels, this extended text doesn't overlap with adjacent segments.
|
||||
|
||||

|
||||
|
||||
In the example above, notice how:
|
||||
- "Monica Mountains" (level 0) has text that extends beyond its block
|
||||
- "Where she then proceeded to pump her vehicle in and out of turns" (level 1) is on a different vertical level
|
||||
- "Sometimes dropping down to fifty miles per hour" (level 0) returns to the top level
|
||||
- "Only to immediately gun it back up to 90 again" (level 1) is back on the bottom level
|
||||
|
||||
This simple alternating pattern ensures that even long segment text remains fully readable without truncation.
|
||||
|
||||
**Edge case:** Overlap can still occur in rare situations - if one segment's text is extremely long AND the segment two positions later (on the same level) is very short/early. But this is uncommon in practice.
|
||||
|
||||
#### Word Block Selection
|
||||
|
||||
- **Single click** on a word block: Selects that block (shown with white 1px border)
|
||||
- **Click-drag on background**: Creates selection rectangle to select multiple blocks
|
||||
|
||||

|
||||
|
||||
#### Word Block Manipulation (Resize & Drag)
|
||||
|
||||
Selected word blocks can be manipulated directly on the timeline:
|
||||
|
||||
##### Resizing Word Blocks (Change Duration)
|
||||
|
||||
When a word block is selected and you hover over it, a **small white dot/handle** appears just inside the right edge of the block. This resize handle allows you to change the word's duration:
|
||||
|
||||
1. Select a word block (single click)
|
||||
2. Hover over the selected block to reveal the resize handle (white dot on right edge)
|
||||
3. Click and drag the handle left/right to shorten/lengthen the word's duration
|
||||
4. The word's end time changes; start time remains fixed
|
||||
|
||||
This is essential for fine-tuning word durations after initial sync, especially for:
|
||||
- Words that were synced too long or too short
|
||||
- Adjusting timing to better match the audio
|
||||
- Creating smoother transitions between words
|
||||
|
||||
##### Dragging Word Blocks (Change Position)
|
||||
|
||||
Selected word blocks can be dragged horizontally to change their position in time:
|
||||
|
||||
**Single word:**
|
||||
1. Select a word block
|
||||
2. Click and drag anywhere on the block (not on the resize handle)
|
||||
3. The entire word moves earlier/later in time (both start and end times shift)
|
||||
|
||||
**Multiple words:**
|
||||
1. Drag-select multiple word blocks (or Ctrl/Cmd+click to add to selection)
|
||||
2. Click and drag any of the selected blocks
|
||||
3. **All selected blocks move together**, maintaining their relative timing
|
||||
|
||||
This is particularly useful for:
|
||||
- Shifting an entire segment earlier or later when it's consistently off
|
||||
- Adjusting groups of words that were synced correctly relative to each other but offset from the audio
|
||||
- Fine-tuning timing without having to re-sync
|
||||
|
||||
**Example workflow:** If a segment of 10 words all come in 0.2 seconds too late:
|
||||
1. Drag-select all 10 word blocks
|
||||
2. Drag them 0.2 seconds earlier
|
||||
3. All words maintain their relative timing but are now properly aligned with the audio
|
||||
|
||||
### 2.4 Upcoming Words Display
|
||||
|
||||
During sync mode, unsynced words appear in **two locations**:
|
||||
|
||||

|
||||
|
||||
1. **Fixed position above time bar** (left side): Shows upcoming words as red/white blocks in a horizontal row. The next word to sync is highlighted in red, subsequent words in white.
|
||||
|
||||
2. **On the timeline, right of playhead**: Same words appear starting from the playhead position and extending to the right, with a pale yellow background and black text, moving along with the playhead during playback.
|
||||
|
||||
This dual display makes it easy to:
|
||||
- See what's coming next (fixed position - easy to read while focused on timing)
|
||||
- See where words will land on the timeline relative to already-synced words
|
||||
|
||||
---
|
||||
|
||||
## 3. Action Buttons (Icon Toolbar)
|
||||
|
||||
A row of small icon-only buttons appears above the timeline. Key buttons we need:
|
||||
|
||||
### Essential Buttons
|
||||
|
||||
| Icon | Tooltip | Function |
|
||||
|------|---------|----------|
|
||||
| **Rectangle with Pencil** | Split, spell or edit selected word | Opens popup to edit a single word. Useful for typos. Entering multiple space-separated words splits the selected word while preserving timing. |
|
||||
| **No entry symbol** | Unsynchronize from cursor position | All word blocks **after** the current playhead position are reset to unsynced state. Critical for fixing drift in later parts of a song. |
|
||||
| **Trash** | Delete selected | Deletes selected word(s) entirely. Useful for removing backing vocals or nonsense words. |
|
||||
|
||||
### Typical Workflow for Deleting Unwanted Words
|
||||
|
||||
1. Tap spacebar to sync the unwanted words (so they appear on timeline)
|
||||
2. Stop playback
|
||||
3. Click-drag to select the unwanted word blocks
|
||||
4. Click trash icon to delete
|
||||
5. Click Start Sync to resume syncing from where you left off
|
||||
|
||||
---
|
||||
|
||||
## 4. Sync Mode Operation
|
||||
|
||||
### Starting Sync
|
||||
|
||||
1. Click **Start Sync** button
|
||||
2. Audio begins playing from current playhead position
|
||||
3. Upcoming unsynced words appear in both display locations
|
||||
4. System begins listening for spacebar input
|
||||
|
||||
### Spacebar Timing
|
||||
|
||||
Two input modes:
|
||||
|
||||
**Tap (press and release quickly):**
|
||||
- Sets the **start time** of the next unsynced word to the current playhead position
|
||||
- The word's **end time** is set when the following word is synced
|
||||
- If gap between words > 1 second, previous word gets default 1 second duration
|
||||
|
||||
**Press-hold:**
|
||||
- Hold spacebar down when word starts
|
||||
- Release when word ends
|
||||
- Sets both start and end times explicitly
|
||||
|
||||
### Stopping Sync
|
||||
|
||||
- Click the **Stop** button (replaces Play when in sync mode)
|
||||
- Or click **Start Sync** again to toggle off
|
||||
- Sync progress is preserved
|
||||
|
||||
---
|
||||
|
||||
## 5. Edit Lyrics Modal
|
||||
|
||||

|
||||
|
||||
Accessed via the **Edit Lyrics** button. Provides:
|
||||
|
||||
- **Left panel**: Plain text editor with all lyrics, newlines separate segments
|
||||
- **Right panel**: Preview of how lyrics will appear (karaoke style rendering)
|
||||
- **Language selector**: For hyphenation support
|
||||
- **Hyphenate button**: Auto-hyphenate words for syllable-level sync
|
||||
- **Reset button**: Revert to original lyrics
|
||||
- **Cancel/OK buttons**: Discard or apply changes
|
||||
|
||||
### Important Behavior
|
||||
|
||||
Editing lyrics when there are already synced timestamps **usually messes up the syncs**. Users typically need to Clear Sync and start over after editing lyrics.
|
||||
|
||||
---
|
||||
|
||||
## 6. Apply Button
|
||||
|
||||
The **Apply** button in the bottom-right corner is critical:
|
||||
|
||||
- Changes made in the Synchronizer are **not saved** until Apply is clicked
|
||||
- This allows experimenting without fear of losing work
|
||||
- If sync goes badly wrong, user can close the Synchronizer without applying changes
|
||||
- Provides a safe "sandbox" for sync work
|
||||
|
||||
---
|
||||
|
||||
## 7. Performance Requirements
|
||||
|
||||
The entire interface must be:
|
||||
|
||||
- **Smooth and responsive** - No lag or stutter during playback
|
||||
- **Low latency** - Spacebar input must register with sub-100ms precision
|
||||
- **Efficient** - No unnecessary computation during sync (user is focused on timing)
|
||||
- **Native-app feel** - As expected from a macOS application
|
||||
|
||||
Since we're dealing with sub-second time precision for synced lyrics, performance is critical.
|
||||
|
||||
---
|
||||
|
||||
## 8. Implementation Notes for Our App
|
||||
|
||||
### Entry Point: "Edit All" Button
|
||||
|
||||
The current "Edit All" button should show a choice:
|
||||
1. **Replace all lyrics** - Shows the existing paste box flow (for completely new lyrics)
|
||||
2. **Re-sync existing lyrics** - Goes directly to the new Synchronizer view with all existing words/segments plotted on the timeline
|
||||
|
||||
This preserves existing sync data while allowing re-sync of later portions.
|
||||
|
||||
### Key Features to Implement
|
||||
|
||||
1. **Timeline with word blocks showing existing sync data**
|
||||
2. **Playhead synced with audio player**
|
||||
3. **Zoom slider (4.5s to 24s range)**
|
||||
4. **Horizontal scrolling**
|
||||
5. **Two-level word block layout**
|
||||
6. **Start Sync mode with spacebar capture**
|
||||
7. **Upcoming words display (fixed + timeline)**
|
||||
8. **"Unsynchronize from cursor" - critical for fixing drift**
|
||||
9. **Word selection (single click + drag-select)**
|
||||
10. **Delete selected words**
|
||||
11. **Edit single word popup**
|
||||
12. **Apply/Cancel for safe experimentation**
|
||||
|
||||
### Fixing Timing Drift (Primary Use Case)
|
||||
|
||||
The main workflow for fixing drift:
|
||||
|
||||
1. Open Synchronizer (with existing sync data loaded)
|
||||
2. Play audio to find where sync starts drifting
|
||||
3. Position playhead at last correctly-synced word
|
||||
4. Click "Unsynchronize from cursor position"
|
||||
5. Click "Start Sync" to resume syncing from that point
|
||||
6. Tap spacebar to re-sync the remaining words
|
||||
7. Click "Apply" when done
|
||||
|
||||
This workflow allows keeping good sync data while fixing only the problematic portion.
|
||||
|
||||
---
|
||||
|
||||
## Screenshots Reference
|
||||
|
||||
All screenshots are located in: `docs/midico-sync-screenshots/`
|
||||
|
||||
| Filename | Description |
|
||||
|----------|-------------|
|
||||
| `MidiCo-Synchronizer-2025-12-18-Empty-Timeline-Before-Any-Words-Synced.png` | Initial state with empty timeline |
|
||||
| `MidiCo-Synchronizer-2025-12-18-Start-Sync-Showing-Upcoming-Words.png` | Sync mode started, showing upcoming words in both locations |
|
||||
| `MidiCo-Synchronizer-2025-12-18-During-Sync-Showing-Synced-And-Upcoming-Words.png` | Mid-sync showing both synced blocks and upcoming words |
|
||||
| `MidiCo-Synchronizer-2025-12-18-During-Sync-Showing-Two-Levels-Word-Blocks.png` | Demonstration of two-level word block layout |
|
||||
| `MidiCo-Synchronizer-2025-12-18-During-Sync-Showing-Max-Zoom-Level.png` | Maximum zoom level (~4.5 seconds visible) |
|
||||
| `MidiCo-Synchronizer-2025-12-18-Click-Drag-Word-Selection.png` | Selection rectangle for multi-word selection |
|
||||
| `MidiCo-Synchronizer-2025-12-18-Lyrics-Editor-Modal.png` | Edit Lyrics modal dialog |
|
||||
| `MidiCo-Synchronizer-2025-12-18-Timeline-With-Non-Overlapping-Segments.png` | Shows alternating segment levels with long text that doesn't overlap |
|
||||
|
After Width: | Height: | Size: 138 KiB |
|
After Width: | Height: | Size: 144 KiB |
|
After Width: | Height: | Size: 149 KiB |
|
After Width: | Height: | Size: 162 KiB |
|
After Width: | Height: | Size: 126 KiB |
|
After Width: | Height: | Size: 143 KiB |
|
After Width: | Height: | Size: 150 KiB |
|
After Width: | Height: | Size: 56 KiB |
@@ -2,7 +2,7 @@
|
||||
"name": "lyrics-transcriber-frontend",
|
||||
"private": true,
|
||||
"homepage": "https://nomadkaraoke.github.io/lyrics-transcriber-frontend",
|
||||
"version": "0.80.0",
|
||||
"version": "0.82.0",
|
||||
"type": "module",
|
||||
"scripts": {
|
||||
"dev": "vite",
|
||||
|
||||
@@ -1326,6 +1326,7 @@ export default function LyricsAnalyzer({ data: initialData, onFileLoad, apiClien
|
||||
onPlaySegment={handlePlaySegment}
|
||||
currentTime={currentAudioTime}
|
||||
setModalSpacebarHandler={handleSetModalSpacebarHandler}
|
||||
existingSegments={data.corrected_segments}
|
||||
/>
|
||||
|
||||
{pendingAnnotation && (
|
||||
|
||||
@@ -0,0 +1,185 @@
|
||||
import { memo } from 'react'
|
||||
import {
|
||||
Box,
|
||||
Button,
|
||||
Divider,
|
||||
Stack
|
||||
} from '@mui/material'
|
||||
import PlayCircleOutlineIcon from '@mui/icons-material/PlayCircleOutline'
|
||||
import StopIcon from '@mui/icons-material/Stop'
|
||||
import PauseIcon from '@mui/icons-material/Pause'
|
||||
import PlayArrowIcon from '@mui/icons-material/PlayArrow'
|
||||
import ClearAllIcon from '@mui/icons-material/ClearAll'
|
||||
import EditNoteIcon from '@mui/icons-material/EditNote'
|
||||
import BlockIcon from '@mui/icons-material/Block'
|
||||
import EditIcon from '@mui/icons-material/Edit'
|
||||
import DeleteIcon from '@mui/icons-material/Delete'
|
||||
|
||||
interface SyncControlsProps {
|
||||
// Main buttons
|
||||
isManualSyncing: boolean
|
||||
isPaused: boolean
|
||||
onStartSync: () => void
|
||||
onPauseSync: () => void
|
||||
onResumeSync: () => void
|
||||
onClearSync: () => void
|
||||
onEditLyrics: () => void
|
||||
|
||||
// Playback controls
|
||||
onPlay: () => void
|
||||
onStop: () => void
|
||||
isPlaying: boolean
|
||||
|
||||
// Word action buttons
|
||||
hasSelectedWords: boolean
|
||||
selectedWordCount: number
|
||||
onUnsyncFromCursor: () => void
|
||||
onEditSelectedWord: () => void
|
||||
onDeleteSelected: () => void
|
||||
|
||||
// Additional state
|
||||
canUnsyncFromCursor: boolean
|
||||
}
|
||||
|
||||
const SyncControls = memo(function SyncControls({
|
||||
isManualSyncing,
|
||||
isPaused,
|
||||
onStartSync,
|
||||
onPauseSync,
|
||||
onResumeSync,
|
||||
onClearSync,
|
||||
onEditLyrics,
|
||||
onPlay,
|
||||
onStop,
|
||||
isPlaying,
|
||||
hasSelectedWords,
|
||||
selectedWordCount,
|
||||
onUnsyncFromCursor,
|
||||
onEditSelectedWord,
|
||||
onDeleteSelected,
|
||||
canUnsyncFromCursor
|
||||
}: SyncControlsProps) {
|
||||
return (
|
||||
<Box sx={{ display: 'flex', flexDirection: 'column', gap: 1.5 }}>
|
||||
{/* Row 1: Playback & Sync Mode Controls */}
|
||||
<Stack direction="row" spacing={1} alignItems="center" flexWrap="wrap">
|
||||
{/* Playback controls */}
|
||||
<Button
|
||||
variant="outlined"
|
||||
color="primary"
|
||||
onClick={onPlay}
|
||||
startIcon={<PlayArrowIcon />}
|
||||
size="small"
|
||||
disabled={isPlaying}
|
||||
>
|
||||
Play
|
||||
</Button>
|
||||
<Button
|
||||
variant="outlined"
|
||||
color="error"
|
||||
onClick={onStop}
|
||||
startIcon={<StopIcon />}
|
||||
size="small"
|
||||
disabled={!isPlaying}
|
||||
>
|
||||
Stop
|
||||
</Button>
|
||||
|
||||
<Divider orientation="vertical" flexItem sx={{ mx: 0.5 }} />
|
||||
|
||||
{/* Sync Mode controls */}
|
||||
{isManualSyncing ? (
|
||||
<>
|
||||
<Button
|
||||
variant="contained"
|
||||
color="error"
|
||||
onClick={onStartSync}
|
||||
startIcon={<StopIcon />}
|
||||
size="small"
|
||||
>
|
||||
Stop Sync
|
||||
</Button>
|
||||
<Button
|
||||
variant="outlined"
|
||||
color={isPaused ? 'success' : 'warning'}
|
||||
onClick={isPaused ? onResumeSync : onPauseSync}
|
||||
startIcon={isPaused ? <PlayArrowIcon /> : <PauseIcon />}
|
||||
size="small"
|
||||
>
|
||||
{isPaused ? 'Resume' : 'Pause'}
|
||||
</Button>
|
||||
</>
|
||||
) : (
|
||||
<Button
|
||||
variant="contained"
|
||||
color="primary"
|
||||
onClick={onStartSync}
|
||||
startIcon={<PlayCircleOutlineIcon />}
|
||||
size="small"
|
||||
>
|
||||
Start Sync
|
||||
</Button>
|
||||
)}
|
||||
</Stack>
|
||||
|
||||
{/* Row 2: Editing & Word Actions */}
|
||||
<Stack direction="row" spacing={1} alignItems="center" flexWrap="wrap">
|
||||
<Button
|
||||
variant="outlined"
|
||||
color="warning"
|
||||
onClick={onClearSync}
|
||||
startIcon={<ClearAllIcon />}
|
||||
size="small"
|
||||
disabled={isManualSyncing && !isPaused}
|
||||
>
|
||||
Clear Sync
|
||||
</Button>
|
||||
|
||||
<Button
|
||||
variant="outlined"
|
||||
onClick={onEditLyrics}
|
||||
startIcon={<EditNoteIcon />}
|
||||
size="small"
|
||||
disabled={isManualSyncing && !isPaused}
|
||||
>
|
||||
Edit Lyrics
|
||||
</Button>
|
||||
|
||||
<Divider orientation="vertical" flexItem sx={{ mx: 0.5 }} />
|
||||
|
||||
<Button
|
||||
variant="outlined"
|
||||
onClick={onUnsyncFromCursor}
|
||||
startIcon={<BlockIcon />}
|
||||
size="small"
|
||||
disabled={!canUnsyncFromCursor || (isManualSyncing && !isPaused)}
|
||||
>
|
||||
Unsync from Cursor
|
||||
</Button>
|
||||
|
||||
<Button
|
||||
variant="outlined"
|
||||
onClick={onEditSelectedWord}
|
||||
startIcon={<EditIcon />}
|
||||
size="small"
|
||||
disabled={!hasSelectedWords || selectedWordCount !== 1}
|
||||
>
|
||||
Edit Word
|
||||
</Button>
|
||||
|
||||
<Button
|
||||
variant="outlined"
|
||||
color="error"
|
||||
onClick={onDeleteSelected}
|
||||
startIcon={<DeleteIcon />}
|
||||
size="small"
|
||||
disabled={!hasSelectedWords || (isManualSyncing && !isPaused)}
|
||||
>
|
||||
Delete{hasSelectedWords && selectedWordCount > 0 ? ` (${selectedWordCount})` : ''}
|
||||
</Button>
|
||||
</Stack>
|
||||
</Box>
|
||||
)
|
||||
})
|
||||
|
||||
export default SyncControls
|
||||
@@ -0,0 +1,704 @@
|
||||
import { useRef, useEffect, useCallback, useState, memo } from 'react'
|
||||
import { Box, IconButton, Tooltip } from '@mui/material'
|
||||
import ArrowBackIcon from '@mui/icons-material/ArrowBack'
|
||||
import ArrowForwardIcon from '@mui/icons-material/ArrowForward'
|
||||
import { Word, LyricsSegment } from '../../types'
|
||||
|
||||
interface TimelineCanvasProps {
|
||||
words: Word[]
|
||||
segments: LyricsSegment[]
|
||||
visibleStartTime: number
|
||||
visibleEndTime: number
|
||||
currentTime: number
|
||||
selectedWordIds: Set<string>
|
||||
onWordClick: (wordId: string, event: React.MouseEvent) => void
|
||||
onBackgroundClick: () => void
|
||||
onTimeBarClick: (time: number) => void
|
||||
onSelectionComplete: (wordIds: string[]) => void
|
||||
onWordTimingChange: (wordId: string, newStartTime: number, newEndTime: number) => void
|
||||
onWordsMove: (updates: Array<{ wordId: string; newStartTime: number; newEndTime: number }>) => void
|
||||
syncWordIndex: number
|
||||
isManualSyncing: boolean
|
||||
onScrollChange: (newStartTime: number) => void
|
||||
audioDuration: number
|
||||
zoomSeconds: number
|
||||
height?: number
|
||||
}
|
||||
|
||||
// Constants for rendering
|
||||
const TIME_BAR_HEIGHT = 28
|
||||
const WORD_BLOCK_HEIGHT = 24
|
||||
const WORD_LEVEL_SPACING = 50
|
||||
const CANVAS_PADDING = 8
|
||||
const TEXT_ABOVE_BLOCK = 14
|
||||
const RESIZE_HANDLE_SIZE = 8
|
||||
const RESIZE_HANDLE_HITAREA = 12
|
||||
const PLAYHEAD_COLOR = '#ffffff'
|
||||
const WORD_BLOCK_COLOR = '#d32f2f'
|
||||
const WORD_BLOCK_SELECTED_COLOR = '#b71c1c'
|
||||
const WORD_BLOCK_CURRENT_COLOR = '#f44336'
|
||||
const WORD_TEXT_CURRENT_COLOR = '#d32f2f'
|
||||
const UPCOMING_WORD_BG = '#fff9c4'
|
||||
const UPCOMING_WORD_TEXT = '#000000'
|
||||
const TIME_BAR_BG = '#f5f5f5'
|
||||
const TIME_BAR_TEXT = '#666666'
|
||||
const TIMELINE_BG = '#e0e0e0'
|
||||
|
||||
// Drag modes
|
||||
type DragMode = 'none' | 'selection' | 'resize' | 'move'
|
||||
|
||||
// Build a map of word ID to segment index
|
||||
function buildWordToSegmentMap(segments: LyricsSegment[]): Map<string, number> {
|
||||
const map = new Map<string, number>()
|
||||
segments.forEach((segment, idx) => {
|
||||
segment.words.forEach(word => {
|
||||
map.set(word.id, idx)
|
||||
})
|
||||
})
|
||||
return map
|
||||
}
|
||||
|
||||
// Calculate which vertical level a word should be on
|
||||
function calculateWordLevels(words: Word[], segments: LyricsSegment[]): Map<string, number> {
|
||||
const levels = new Map<string, number>()
|
||||
const wordToSegment = buildWordToSegmentMap(segments)
|
||||
|
||||
const segmentsWithTiming = segments
|
||||
.map((segment, idx) => {
|
||||
const timedWords = segment.words.filter(w => w.start_time !== null)
|
||||
const minStart = timedWords.length > 0
|
||||
? Math.min(...timedWords.map(w => w.start_time!))
|
||||
: Infinity
|
||||
return { idx, minStart }
|
||||
})
|
||||
.filter(s => s.minStart !== Infinity)
|
||||
.sort((a, b) => a.minStart - b.minStart)
|
||||
|
||||
const segmentLevels = new Map<number, number>()
|
||||
segmentsWithTiming.forEach(({ idx }, orderIndex) => {
|
||||
segmentLevels.set(idx, orderIndex % 2)
|
||||
})
|
||||
|
||||
for (const word of words) {
|
||||
const segmentIdx = wordToSegment.get(word.id)
|
||||
if (segmentIdx !== undefined && segmentLevels.has(segmentIdx)) {
|
||||
levels.set(word.id, segmentLevels.get(segmentIdx)!)
|
||||
} else {
|
||||
levels.set(word.id, 0)
|
||||
}
|
||||
}
|
||||
|
||||
return levels
|
||||
}
|
||||
|
||||
function formatTime(seconds: number): string {
|
||||
const mins = Math.floor(seconds / 60)
|
||||
const secs = Math.floor(seconds % 60)
|
||||
return `${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`
|
||||
}
|
||||
|
||||
const TimelineCanvas = memo(function TimelineCanvas({
|
||||
words,
|
||||
segments,
|
||||
visibleStartTime,
|
||||
visibleEndTime,
|
||||
currentTime,
|
||||
selectedWordIds,
|
||||
onWordClick,
|
||||
onBackgroundClick,
|
||||
onTimeBarClick,
|
||||
onSelectionComplete,
|
||||
onWordTimingChange,
|
||||
onWordsMove,
|
||||
syncWordIndex,
|
||||
isManualSyncing,
|
||||
onScrollChange,
|
||||
audioDuration,
|
||||
zoomSeconds,
|
||||
height = 200
|
||||
}: TimelineCanvasProps) {
|
||||
const canvasRef = useRef<HTMLCanvasElement>(null)
|
||||
const containerRef = useRef<HTMLDivElement>(null)
|
||||
const [canvasWidth, setCanvasWidth] = useState(800)
|
||||
const animationFrameRef = useRef<number>()
|
||||
const wordLevelsRef = useRef<Map<string, number>>(new Map())
|
||||
|
||||
// Drag state
|
||||
const [dragMode, setDragMode] = useState<DragMode>('none')
|
||||
const dragStartRef = useRef<{ x: number; y: number; time: number } | null>(null)
|
||||
const dragWordIdRef = useRef<string | null>(null)
|
||||
const dragOriginalTimesRef = useRef<Map<string, { start: number; end: number }>>(new Map())
|
||||
|
||||
// Selection rectangle
|
||||
const [selectionRect, setSelectionRect] = useState<{
|
||||
startX: number; startY: number; endX: number; endY: number
|
||||
} | null>(null)
|
||||
|
||||
// Hover state for showing resize handle
|
||||
const [hoveredWordId, setHoveredWordId] = useState<string | null>(null)
|
||||
const [cursorStyle, setCursorStyle] = useState<string>('default')
|
||||
|
||||
// Update canvas width on resize
|
||||
useEffect(() => {
|
||||
const updateWidth = () => {
|
||||
if (containerRef.current) {
|
||||
setCanvasWidth(containerRef.current.clientWidth)
|
||||
}
|
||||
}
|
||||
|
||||
updateWidth()
|
||||
const resizeObserver = new ResizeObserver(updateWidth)
|
||||
if (containerRef.current) {
|
||||
resizeObserver.observe(containerRef.current)
|
||||
}
|
||||
|
||||
return () => resizeObserver.disconnect()
|
||||
}, [])
|
||||
|
||||
// Calculate word levels when words or segments change
|
||||
useEffect(() => {
|
||||
wordLevelsRef.current = calculateWordLevels(words, segments)
|
||||
}, [words, segments])
|
||||
|
||||
// Convert time to x position
|
||||
const timeToX = useCallback((time: number): number => {
|
||||
const duration = visibleEndTime - visibleStartTime
|
||||
if (duration <= 0) return 0
|
||||
return CANVAS_PADDING + ((time - visibleStartTime) / duration) * (canvasWidth - CANVAS_PADDING * 2)
|
||||
}, [visibleStartTime, visibleEndTime, canvasWidth])
|
||||
|
||||
// Convert x position to time
|
||||
const xToTime = useCallback((x: number): number => {
|
||||
const duration = visibleEndTime - visibleStartTime
|
||||
return visibleStartTime + ((x - CANVAS_PADDING) / (canvasWidth - CANVAS_PADDING * 2)) * duration
|
||||
}, [visibleStartTime, visibleEndTime, canvasWidth])
|
||||
|
||||
// Get word bounds
|
||||
const getWordBounds = useCallback((word: Word) => {
|
||||
if (word.start_time === null || word.end_time === null) return null
|
||||
|
||||
const level = wordLevelsRef.current.get(word.id) || 0
|
||||
const startX = timeToX(word.start_time)
|
||||
const endX = timeToX(word.end_time)
|
||||
const blockWidth = Math.max(endX - startX, 4)
|
||||
const y = TIME_BAR_HEIGHT + CANVAS_PADDING + TEXT_ABOVE_BLOCK + level * WORD_LEVEL_SPACING
|
||||
|
||||
return { startX, endX, blockWidth, y, level }
|
||||
}, [timeToX])
|
||||
|
||||
// Check if position is near resize handle
|
||||
const isNearResizeHandlePos = useCallback((word: Word, x: number, y: number): boolean => {
|
||||
const bounds = getWordBounds(word)
|
||||
if (!bounds) return false
|
||||
|
||||
const handleX = bounds.startX + bounds.blockWidth - RESIZE_HANDLE_SIZE / 2
|
||||
const handleY = bounds.y + WORD_BLOCK_HEIGHT / 2
|
||||
|
||||
return Math.abs(x - handleX) < RESIZE_HANDLE_HITAREA / 2 &&
|
||||
Math.abs(y - handleY) < RESIZE_HANDLE_HITAREA / 2
|
||||
}, [getWordBounds])
|
||||
|
||||
// Find word at position
|
||||
const findWordAtPosition = useCallback((x: number, y: number): Word | null => {
|
||||
for (const word of words) {
|
||||
const bounds = getWordBounds(word)
|
||||
if (!bounds) continue
|
||||
|
||||
if (x >= bounds.startX && x <= bounds.startX + bounds.blockWidth &&
|
||||
y >= bounds.y && y <= bounds.y + WORD_BLOCK_HEIGHT) {
|
||||
return word
|
||||
}
|
||||
}
|
||||
return null
|
||||
}, [words, getWordBounds])
|
||||
|
||||
// Find words in selection rectangle
|
||||
const findWordsInRect = useCallback((rect: { startX: number; startY: number; endX: number; endY: number }): string[] => {
|
||||
const rectLeft = Math.min(rect.startX, rect.endX)
|
||||
const rectRight = Math.max(rect.startX, rect.endX)
|
||||
const rectTop = Math.min(rect.startY, rect.endY)
|
||||
const rectBottom = Math.max(rect.startY, rect.endY)
|
||||
|
||||
const selectedIds: string[] = []
|
||||
|
||||
for (const word of words) {
|
||||
const bounds = getWordBounds(word)
|
||||
if (!bounds) continue
|
||||
|
||||
if (bounds.startX + bounds.blockWidth >= rectLeft && bounds.startX <= rectRight &&
|
||||
bounds.y + WORD_BLOCK_HEIGHT >= rectTop && bounds.y <= rectBottom) {
|
||||
selectedIds.push(word.id)
|
||||
}
|
||||
}
|
||||
|
||||
return selectedIds
|
||||
}, [words, getWordBounds])
|
||||
|
||||
// Draw the timeline
|
||||
const draw = useCallback(() => {
|
||||
const canvas = canvasRef.current
|
||||
if (!canvas) return
|
||||
|
||||
const ctx = canvas.getContext('2d')
|
||||
if (!ctx) return
|
||||
|
||||
const dpr = window.devicePixelRatio || 1
|
||||
canvas.width = canvasWidth * dpr
|
||||
canvas.height = height * dpr
|
||||
ctx.scale(dpr, dpr)
|
||||
|
||||
// Clear canvas
|
||||
ctx.fillStyle = TIMELINE_BG
|
||||
ctx.fillRect(0, 0, canvasWidth, height)
|
||||
|
||||
// Draw time bar background
|
||||
ctx.fillStyle = TIME_BAR_BG
|
||||
ctx.fillRect(0, 0, canvasWidth, TIME_BAR_HEIGHT)
|
||||
|
||||
// Draw time markers
|
||||
const duration = visibleEndTime - visibleStartTime
|
||||
const secondsPerTick = duration > 15 ? 2 : duration > 8 ? 1 : 0.5
|
||||
const startSecond = Math.ceil(visibleStartTime / secondsPerTick) * secondsPerTick
|
||||
|
||||
ctx.fillStyle = TIME_BAR_TEXT
|
||||
ctx.font = '11px system-ui, -apple-system, sans-serif'
|
||||
ctx.textAlign = 'center'
|
||||
|
||||
for (let t = startSecond; t <= visibleEndTime; t += secondsPerTick) {
|
||||
const x = timeToX(t)
|
||||
|
||||
ctx.beginPath()
|
||||
ctx.strokeStyle = '#999999'
|
||||
ctx.lineWidth = 1
|
||||
ctx.moveTo(x, TIME_BAR_HEIGHT - 6)
|
||||
ctx.lineTo(x, TIME_BAR_HEIGHT)
|
||||
ctx.stroke()
|
||||
|
||||
if (t % 1 === 0) {
|
||||
ctx.fillText(formatTime(t), x, TIME_BAR_HEIGHT - 10)
|
||||
}
|
||||
}
|
||||
|
||||
ctx.beginPath()
|
||||
ctx.strokeStyle = '#cccccc'
|
||||
ctx.lineWidth = 1
|
||||
ctx.moveTo(0, TIME_BAR_HEIGHT)
|
||||
ctx.lineTo(canvasWidth, TIME_BAR_HEIGHT)
|
||||
ctx.stroke()
|
||||
|
||||
const wordToSegment = buildWordToSegmentMap(segments)
|
||||
const syncedWords = words.filter(w => w.start_time !== null && w.end_time !== null)
|
||||
|
||||
const currentWordId = syncedWords.find(w =>
|
||||
currentTime >= w.start_time! && currentTime <= w.end_time!
|
||||
)?.id || null
|
||||
|
||||
// First pass: draw all blocks
|
||||
for (const word of syncedWords) {
|
||||
const bounds = getWordBounds(word)
|
||||
if (!bounds) continue
|
||||
|
||||
const isSelected = selectedWordIds.has(word.id)
|
||||
const isCurrent = word.id === currentWordId
|
||||
const isHovered = word.id === hoveredWordId
|
||||
|
||||
// Draw word block background
|
||||
if (isSelected) {
|
||||
ctx.fillStyle = WORD_BLOCK_SELECTED_COLOR
|
||||
} else if (isCurrent) {
|
||||
ctx.fillStyle = WORD_BLOCK_CURRENT_COLOR
|
||||
} else {
|
||||
ctx.fillStyle = WORD_BLOCK_COLOR
|
||||
}
|
||||
ctx.fillRect(bounds.startX, bounds.y, bounds.blockWidth, WORD_BLOCK_HEIGHT)
|
||||
|
||||
// Draw selection border
|
||||
if (isSelected) {
|
||||
ctx.strokeStyle = '#ffffff'
|
||||
ctx.lineWidth = 2
|
||||
ctx.strokeRect(bounds.startX, bounds.y, bounds.blockWidth, WORD_BLOCK_HEIGHT)
|
||||
|
||||
// Draw resize handle (white dot on right edge) for selected words when hovered
|
||||
if (isHovered || selectedWordIds.size === 1) {
|
||||
const handleX = bounds.startX + bounds.blockWidth - RESIZE_HANDLE_SIZE / 2
|
||||
const handleY = bounds.y + WORD_BLOCK_HEIGHT / 2
|
||||
|
||||
ctx.beginPath()
|
||||
ctx.fillStyle = '#ffffff'
|
||||
ctx.arc(handleX, handleY, RESIZE_HANDLE_SIZE / 2, 0, Math.PI * 2)
|
||||
ctx.fill()
|
||||
ctx.strokeStyle = '#666666'
|
||||
ctx.lineWidth = 1
|
||||
ctx.stroke()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Second pass: draw text
|
||||
const wordsBySegment = new Map<number, Word[]>()
|
||||
for (const word of syncedWords) {
|
||||
const segIdx = wordToSegment.get(word.id)
|
||||
if (segIdx !== undefined) {
|
||||
if (!wordsBySegment.has(segIdx)) {
|
||||
wordsBySegment.set(segIdx, [])
|
||||
}
|
||||
wordsBySegment.get(segIdx)!.push(word)
|
||||
}
|
||||
}
|
||||
|
||||
ctx.font = '11px system-ui, -apple-system, sans-serif'
|
||||
ctx.textAlign = 'left'
|
||||
|
||||
for (const [, segmentWords] of wordsBySegment) {
|
||||
const sortedWords = [...segmentWords].sort((a, b) =>
|
||||
(a.start_time || 0) - (b.start_time || 0)
|
||||
)
|
||||
|
||||
if (sortedWords.length === 0) continue
|
||||
|
||||
const level = wordLevelsRef.current.get(sortedWords[0].id) || 0
|
||||
const textY = TIME_BAR_HEIGHT + CANVAS_PADDING + TEXT_ABOVE_BLOCK + level * WORD_LEVEL_SPACING - 3
|
||||
|
||||
let rightmostTextEnd = -Infinity
|
||||
|
||||
for (const word of sortedWords) {
|
||||
const blockStartX = timeToX(word.start_time!)
|
||||
const textWidth = ctx.measureText(word.text).width
|
||||
const textStartX = Math.max(blockStartX, rightmostTextEnd + 3)
|
||||
|
||||
if (textStartX < canvasWidth - 10) {
|
||||
const isCurrent = word.id === currentWordId
|
||||
ctx.fillStyle = isCurrent ? WORD_TEXT_CURRENT_COLOR : '#333333'
|
||||
ctx.fillText(word.text, textStartX, textY)
|
||||
rightmostTextEnd = textStartX + textWidth
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Draw upcoming words during sync
|
||||
if (isManualSyncing && syncWordIndex >= 0) {
|
||||
const upcomingWords = words.slice(syncWordIndex).filter(w => w.start_time === null)
|
||||
const playheadX = timeToX(currentTime)
|
||||
let offsetX = playheadX + 10
|
||||
|
||||
ctx.font = '11px system-ui, -apple-system, sans-serif'
|
||||
|
||||
for (let i = 0; i < Math.min(upcomingWords.length, 12); i++) {
|
||||
const word = upcomingWords[i]
|
||||
const textWidth = ctx.measureText(word.text).width + 10
|
||||
|
||||
ctx.fillStyle = UPCOMING_WORD_BG
|
||||
ctx.fillRect(offsetX, TIME_BAR_HEIGHT + CANVAS_PADDING + WORD_LEVEL_SPACING + 60, textWidth, 20)
|
||||
|
||||
ctx.fillStyle = UPCOMING_WORD_TEXT
|
||||
ctx.textAlign = 'left'
|
||||
ctx.fillText(word.text, offsetX + 5, TIME_BAR_HEIGHT + CANVAS_PADDING + WORD_LEVEL_SPACING + 74)
|
||||
|
||||
offsetX += textWidth + 3
|
||||
if (offsetX > canvasWidth - 20) break
|
||||
}
|
||||
}
|
||||
|
||||
// Draw playhead
|
||||
if (currentTime >= visibleStartTime && currentTime <= visibleEndTime) {
|
||||
const playheadX = timeToX(currentTime)
|
||||
|
||||
ctx.beginPath()
|
||||
ctx.fillStyle = PLAYHEAD_COLOR
|
||||
ctx.strokeStyle = '#333333'
|
||||
ctx.lineWidth = 1
|
||||
ctx.moveTo(playheadX - 6, 2)
|
||||
ctx.lineTo(playheadX + 6, 2)
|
||||
ctx.lineTo(playheadX, TIME_BAR_HEIGHT - 4)
|
||||
ctx.closePath()
|
||||
ctx.fill()
|
||||
ctx.stroke()
|
||||
|
||||
ctx.beginPath()
|
||||
ctx.strokeStyle = PLAYHEAD_COLOR
|
||||
ctx.lineWidth = 2
|
||||
ctx.moveTo(playheadX, TIME_BAR_HEIGHT)
|
||||
ctx.lineTo(playheadX, height)
|
||||
ctx.stroke()
|
||||
|
||||
ctx.beginPath()
|
||||
ctx.strokeStyle = 'rgba(0,0,0,0.4)'
|
||||
ctx.lineWidth = 1
|
||||
ctx.moveTo(playheadX + 1, TIME_BAR_HEIGHT)
|
||||
ctx.lineTo(playheadX + 1, height)
|
||||
ctx.stroke()
|
||||
}
|
||||
|
||||
// Draw selection rectangle
|
||||
if (selectionRect) {
|
||||
ctx.fillStyle = 'rgba(25, 118, 210, 0.2)'
|
||||
ctx.strokeStyle = 'rgba(25, 118, 210, 0.8)'
|
||||
ctx.lineWidth = 1
|
||||
|
||||
const rectX = Math.min(selectionRect.startX, selectionRect.endX)
|
||||
const rectY = Math.min(selectionRect.startY, selectionRect.endY)
|
||||
const rectW = Math.abs(selectionRect.endX - selectionRect.startX)
|
||||
const rectH = Math.abs(selectionRect.endY - selectionRect.startY)
|
||||
|
||||
ctx.fillRect(rectX, rectY, rectW, rectH)
|
||||
ctx.strokeRect(rectX, rectY, rectW, rectH)
|
||||
}
|
||||
}, [
|
||||
canvasWidth, height, visibleStartTime, visibleEndTime, currentTime,
|
||||
words, segments, selectedWordIds, selectionRect, hoveredWordId,
|
||||
syncWordIndex, isManualSyncing, timeToX, getWordBounds
|
||||
])
|
||||
|
||||
// Animation frame
|
||||
useEffect(() => {
|
||||
const animate = () => {
|
||||
draw()
|
||||
animationFrameRef.current = requestAnimationFrame(animate)
|
||||
}
|
||||
animate()
|
||||
|
||||
return () => {
|
||||
if (animationFrameRef.current) {
|
||||
cancelAnimationFrame(animationFrameRef.current)
|
||||
}
|
||||
}
|
||||
}, [draw])
|
||||
|
||||
// Mouse handlers
|
||||
const handleMouseDown = useCallback((e: React.MouseEvent<HTMLCanvasElement>) => {
|
||||
const rect = canvasRef.current?.getBoundingClientRect()
|
||||
if (!rect) return
|
||||
|
||||
const x = e.clientX - rect.left
|
||||
const y = e.clientY - rect.top
|
||||
const time = xToTime(x)
|
||||
|
||||
// Time bar click
|
||||
if (y < TIME_BAR_HEIGHT) {
|
||||
onTimeBarClick(Math.max(0, time))
|
||||
return
|
||||
}
|
||||
|
||||
const clickedWord = findWordAtPosition(x, y)
|
||||
|
||||
if (clickedWord && selectedWordIds.has(clickedWord.id)) {
|
||||
// Check if clicking on resize handle
|
||||
if (isNearResizeHandlePos(clickedWord, x, y)) {
|
||||
// Start resize
|
||||
setDragMode('resize')
|
||||
dragStartRef.current = { x, y, time }
|
||||
dragWordIdRef.current = clickedWord.id
|
||||
dragOriginalTimesRef.current = new Map([[clickedWord.id, {
|
||||
start: clickedWord.start_time!,
|
||||
end: clickedWord.end_time!
|
||||
}]])
|
||||
return
|
||||
}
|
||||
|
||||
// Start move (for all selected words)
|
||||
setDragMode('move')
|
||||
dragStartRef.current = { x, y, time }
|
||||
dragWordIdRef.current = clickedWord.id
|
||||
|
||||
// Store original times for all selected words
|
||||
const originalTimes = new Map<string, { start: number; end: number }>()
|
||||
for (const wordId of selectedWordIds) {
|
||||
const word = words.find(w => w.id === wordId)
|
||||
if (word && word.start_time !== null && word.end_time !== null) {
|
||||
originalTimes.set(wordId, { start: word.start_time, end: word.end_time })
|
||||
}
|
||||
}
|
||||
dragOriginalTimesRef.current = originalTimes
|
||||
return
|
||||
}
|
||||
|
||||
if (clickedWord) {
|
||||
// Click on unselected word - select it
|
||||
onWordClick(clickedWord.id, e)
|
||||
return
|
||||
}
|
||||
|
||||
// Background - start selection
|
||||
setDragMode('selection')
|
||||
dragStartRef.current = { x, y, time }
|
||||
setSelectionRect({ startX: x, startY: y, endX: x, endY: y })
|
||||
}, [xToTime, onTimeBarClick, findWordAtPosition, selectedWordIds, isNearResizeHandlePos, onWordClick, words])
|
||||
|
||||
const handleMouseMove = useCallback((e: React.MouseEvent<HTMLCanvasElement>) => {
|
||||
const rect = canvasRef.current?.getBoundingClientRect()
|
||||
if (!rect) return
|
||||
|
||||
const x = e.clientX - rect.left
|
||||
const y = e.clientY - rect.top
|
||||
const time = xToTime(x)
|
||||
|
||||
// Update hover state and cursor
|
||||
if (dragMode === 'none') {
|
||||
const hoveredWord = findWordAtPosition(x, y)
|
||||
setHoveredWordId(hoveredWord?.id || null)
|
||||
|
||||
if (hoveredWord && selectedWordIds.has(hoveredWord.id)) {
|
||||
const nearHandle = isNearResizeHandlePos(hoveredWord, x, y)
|
||||
setCursorStyle(nearHandle ? 'ew-resize' : 'grab')
|
||||
} else if (hoveredWord) {
|
||||
setCursorStyle('pointer')
|
||||
} else if (y < TIME_BAR_HEIGHT) {
|
||||
setCursorStyle('pointer')
|
||||
} else {
|
||||
setCursorStyle('default')
|
||||
}
|
||||
}
|
||||
|
||||
if (!dragStartRef.current) return
|
||||
|
||||
if (dragMode === 'selection') {
|
||||
setSelectionRect({
|
||||
startX: dragStartRef.current.x,
|
||||
startY: dragStartRef.current.y,
|
||||
endX: x,
|
||||
endY: y
|
||||
})
|
||||
} else if (dragMode === 'resize' && dragWordIdRef.current) {
|
||||
// Resize the word
|
||||
const originalTimes = dragOriginalTimesRef.current.get(dragWordIdRef.current)
|
||||
if (originalTimes) {
|
||||
const deltaTime = time - dragStartRef.current.time
|
||||
const newEndTime = Math.max(originalTimes.start + 0.05, originalTimes.end + deltaTime)
|
||||
onWordTimingChange(dragWordIdRef.current, originalTimes.start, newEndTime)
|
||||
}
|
||||
setCursorStyle('ew-resize')
|
||||
} else if (dragMode === 'move') {
|
||||
// Move all selected words
|
||||
const deltaTime = time - dragStartRef.current.time
|
||||
const updates: Array<{ wordId: string; newStartTime: number; newEndTime: number }> = []
|
||||
|
||||
for (const [wordId, originalTimes] of dragOriginalTimesRef.current) {
|
||||
// Ensure end time is always after start time (at least 0.05s duration)
|
||||
const newStartTime = Math.max(0, originalTimes.start + deltaTime)
|
||||
const newEndTime = Math.max(newStartTime + 0.05, originalTimes.end + deltaTime)
|
||||
updates.push({
|
||||
wordId,
|
||||
newStartTime,
|
||||
newEndTime
|
||||
})
|
||||
}
|
||||
|
||||
if (updates.length > 0) {
|
||||
onWordsMove(updates)
|
||||
}
|
||||
setCursorStyle('grabbing')
|
||||
}
|
||||
}, [dragMode, xToTime, findWordAtPosition, selectedWordIds, isNearResizeHandlePos, onWordTimingChange, onWordsMove])
|
||||
|
||||
const handleMouseUp = useCallback((e: React.MouseEvent<HTMLCanvasElement>) => {
|
||||
const rect = canvasRef.current?.getBoundingClientRect()
|
||||
|
||||
if (dragMode === 'selection' && dragStartRef.current && rect) {
|
||||
const endX = e.clientX - rect.left
|
||||
const endY = e.clientY - rect.top
|
||||
|
||||
const dragDistance = Math.sqrt(
|
||||
Math.pow(endX - dragStartRef.current.x, 2) +
|
||||
Math.pow(endY - dragStartRef.current.y, 2)
|
||||
)
|
||||
|
||||
if (dragDistance < 5) {
|
||||
onBackgroundClick()
|
||||
} else {
|
||||
const finalRect = {
|
||||
startX: dragStartRef.current.x,
|
||||
startY: dragStartRef.current.y,
|
||||
endX,
|
||||
endY
|
||||
}
|
||||
const selectedIds = findWordsInRect(finalRect)
|
||||
if (selectedIds.length > 0) {
|
||||
onSelectionComplete(selectedIds)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Reset drag state
|
||||
setDragMode('none')
|
||||
dragStartRef.current = null
|
||||
dragWordIdRef.current = null
|
||||
dragOriginalTimesRef.current = new Map()
|
||||
setSelectionRect(null)
|
||||
setCursorStyle('default')
|
||||
}, [dragMode, onBackgroundClick, findWordsInRect, onSelectionComplete])
|
||||
|
||||
// Wheel handler
|
||||
const handleWheel = useCallback((e: React.WheelEvent<HTMLCanvasElement>) => {
|
||||
const delta = e.deltaX !== 0 ? e.deltaX : e.deltaY
|
||||
const scrollAmount = (delta / 100) * (zoomSeconds / 4)
|
||||
let newStart = Math.max(0, Math.min(audioDuration - zoomSeconds, visibleStartTime + scrollAmount))
|
||||
|
||||
if (newStart !== visibleStartTime) {
|
||||
onScrollChange(newStart)
|
||||
}
|
||||
}, [visibleStartTime, zoomSeconds, audioDuration, onScrollChange])
|
||||
|
||||
const handleScrollLeft = useCallback(() => {
|
||||
const newStart = Math.max(0, visibleStartTime - zoomSeconds * 0.25)
|
||||
onScrollChange(newStart)
|
||||
}, [visibleStartTime, zoomSeconds, onScrollChange])
|
||||
|
||||
const handleScrollRight = useCallback(() => {
|
||||
const newStart = Math.min(audioDuration - zoomSeconds, visibleStartTime + zoomSeconds * 0.25)
|
||||
onScrollChange(Math.max(0, newStart))
|
||||
}, [visibleStartTime, zoomSeconds, audioDuration, onScrollChange])
|
||||
|
||||
return (
|
||||
<Box sx={{ display: 'flex', flexDirection: 'column', gap: 0.5 }}>
|
||||
<Box sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>
|
||||
<Tooltip title="Scroll Left">
|
||||
<IconButton
|
||||
size="small"
|
||||
onClick={handleScrollLeft}
|
||||
disabled={visibleStartTime <= 0}
|
||||
>
|
||||
<ArrowBackIcon fontSize="small" />
|
||||
</IconButton>
|
||||
</Tooltip>
|
||||
|
||||
<Box
|
||||
ref={containerRef}
|
||||
sx={{
|
||||
flexGrow: 1,
|
||||
height,
|
||||
cursor: cursorStyle,
|
||||
borderRadius: 1,
|
||||
overflow: 'hidden'
|
||||
}}
|
||||
>
|
||||
<canvas
|
||||
ref={canvasRef}
|
||||
style={{
|
||||
width: '100%',
|
||||
height: '100%',
|
||||
display: 'block',
|
||||
cursor: cursorStyle
|
||||
}}
|
||||
onMouseDown={handleMouseDown}
|
||||
onMouseMove={handleMouseMove}
|
||||
onMouseUp={handleMouseUp}
|
||||
onMouseLeave={handleMouseUp}
|
||||
onWheel={handleWheel}
|
||||
/>
|
||||
</Box>
|
||||
|
||||
<Tooltip title="Scroll Right">
|
||||
<IconButton
|
||||
size="small"
|
||||
onClick={handleScrollRight}
|
||||
disabled={visibleStartTime >= audioDuration - zoomSeconds}
|
||||
>
|
||||
<ArrowForwardIcon fontSize="small" />
|
||||
</IconButton>
|
||||
</Tooltip>
|
||||
</Box>
|
||||
</Box>
|
||||
)
|
||||
})
|
||||
|
||||
export default TimelineCanvas
|
||||
@@ -0,0 +1,80 @@
|
||||
import { memo, useMemo } from 'react'
|
||||
import { Box, Typography } from '@mui/material'
|
||||
import { Word } from '../../types'
|
||||
|
||||
interface UpcomingWordsBarProps {
|
||||
words: Word[]
|
||||
syncWordIndex: number
|
||||
isManualSyncing: boolean
|
||||
maxWordsToShow?: number
|
||||
}
|
||||
|
||||
const UpcomingWordsBar = memo(function UpcomingWordsBar({
|
||||
words,
|
||||
syncWordIndex,
|
||||
isManualSyncing,
|
||||
maxWordsToShow = 20
|
||||
}: UpcomingWordsBarProps) {
|
||||
// Get upcoming unsynced words
|
||||
const upcomingWords = useMemo(() => {
|
||||
if (!isManualSyncing || syncWordIndex < 0) return []
|
||||
|
||||
return words
|
||||
.slice(syncWordIndex)
|
||||
.filter(w => w.start_time === null)
|
||||
.slice(0, maxWordsToShow)
|
||||
}, [words, syncWordIndex, isManualSyncing, maxWordsToShow])
|
||||
|
||||
const totalRemaining = useMemo(() => {
|
||||
if (!isManualSyncing || syncWordIndex < 0) return 0
|
||||
return words.slice(syncWordIndex).filter(w => w.start_time === null).length
|
||||
}, [words, syncWordIndex, isManualSyncing])
|
||||
|
||||
// Show empty placeholder when no upcoming words
|
||||
if (upcomingWords.length === 0) {
|
||||
return null
|
||||
}
|
||||
|
||||
return (
|
||||
<Box sx={{
|
||||
height: 44,
|
||||
bgcolor: 'grey.100',
|
||||
borderRadius: 1,
|
||||
display: 'flex',
|
||||
alignItems: 'center',
|
||||
px: 1,
|
||||
gap: 0.5,
|
||||
overflow: 'hidden',
|
||||
boxSizing: 'border-box'
|
||||
}}>
|
||||
{upcomingWords.map((word, index) => (
|
||||
<Box
|
||||
key={word.id}
|
||||
sx={{
|
||||
px: 1,
|
||||
py: 0.5,
|
||||
borderRadius: 0.5,
|
||||
bgcolor: index === 0 ? 'error.main' : 'grey.300',
|
||||
color: index === 0 ? 'white' : 'text.primary',
|
||||
fontWeight: index === 0 ? 'bold' : 'normal',
|
||||
fontSize: '13px',
|
||||
fontFamily: 'system-ui, -apple-system, sans-serif',
|
||||
whiteSpace: 'nowrap',
|
||||
border: index === 0 ? '2px solid' : 'none',
|
||||
borderColor: 'error.dark'
|
||||
}}
|
||||
>
|
||||
{word.text}
|
||||
</Box>
|
||||
))}
|
||||
|
||||
{totalRemaining > maxWordsToShow && (
|
||||
<Typography variant="caption" color="text.secondary" sx={{ ml: 1 }}>
|
||||
+{totalRemaining - maxWordsToShow} more
|
||||
</Typography>
|
||||
)}
|
||||
</Box>
|
||||
)
|
||||
})
|
||||
|
||||
export default UpcomingWordsBar
|
||||
@@ -0,0 +1,905 @@
|
||||
import { useState, useCallback, useEffect, useRef, useMemo, memo } from 'react'
|
||||
import {
|
||||
Box,
|
||||
Typography,
|
||||
Slider,
|
||||
Dialog,
|
||||
DialogTitle,
|
||||
DialogContent,
|
||||
DialogActions,
|
||||
TextField,
|
||||
Button,
|
||||
Paper,
|
||||
Alert
|
||||
} from '@mui/material'
|
||||
import ZoomInIcon from '@mui/icons-material/ZoomIn'
|
||||
import ZoomOutIcon from '@mui/icons-material/ZoomOut'
|
||||
import { Word, LyricsSegment } from '../../types'
|
||||
import TimelineCanvas from './TimelineCanvas'
|
||||
import UpcomingWordsBar from './UpcomingWordsBar'
|
||||
import SyncControls from './SyncControls'
|
||||
|
||||
// Augment window type for audio functions
|
||||
declare global {
|
||||
interface Window {
|
||||
getAudioDuration?: () => number
|
||||
toggleAudioPlayback?: () => void
|
||||
isAudioPlaying?: boolean
|
||||
}
|
||||
}
|
||||
|
||||
interface LyricsSynchronizerProps {
|
||||
segments: LyricsSegment[]
|
||||
currentTime: number
|
||||
onPlaySegment?: (startTime: number) => void
|
||||
onSave: (segments: LyricsSegment[]) => void
|
||||
onCancel: () => void
|
||||
setModalSpacebarHandler: (handler: (() => (e: KeyboardEvent) => void) | undefined) => void
|
||||
}
|
||||
|
||||
// Constants for zoom
|
||||
const MIN_ZOOM_SECONDS = 4.5 // Most zoomed in - 4.5 seconds visible
|
||||
const MAX_ZOOM_SECONDS = 24 // Most zoomed out - 24 seconds visible
|
||||
const ZOOM_STEPS = 50 // Number of zoom levels
|
||||
|
||||
// Get all words from segments
|
||||
function getAllWords(segments: LyricsSegment[]): Word[] {
|
||||
return segments.flatMap(s => s.words)
|
||||
}
|
||||
|
||||
// Deep clone segments
|
||||
function cloneSegments(segments: LyricsSegment[]): LyricsSegment[] {
|
||||
return JSON.parse(JSON.stringify(segments))
|
||||
}
|
||||
|
||||
const LyricsSynchronizer = memo(function LyricsSynchronizer({
|
||||
segments: initialSegments,
|
||||
currentTime,
|
||||
onPlaySegment,
|
||||
onSave,
|
||||
onCancel,
|
||||
setModalSpacebarHandler
|
||||
}: LyricsSynchronizerProps) {
|
||||
// Working copy of segments
|
||||
const [workingSegments, setWorkingSegments] = useState<LyricsSegment[]>(() =>
|
||||
cloneSegments(initialSegments)
|
||||
)
|
||||
|
||||
// Get all words flattened
|
||||
const allWords = useMemo(() => getAllWords(workingSegments), [workingSegments])
|
||||
|
||||
// Audio duration
|
||||
const audioDuration = useMemo(() => {
|
||||
if (typeof window.getAudioDuration === 'function') {
|
||||
const duration = window.getAudioDuration()
|
||||
return duration > 0 ? duration : 300
|
||||
}
|
||||
return 300 // 5 minute fallback
|
||||
}, [])
|
||||
|
||||
// Zoom state (value is the visible time window in seconds)
|
||||
const [zoomSeconds, setZoomSeconds] = useState(12) // Default ~12 seconds visible
|
||||
|
||||
// Visible time range
|
||||
const [visibleStartTime, setVisibleStartTime] = useState(0)
|
||||
const visibleEndTime = useMemo(() =>
|
||||
Math.min(visibleStartTime + zoomSeconds, audioDuration),
|
||||
[visibleStartTime, zoomSeconds, audioDuration]
|
||||
)
|
||||
|
||||
// Manual sync state
|
||||
const [isManualSyncing, setIsManualSyncing] = useState(false)
|
||||
const [isPaused, setIsPaused] = useState(false)
|
||||
const [syncWordIndex, setSyncWordIndex] = useState(-1)
|
||||
const [isSpacebarPressed, setIsSpacebarPressed] = useState(false)
|
||||
const wordStartTimeRef = useRef<number | null>(null)
|
||||
const spacebarPressTimeRef = useRef<number | null>(null)
|
||||
const currentTimeRef = useRef(currentTime)
|
||||
|
||||
// Selection state
|
||||
const [selectedWordIds, setSelectedWordIds] = useState<Set<string>>(new Set())
|
||||
|
||||
// Edit lyrics modal state
|
||||
const [showEditLyricsModal, setShowEditLyricsModal] = useState(false)
|
||||
const [editLyricsText, setEditLyricsText] = useState('')
|
||||
|
||||
// Edit word modal state
|
||||
const [showEditWordModal, setShowEditWordModal] = useState(false)
|
||||
const [editWordText, setEditWordText] = useState('')
|
||||
const [editWordId, setEditWordId] = useState<string | null>(null)
|
||||
|
||||
// Keep currentTimeRef up to date
|
||||
useEffect(() => {
|
||||
currentTimeRef.current = currentTime
|
||||
}, [currentTime])
|
||||
|
||||
// Auto-scroll to follow playhead during sync
|
||||
useEffect(() => {
|
||||
if (isManualSyncing && !isPaused && currentTime > 0) {
|
||||
// If playhead is near the end of visible area, scroll forward
|
||||
if (currentTime > visibleEndTime - (zoomSeconds * 0.1)) {
|
||||
const newStart = Math.max(0, currentTime - zoomSeconds * 0.1)
|
||||
setVisibleStartTime(newStart)
|
||||
}
|
||||
// If playhead is before visible area, scroll back
|
||||
else if (currentTime < visibleStartTime) {
|
||||
setVisibleStartTime(Math.max(0, currentTime - 1))
|
||||
}
|
||||
}
|
||||
}, [currentTime, isManualSyncing, isPaused, visibleStartTime, visibleEndTime, zoomSeconds])
|
||||
|
||||
// Handle zoom slider change
|
||||
const handleZoomChange = useCallback((_: Event, value: number | number[]) => {
|
||||
const zoomValue = value as number
|
||||
// Map slider value (0-50) to zoom range (4.5-24 seconds)
|
||||
const newZoomSeconds = MIN_ZOOM_SECONDS + (zoomValue / ZOOM_STEPS) * (MAX_ZOOM_SECONDS - MIN_ZOOM_SECONDS)
|
||||
setZoomSeconds(newZoomSeconds)
|
||||
}, [])
|
||||
|
||||
// Get slider value from zoom seconds
|
||||
const sliderValue = useMemo(() => {
|
||||
return ((zoomSeconds - MIN_ZOOM_SECONDS) / (MAX_ZOOM_SECONDS - MIN_ZOOM_SECONDS)) * ZOOM_STEPS
|
||||
}, [zoomSeconds])
|
||||
|
||||
// Handle scroll change from timeline
|
||||
const handleScrollChange = useCallback((newStartTime: number) => {
|
||||
setVisibleStartTime(newStartTime)
|
||||
}, [])
|
||||
|
||||
// Update words in segments
|
||||
const updateWords = useCallback((newWords: Word[]) => {
|
||||
setWorkingSegments(prevSegments => {
|
||||
const newSegments = cloneSegments(prevSegments)
|
||||
|
||||
// Create a map of word id to word for quick lookup
|
||||
const wordMap = new Map(newWords.map(w => [w.id, w]))
|
||||
|
||||
// Update each segment's words
|
||||
for (const segment of newSegments) {
|
||||
segment.words = segment.words.map(w => wordMap.get(w.id) || w)
|
||||
|
||||
// Recalculate segment timing
|
||||
const timedWords = segment.words.filter(w =>
|
||||
w.start_time !== null && w.end_time !== null
|
||||
)
|
||||
|
||||
if (timedWords.length > 0) {
|
||||
segment.start_time = Math.min(...timedWords.map(w => w.start_time!))
|
||||
segment.end_time = Math.max(...timedWords.map(w => w.end_time!))
|
||||
} else {
|
||||
segment.start_time = null
|
||||
segment.end_time = null
|
||||
}
|
||||
}
|
||||
|
||||
return newSegments
|
||||
})
|
||||
}, [])
|
||||
|
||||
// Check if audio is playing
|
||||
const [isPlaying, setIsPlaying] = useState(false)
|
||||
|
||||
// Update isPlaying state periodically
|
||||
useEffect(() => {
|
||||
const checkPlaying = () => {
|
||||
setIsPlaying(typeof window.isAudioPlaying === 'boolean' ? window.isAudioPlaying : false)
|
||||
}
|
||||
checkPlaying()
|
||||
const interval = setInterval(checkPlaying, 100)
|
||||
return () => clearInterval(interval)
|
||||
}, [])
|
||||
|
||||
// Play audio from current position
|
||||
const handlePlayAudio = useCallback(() => {
|
||||
if (onPlaySegment) {
|
||||
onPlaySegment(currentTimeRef.current)
|
||||
}
|
||||
}, [onPlaySegment])
|
||||
|
||||
// Stop audio playback - also exits sync mode
|
||||
const handleStopAudio = useCallback(() => {
|
||||
if (typeof window.toggleAudioPlayback === 'function' && window.isAudioPlaying) {
|
||||
window.toggleAudioPlayback()
|
||||
}
|
||||
// Also exit sync mode when stopping
|
||||
if (isManualSyncing) {
|
||||
setIsManualSyncing(false)
|
||||
setIsPaused(false)
|
||||
setIsSpacebarPressed(false)
|
||||
}
|
||||
}, [isManualSyncing])
|
||||
|
||||
// Start manual sync
|
||||
const handleStartSync = useCallback(() => {
|
||||
if (isManualSyncing) {
|
||||
// Stop sync
|
||||
setIsManualSyncing(false)
|
||||
setIsPaused(false)
|
||||
setSyncWordIndex(-1)
|
||||
setIsSpacebarPressed(false)
|
||||
|
||||
// Stop audio
|
||||
handleStopAudio()
|
||||
return
|
||||
}
|
||||
|
||||
// Find first unsynced word
|
||||
const firstUnsyncedIndex = allWords.findIndex(w =>
|
||||
w.start_time === null || w.end_time === null
|
||||
)
|
||||
|
||||
const startIndex = firstUnsyncedIndex !== -1 ? firstUnsyncedIndex : 0
|
||||
|
||||
setIsManualSyncing(true)
|
||||
setIsPaused(false)
|
||||
setSyncWordIndex(startIndex)
|
||||
setIsSpacebarPressed(false)
|
||||
|
||||
// Start playback
|
||||
if (onPlaySegment) {
|
||||
onPlaySegment(Math.max(0, currentTimeRef.current - 1))
|
||||
}
|
||||
}, [isManualSyncing, allWords, onPlaySegment, handleStopAudio])
|
||||
|
||||
// Pause sync
|
||||
const handlePauseSync = useCallback(() => {
|
||||
setIsPaused(true)
|
||||
handleStopAudio()
|
||||
}, [handleStopAudio])
|
||||
|
||||
// Resume sync
|
||||
const handleResumeSync = useCallback(() => {
|
||||
setIsPaused(false)
|
||||
|
||||
// Find first unsynced word from current position
|
||||
const firstUnsyncedIndex = allWords.findIndex(w =>
|
||||
w.start_time === null || w.end_time === null
|
||||
)
|
||||
|
||||
if (firstUnsyncedIndex !== -1 && firstUnsyncedIndex !== syncWordIndex) {
|
||||
setSyncWordIndex(firstUnsyncedIndex)
|
||||
}
|
||||
|
||||
// Resume playback
|
||||
if (onPlaySegment) {
|
||||
onPlaySegment(currentTimeRef.current)
|
||||
}
|
||||
}, [allWords, syncWordIndex, onPlaySegment])
|
||||
|
||||
// Clear all sync data
|
||||
const handleClearSync = useCallback(() => {
|
||||
setWorkingSegments(prevSegments => {
|
||||
const newSegments = cloneSegments(prevSegments)
|
||||
|
||||
for (const segment of newSegments) {
|
||||
for (const word of segment.words) {
|
||||
word.start_time = null
|
||||
word.end_time = null
|
||||
}
|
||||
segment.start_time = null
|
||||
segment.end_time = null
|
||||
}
|
||||
|
||||
return newSegments
|
||||
})
|
||||
|
||||
setSyncWordIndex(-1)
|
||||
}, [])
|
||||
|
||||
// Unsync from cursor position
|
||||
const handleUnsyncFromCursor = useCallback(() => {
|
||||
const cursorTime = currentTimeRef.current
|
||||
|
||||
setWorkingSegments(prevSegments => {
|
||||
const newSegments = cloneSegments(prevSegments)
|
||||
|
||||
for (const segment of newSegments) {
|
||||
for (const word of segment.words) {
|
||||
// Reset words that start after cursor position
|
||||
if (word.start_time !== null && word.start_time > cursorTime) {
|
||||
word.start_time = null
|
||||
word.end_time = null
|
||||
}
|
||||
}
|
||||
|
||||
// Recalculate segment timing
|
||||
const timedWords = segment.words.filter(w =>
|
||||
w.start_time !== null && w.end_time !== null
|
||||
)
|
||||
|
||||
if (timedWords.length > 0) {
|
||||
segment.start_time = Math.min(...timedWords.map(w => w.start_time!))
|
||||
segment.end_time = Math.max(...timedWords.map(w => w.end_time!))
|
||||
} else {
|
||||
segment.start_time = null
|
||||
segment.end_time = null
|
||||
}
|
||||
}
|
||||
|
||||
return newSegments
|
||||
})
|
||||
}, [])
|
||||
|
||||
// Check if there are words after cursor that can be unsynced
|
||||
const canUnsyncFromCursor = useMemo(() => {
|
||||
const cursorTime = currentTimeRef.current
|
||||
return allWords.some(w =>
|
||||
w.start_time !== null && w.start_time > cursorTime
|
||||
)
|
||||
}, [allWords, currentTime])
|
||||
|
||||
// Open edit lyrics modal
|
||||
const handleEditLyrics = useCallback(() => {
|
||||
const text = workingSegments.map(s => s.text).join('\n')
|
||||
setEditLyricsText(text)
|
||||
setShowEditLyricsModal(true)
|
||||
}, [workingSegments])
|
||||
|
||||
// Save edited lyrics (warning: resets timing)
|
||||
const handleSaveEditedLyrics = useCallback(() => {
|
||||
const lines = editLyricsText.split('\n').filter(l => l.trim())
|
||||
|
||||
const newSegments: LyricsSegment[] = lines.map((line, idx) => {
|
||||
const words = line.trim().split(/\s+/).map((text, wIdx) => ({
|
||||
id: `word-${idx}-${wIdx}-${Date.now()}`,
|
||||
text,
|
||||
start_time: null,
|
||||
end_time: null,
|
||||
confidence: 1.0
|
||||
}))
|
||||
|
||||
return {
|
||||
id: `segment-${idx}-${Date.now()}`,
|
||||
text: line.trim(),
|
||||
words,
|
||||
start_time: null,
|
||||
end_time: null
|
||||
}
|
||||
})
|
||||
|
||||
setWorkingSegments(newSegments)
|
||||
setShowEditLyricsModal(false)
|
||||
setSyncWordIndex(-1)
|
||||
}, [editLyricsText])
|
||||
|
||||
// Open edit word modal
|
||||
const handleEditSelectedWord = useCallback(() => {
|
||||
if (selectedWordIds.size !== 1) return
|
||||
|
||||
const wordId = Array.from(selectedWordIds)[0]
|
||||
const word = allWords.find(w => w.id === wordId)
|
||||
|
||||
if (word) {
|
||||
setEditWordId(wordId)
|
||||
setEditWordText(word.text)
|
||||
setShowEditWordModal(true)
|
||||
}
|
||||
}, [selectedWordIds, allWords])
|
||||
|
||||
// Save edited word
|
||||
const handleSaveEditedWord = useCallback(() => {
|
||||
if (!editWordId) return
|
||||
|
||||
const newText = editWordText.trim()
|
||||
if (!newText) return
|
||||
|
||||
// Check if we're splitting into multiple words
|
||||
const newWords = newText.split(/\s+/)
|
||||
|
||||
if (newWords.length === 1) {
|
||||
// Simple rename
|
||||
const updatedWords = allWords.map(w =>
|
||||
w.id === editWordId ? { ...w, text: newWords[0] } : w
|
||||
)
|
||||
updateWords(updatedWords)
|
||||
} else {
|
||||
// Split word - preserve timing for first word, null for rest
|
||||
const originalWord = allWords.find(w => w.id === editWordId)
|
||||
if (!originalWord) return
|
||||
|
||||
setWorkingSegments(prevSegments => {
|
||||
const newSegments = cloneSegments(prevSegments)
|
||||
|
||||
for (const segment of newSegments) {
|
||||
const wordIndex = segment.words.findIndex(w => w.id === editWordId)
|
||||
if (wordIndex !== -1) {
|
||||
const newWordObjects = newWords.map((text, idx) => ({
|
||||
id: idx === 0 ? editWordId : `${editWordId}-split-${idx}`,
|
||||
text,
|
||||
start_time: idx === 0 ? originalWord.start_time : null,
|
||||
end_time: idx === 0 ? originalWord.end_time : null,
|
||||
confidence: 1.0
|
||||
}))
|
||||
|
||||
segment.words.splice(wordIndex, 1, ...newWordObjects)
|
||||
segment.text = segment.words.map(w => w.text).join(' ')
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
return newSegments
|
||||
})
|
||||
}
|
||||
|
||||
setShowEditWordModal(false)
|
||||
setEditWordId(null)
|
||||
setEditWordText('')
|
||||
setSelectedWordIds(new Set())
|
||||
}, [editWordId, editWordText, allWords, updateWords])
|
||||
|
||||
// Delete selected words
|
||||
const handleDeleteSelected = useCallback(() => {
|
||||
if (selectedWordIds.size === 0) return
|
||||
|
||||
setWorkingSegments(prevSegments => {
|
||||
const newSegments = cloneSegments(prevSegments)
|
||||
|
||||
for (const segment of newSegments) {
|
||||
segment.words = segment.words.filter(w => !selectedWordIds.has(w.id))
|
||||
segment.text = segment.words.map(w => w.text).join(' ')
|
||||
|
||||
// Recalculate segment timing
|
||||
const timedWords = segment.words.filter(w =>
|
||||
w.start_time !== null && w.end_time !== null
|
||||
)
|
||||
|
||||
if (timedWords.length > 0) {
|
||||
segment.start_time = Math.min(...timedWords.map(w => w.start_time!))
|
||||
segment.end_time = Math.max(...timedWords.map(w => w.end_time!))
|
||||
} else {
|
||||
segment.start_time = null
|
||||
segment.end_time = null
|
||||
}
|
||||
}
|
||||
|
||||
// Remove empty segments
|
||||
return newSegments.filter(s => s.words.length > 0)
|
||||
})
|
||||
|
||||
setSelectedWordIds(new Set())
|
||||
}, [selectedWordIds])
|
||||
|
||||
// Handle word click (selection)
|
||||
const handleWordClick = useCallback((wordId: string, event: React.MouseEvent) => {
|
||||
if (event.shiftKey || event.ctrlKey || event.metaKey) {
|
||||
// Add to selection
|
||||
setSelectedWordIds(prev => {
|
||||
const newSet = new Set(prev)
|
||||
if (newSet.has(wordId)) {
|
||||
newSet.delete(wordId)
|
||||
} else {
|
||||
newSet.add(wordId)
|
||||
}
|
||||
return newSet
|
||||
})
|
||||
} else {
|
||||
// Single selection
|
||||
setSelectedWordIds(new Set([wordId]))
|
||||
}
|
||||
}, [])
|
||||
|
||||
// Handle background click (deselect)
|
||||
const handleBackgroundClick = useCallback(() => {
|
||||
setSelectedWordIds(new Set())
|
||||
}, [])
|
||||
|
||||
// Handle single word timing change (from resize)
|
||||
const handleWordTimingChange = useCallback((wordId: string, newStartTime: number, newEndTime: number) => {
|
||||
setWorkingSegments(prevSegments => {
|
||||
const newSegments = cloneSegments(prevSegments)
|
||||
|
||||
for (const segment of newSegments) {
|
||||
const word = segment.words.find(w => w.id === wordId)
|
||||
if (word) {
|
||||
word.start_time = Math.max(0, newStartTime)
|
||||
word.end_time = Math.max(word.start_time + 0.05, newEndTime)
|
||||
|
||||
// Recalculate segment timing
|
||||
const timedWords = segment.words.filter(w =>
|
||||
w.start_time !== null && w.end_time !== null
|
||||
)
|
||||
if (timedWords.length > 0) {
|
||||
segment.start_time = Math.min(...timedWords.map(w => w.start_time!))
|
||||
segment.end_time = Math.max(...timedWords.map(w => w.end_time!))
|
||||
}
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
return newSegments
|
||||
})
|
||||
}, [])
|
||||
|
||||
// Handle moving multiple words (from drag)
|
||||
const handleWordsMove = useCallback((updates: Array<{ wordId: string; newStartTime: number; newEndTime: number }>) => {
|
||||
setWorkingSegments(prevSegments => {
|
||||
const newSegments = cloneSegments(prevSegments)
|
||||
|
||||
// Create a map for quick lookup
|
||||
const updateMap = new Map(updates.map(u => [u.wordId, u]))
|
||||
|
||||
for (const segment of newSegments) {
|
||||
for (const word of segment.words) {
|
||||
const update = updateMap.get(word.id)
|
||||
if (update) {
|
||||
word.start_time = update.newStartTime
|
||||
word.end_time = update.newEndTime
|
||||
}
|
||||
}
|
||||
|
||||
// Recalculate segment timing
|
||||
const timedWords = segment.words.filter(w =>
|
||||
w.start_time !== null && w.end_time !== null
|
||||
)
|
||||
if (timedWords.length > 0) {
|
||||
segment.start_time = Math.min(...timedWords.map(w => w.start_time!))
|
||||
segment.end_time = Math.max(...timedWords.map(w => w.end_time!))
|
||||
}
|
||||
}
|
||||
|
||||
return newSegments
|
||||
})
|
||||
}, [])
|
||||
|
||||
// Handle time bar click (seek to position without playing)
|
||||
const handleTimeBarClick = useCallback((time: number) => {
|
||||
// Scroll the timeline to show this time centered
|
||||
const newStart = Math.max(0, time - zoomSeconds / 2)
|
||||
setVisibleStartTime(Math.min(newStart, Math.max(0, audioDuration - zoomSeconds)))
|
||||
|
||||
// Seek to the position (this will briefly start playback)
|
||||
if (onPlaySegment) {
|
||||
onPlaySegment(time)
|
||||
// Immediately stop playback after seeking
|
||||
setTimeout(() => {
|
||||
if (typeof window.toggleAudioPlayback === 'function' && window.isAudioPlaying) {
|
||||
window.toggleAudioPlayback()
|
||||
}
|
||||
}, 50)
|
||||
}
|
||||
}, [zoomSeconds, audioDuration, onPlaySegment])
|
||||
|
||||
// Handle selection complete from drag
|
||||
const handleSelectionComplete = useCallback((wordIds: string[]) => {
|
||||
setSelectedWordIds(new Set(wordIds))
|
||||
}, [])
|
||||
|
||||
// Handle spacebar for manual sync
|
||||
const handleKeyDown = useCallback((e: KeyboardEvent) => {
|
||||
if (e.code !== 'Space') return
|
||||
if (!isManualSyncing || isPaused) return
|
||||
if (syncWordIndex < 0 || syncWordIndex >= allWords.length) return
|
||||
|
||||
e.preventDefault()
|
||||
e.stopPropagation()
|
||||
|
||||
if (isSpacebarPressed) return
|
||||
|
||||
setIsSpacebarPressed(true)
|
||||
wordStartTimeRef.current = currentTimeRef.current
|
||||
spacebarPressTimeRef.current = Date.now()
|
||||
|
||||
// Set start time for current word
|
||||
const newWords = [...allWords]
|
||||
const currentWord = newWords[syncWordIndex]
|
||||
currentWord.start_time = currentTimeRef.current
|
||||
|
||||
// Handle previous word's end time
|
||||
if (syncWordIndex > 0) {
|
||||
const prevWord = newWords[syncWordIndex - 1]
|
||||
if (prevWord.start_time !== null && prevWord.end_time === null) {
|
||||
const gap = currentTimeRef.current - prevWord.start_time
|
||||
if (gap > 1.0) {
|
||||
prevWord.end_time = prevWord.start_time + 0.5
|
||||
} else {
|
||||
prevWord.end_time = currentTimeRef.current - 0.005
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
updateWords(newWords)
|
||||
}, [isManualSyncing, isPaused, syncWordIndex, allWords, isSpacebarPressed, updateWords])
|
||||
|
||||
const handleKeyUp = useCallback((e: KeyboardEvent) => {
|
||||
if (e.code !== 'Space') return
|
||||
if (!isManualSyncing || isPaused) return
|
||||
if (!isSpacebarPressed) return
|
||||
|
||||
e.preventDefault()
|
||||
e.stopPropagation()
|
||||
|
||||
setIsSpacebarPressed(false)
|
||||
|
||||
const pressDuration = spacebarPressTimeRef.current
|
||||
? Date.now() - spacebarPressTimeRef.current
|
||||
: 0
|
||||
const isTap = pressDuration < 200 // 200ms threshold
|
||||
|
||||
const newWords = [...allWords]
|
||||
const currentWord = newWords[syncWordIndex]
|
||||
|
||||
if (isTap) {
|
||||
// Short tap: default 500ms duration
|
||||
currentWord.end_time = (wordStartTimeRef.current || currentTimeRef.current) + 0.5
|
||||
} else {
|
||||
// Hold: use actual timing
|
||||
currentWord.end_time = currentTimeRef.current
|
||||
}
|
||||
|
||||
updateWords(newWords)
|
||||
|
||||
// Move to next word
|
||||
if (syncWordIndex < allWords.length - 1) {
|
||||
setSyncWordIndex(syncWordIndex + 1)
|
||||
} else {
|
||||
// All words synced
|
||||
setIsManualSyncing(false)
|
||||
setSyncWordIndex(-1)
|
||||
handleStopAudio()
|
||||
}
|
||||
|
||||
wordStartTimeRef.current = null
|
||||
spacebarPressTimeRef.current = null
|
||||
}, [isManualSyncing, isPaused, isSpacebarPressed, syncWordIndex, allWords, updateWords, handleStopAudio])
|
||||
|
||||
// Combined spacebar handler
|
||||
const handleSpacebar = useCallback((e: KeyboardEvent) => {
|
||||
if (e.type === 'keydown') {
|
||||
handleKeyDown(e)
|
||||
} else if (e.type === 'keyup') {
|
||||
handleKeyUp(e)
|
||||
}
|
||||
}, [handleKeyDown, handleKeyUp])
|
||||
|
||||
// Keep ref for handler
|
||||
const spacebarHandlerRef = useRef(handleSpacebar)
|
||||
spacebarHandlerRef.current = handleSpacebar
|
||||
|
||||
// Set up spacebar handler
|
||||
useEffect(() => {
|
||||
const handler = (e: KeyboardEvent) => {
|
||||
if (e.code === 'Space') {
|
||||
e.preventDefault()
|
||||
e.stopPropagation()
|
||||
spacebarHandlerRef.current(e)
|
||||
}
|
||||
}
|
||||
|
||||
setModalSpacebarHandler(() => handler)
|
||||
|
||||
return () => {
|
||||
setModalSpacebarHandler(undefined)
|
||||
}
|
||||
}, [setModalSpacebarHandler])
|
||||
|
||||
// Handle save
|
||||
const handleSave = useCallback(() => {
|
||||
onSave(workingSegments)
|
||||
}, [workingSegments, onSave])
|
||||
|
||||
// Progress stats
|
||||
const stats = useMemo(() => {
|
||||
const total = allWords.length
|
||||
const synced = allWords.filter(w =>
|
||||
w.start_time !== null && w.end_time !== null
|
||||
).length
|
||||
return { total, synced, remaining: total - synced }
|
||||
}, [allWords])
|
||||
|
||||
// Get instruction text based on state
|
||||
const getInstructionText = useCallback(() => {
|
||||
if (isManualSyncing) {
|
||||
if (isSpacebarPressed) {
|
||||
// Always include secondary text to prevent layout shift
|
||||
return { primary: '⏱️ Holding... release when word ends', secondary: 'Release spacebar when the word finishes' }
|
||||
}
|
||||
if (stats.remaining === 0) {
|
||||
return { primary: '✅ All words synced!', secondary: 'Click "Stop Sync" then "Apply" to save' }
|
||||
}
|
||||
return { primary: '👆 Press SPACEBAR when you hear each word', secondary: 'Tap for short words, hold for longer words' }
|
||||
}
|
||||
if (stats.synced === 0) {
|
||||
return { primary: 'Click "Start Sync" to begin timing words', secondary: 'Audio will play and you\'ll tap spacebar for each word' }
|
||||
}
|
||||
if (stats.remaining > 0) {
|
||||
return { primary: `${stats.remaining} words remaining to sync`, secondary: 'Click "Start Sync" to continue, or "Unsync from Cursor" to re-sync from a point' }
|
||||
}
|
||||
return { primary: '✅ All words synced!', secondary: 'Click "Apply" to save changes, or make adjustments first' }
|
||||
}, [isManualSyncing, isSpacebarPressed, stats.synced, stats.remaining])
|
||||
|
||||
const instruction = getInstructionText()
|
||||
|
||||
return (
|
||||
<Box sx={{ display: 'flex', flexDirection: 'column', height: '100%', gap: 1 }}>
|
||||
{/* Stats bar - fixed height */}
|
||||
<Box sx={{ display: 'flex', justifyContent: 'flex-end', alignItems: 'center', height: 24 }}>
|
||||
<Typography variant="body2" color="text.secondary">
|
||||
{stats.synced} / {stats.total} words synced
|
||||
{stats.remaining > 0 && ` (${stats.remaining} remaining)`}
|
||||
</Typography>
|
||||
</Box>
|
||||
|
||||
{/* Instruction banner - fixed height to prevent layout shifts */}
|
||||
<Box
|
||||
sx={{
|
||||
height: 56,
|
||||
flexShrink: 0
|
||||
}}
|
||||
>
|
||||
<Paper
|
||||
sx={{
|
||||
p: 1.5,
|
||||
height: '100%',
|
||||
bgcolor: isManualSyncing ? 'info.main' : 'grey.100',
|
||||
color: isManualSyncing ? 'info.contrastText' : 'text.primary',
|
||||
display: 'flex',
|
||||
flexDirection: 'column',
|
||||
justifyContent: 'center',
|
||||
overflow: 'hidden',
|
||||
boxSizing: 'border-box'
|
||||
}}
|
||||
>
|
||||
<Typography variant="body2" sx={{ fontWeight: 500, lineHeight: 1.3 }}>
|
||||
{instruction.primary}
|
||||
</Typography>
|
||||
<Typography variant="caption" sx={{ opacity: 0.85, display: 'block', lineHeight: 1.3 }}>
|
||||
{instruction.secondary}
|
||||
</Typography>
|
||||
</Paper>
|
||||
</Box>
|
||||
|
||||
{/* Controls - fixed height section */}
|
||||
<Box sx={{ height: 88, flexShrink: 0 }}>
|
||||
<SyncControls
|
||||
isManualSyncing={isManualSyncing}
|
||||
isPaused={isPaused}
|
||||
onStartSync={handleStartSync}
|
||||
onPauseSync={handlePauseSync}
|
||||
onResumeSync={handleResumeSync}
|
||||
onClearSync={handleClearSync}
|
||||
onEditLyrics={handleEditLyrics}
|
||||
onPlay={handlePlayAudio}
|
||||
onStop={handleStopAudio}
|
||||
isPlaying={isPlaying}
|
||||
hasSelectedWords={selectedWordIds.size > 0}
|
||||
selectedWordCount={selectedWordIds.size}
|
||||
onUnsyncFromCursor={handleUnsyncFromCursor}
|
||||
onEditSelectedWord={handleEditSelectedWord}
|
||||
onDeleteSelected={handleDeleteSelected}
|
||||
canUnsyncFromCursor={canUnsyncFromCursor}
|
||||
/>
|
||||
</Box>
|
||||
|
||||
{/* Upcoming words bar - fixed height, immediately above timeline */}
|
||||
<Box sx={{ height: 44, flexShrink: 0 }}>
|
||||
{isManualSyncing && (
|
||||
<UpcomingWordsBar
|
||||
words={allWords}
|
||||
syncWordIndex={syncWordIndex}
|
||||
isManualSyncing={isManualSyncing}
|
||||
/>
|
||||
)}
|
||||
</Box>
|
||||
|
||||
{/* Timeline canvas */}
|
||||
<Box sx={{ flexGrow: 1, minHeight: 200 }}>
|
||||
<TimelineCanvas
|
||||
words={allWords}
|
||||
segments={workingSegments}
|
||||
visibleStartTime={visibleStartTime}
|
||||
visibleEndTime={visibleEndTime}
|
||||
currentTime={currentTime}
|
||||
selectedWordIds={selectedWordIds}
|
||||
onWordClick={handleWordClick}
|
||||
onBackgroundClick={handleBackgroundClick}
|
||||
onTimeBarClick={handleTimeBarClick}
|
||||
onSelectionComplete={handleSelectionComplete}
|
||||
onWordTimingChange={handleWordTimingChange}
|
||||
onWordsMove={handleWordsMove}
|
||||
syncWordIndex={syncWordIndex}
|
||||
isManualSyncing={isManualSyncing}
|
||||
onScrollChange={handleScrollChange}
|
||||
audioDuration={audioDuration}
|
||||
zoomSeconds={zoomSeconds}
|
||||
height={200}
|
||||
/>
|
||||
</Box>
|
||||
|
||||
{/* Zoom slider */}
|
||||
<Box sx={{ display: 'flex', alignItems: 'center', gap: 2, px: 2 }}>
|
||||
<ZoomInIcon color="action" fontSize="small" />
|
||||
<Slider
|
||||
value={sliderValue}
|
||||
onChange={handleZoomChange}
|
||||
min={0}
|
||||
max={ZOOM_STEPS}
|
||||
step={1}
|
||||
sx={{ flexGrow: 1 }}
|
||||
disabled={isManualSyncing && !isPaused}
|
||||
/>
|
||||
<ZoomOutIcon color="action" fontSize="small" />
|
||||
<Typography variant="caption" color="text.secondary" sx={{ minWidth: 60 }}>
|
||||
{zoomSeconds.toFixed(1)}s view
|
||||
</Typography>
|
||||
</Box>
|
||||
|
||||
{/* Action buttons */}
|
||||
<Box sx={{ display: 'flex', justifyContent: 'flex-end', gap: 2, pt: 2, borderTop: 1, borderColor: 'divider' }}>
|
||||
<Button onClick={onCancel} color="inherit">
|
||||
Cancel
|
||||
</Button>
|
||||
<Button
|
||||
onClick={handleSave}
|
||||
variant="contained"
|
||||
color="primary"
|
||||
disabled={isManualSyncing && !isPaused}
|
||||
>
|
||||
Apply
|
||||
</Button>
|
||||
</Box>
|
||||
|
||||
{/* Edit Lyrics Modal */}
|
||||
<Dialog
|
||||
open={showEditLyricsModal}
|
||||
onClose={() => setShowEditLyricsModal(false)}
|
||||
maxWidth="md"
|
||||
fullWidth
|
||||
>
|
||||
<DialogTitle>Edit Lyrics</DialogTitle>
|
||||
<DialogContent>
|
||||
<Alert severity="warning" sx={{ mb: 2 }}>
|
||||
Editing lyrics will reset all timing data. You will need to re-sync the entire song.
|
||||
</Alert>
|
||||
<TextField
|
||||
multiline
|
||||
rows={15}
|
||||
fullWidth
|
||||
value={editLyricsText}
|
||||
onChange={(e) => setEditLyricsText(e.target.value)}
|
||||
placeholder="Enter lyrics, one line per segment..."
|
||||
/>
|
||||
</DialogContent>
|
||||
<DialogActions>
|
||||
<Button onClick={() => setShowEditLyricsModal(false)}>Cancel</Button>
|
||||
<Button onClick={handleSaveEditedLyrics} variant="contained" color="warning">
|
||||
Save & Reset Timing
|
||||
</Button>
|
||||
</DialogActions>
|
||||
</Dialog>
|
||||
|
||||
{/* Edit Word Modal */}
|
||||
<Dialog
|
||||
open={showEditWordModal}
|
||||
onClose={() => setShowEditWordModal(false)}
|
||||
maxWidth="xs"
|
||||
fullWidth
|
||||
>
|
||||
<DialogTitle>Edit Word</DialogTitle>
|
||||
<DialogContent>
|
||||
<Typography variant="body2" color="text.secondary" sx={{ mb: 2 }}>
|
||||
Edit the word text. Enter multiple words separated by spaces to split.
|
||||
</Typography>
|
||||
<TextField
|
||||
fullWidth
|
||||
value={editWordText}
|
||||
onChange={(e) => setEditWordText(e.target.value)}
|
||||
autoFocus
|
||||
onKeyDown={(e) => {
|
||||
if (e.key === 'Enter') {
|
||||
handleSaveEditedWord()
|
||||
}
|
||||
}}
|
||||
/>
|
||||
</DialogContent>
|
||||
<DialogActions>
|
||||
<Button onClick={() => setShowEditWordModal(false)}>Cancel</Button>
|
||||
<Button onClick={handleSaveEditedWord} variant="contained">
|
||||
Save
|
||||
</Button>
|
||||
</DialogActions>
|
||||
</Dialog>
|
||||
</Box>
|
||||
)
|
||||
})
|
||||
|
||||
export default LyricsSynchronizer
|
||||
@@ -0,0 +1,127 @@
|
||||
import {
|
||||
Dialog,
|
||||
DialogTitle,
|
||||
DialogContent,
|
||||
DialogActions,
|
||||
IconButton,
|
||||
Box,
|
||||
Button,
|
||||
Typography,
|
||||
Paper
|
||||
} from '@mui/material'
|
||||
import CloseIcon from '@mui/icons-material/Close'
|
||||
import ContentPasteIcon from '@mui/icons-material/ContentPaste'
|
||||
import SyncIcon from '@mui/icons-material/Sync'
|
||||
|
||||
interface ModeSelectionModalProps {
|
||||
open: boolean
|
||||
onClose: () => void
|
||||
onSelectReplace: () => void // Goes to paste phase for replacing all lyrics
|
||||
onSelectResync: () => void // Goes directly to sync view with existing lyrics
|
||||
hasExistingLyrics: boolean // Whether there are existing lyrics to re-sync
|
||||
}
|
||||
|
||||
export default function ModeSelectionModal({
|
||||
open,
|
||||
onClose,
|
||||
onSelectReplace,
|
||||
onSelectResync,
|
||||
hasExistingLyrics
|
||||
}: ModeSelectionModalProps) {
|
||||
return (
|
||||
<Dialog
|
||||
open={open}
|
||||
onClose={onClose}
|
||||
maxWidth="sm"
|
||||
fullWidth
|
||||
>
|
||||
<DialogTitle sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>
|
||||
<Box sx={{ flex: 1 }}>
|
||||
Edit All Lyrics
|
||||
</Box>
|
||||
<IconButton onClick={onClose} sx={{ ml: 'auto' }}>
|
||||
<CloseIcon />
|
||||
</IconButton>
|
||||
</DialogTitle>
|
||||
|
||||
<DialogContent dividers>
|
||||
<Typography variant="body1" sx={{ mb: 3 }}>
|
||||
Choose how you want to edit the lyrics:
|
||||
</Typography>
|
||||
|
||||
<Box sx={{ display: 'flex', flexDirection: 'column', gap: 2 }}>
|
||||
{/* Re-sync Existing option - only show if there are existing lyrics */}
|
||||
{hasExistingLyrics && (
|
||||
<Paper
|
||||
sx={{
|
||||
p: 2,
|
||||
cursor: 'pointer',
|
||||
border: 2,
|
||||
borderColor: 'primary.main',
|
||||
'&:hover': {
|
||||
bgcolor: 'action.hover',
|
||||
borderColor: 'primary.dark'
|
||||
}
|
||||
}}
|
||||
onClick={onSelectResync}
|
||||
>
|
||||
<Box sx={{ display: 'flex', alignItems: 'flex-start', gap: 2 }}>
|
||||
<SyncIcon color="primary" sx={{ fontSize: 40, mt: 0.5 }} />
|
||||
<Box>
|
||||
<Typography variant="h6" color="primary">
|
||||
Re-sync Existing Lyrics
|
||||
</Typography>
|
||||
<Typography variant="body2" color="text.secondary">
|
||||
Keep the current lyrics text and fix timing issues.
|
||||
Use this when lyrics are correct but timing has drifted,
|
||||
especially in the second half of the song.
|
||||
</Typography>
|
||||
<Typography variant="caption" color="success.main" sx={{ mt: 1, display: 'block' }}>
|
||||
Recommended for fixing timing drift
|
||||
</Typography>
|
||||
</Box>
|
||||
</Box>
|
||||
</Paper>
|
||||
)}
|
||||
|
||||
{/* Replace All option */}
|
||||
<Paper
|
||||
sx={{
|
||||
p: 2,
|
||||
cursor: 'pointer',
|
||||
border: 1,
|
||||
borderColor: 'divider',
|
||||
'&:hover': {
|
||||
bgcolor: 'action.hover',
|
||||
borderColor: 'text.secondary'
|
||||
}
|
||||
}}
|
||||
onClick={onSelectReplace}
|
||||
>
|
||||
<Box sx={{ display: 'flex', alignItems: 'flex-start', gap: 2 }}>
|
||||
<ContentPasteIcon sx={{ fontSize: 40, mt: 0.5, color: 'text.secondary' }} />
|
||||
<Box>
|
||||
<Typography variant="h6">
|
||||
Replace All Lyrics
|
||||
</Typography>
|
||||
<Typography variant="body2" color="text.secondary">
|
||||
Paste completely new lyrics from clipboard and manually
|
||||
sync timing for all words from scratch.
|
||||
</Typography>
|
||||
<Typography variant="caption" color="warning.main" sx={{ mt: 1, display: 'block' }}>
|
||||
All existing timing data will be lost
|
||||
</Typography>
|
||||
</Box>
|
||||
</Box>
|
||||
</Paper>
|
||||
</Box>
|
||||
</DialogContent>
|
||||
|
||||
<DialogActions>
|
||||
<Button onClick={onClose} color="inherit">
|
||||
Cancel
|
||||
</Button>
|
||||
</DialogActions>
|
||||
</Dialog>
|
||||
)
|
||||
}
|
||||
@@ -7,19 +7,17 @@ import {
|
||||
Box,
|
||||
Button,
|
||||
Typography,
|
||||
TextField,
|
||||
Paper,
|
||||
Divider
|
||||
TextField
|
||||
} from '@mui/material'
|
||||
import CloseIcon from '@mui/icons-material/Close'
|
||||
import ContentPasteIcon from '@mui/icons-material/ContentPaste'
|
||||
import AutoFixHighIcon from '@mui/icons-material/AutoFixHigh'
|
||||
import ArrowBackIcon from '@mui/icons-material/ArrowBack'
|
||||
import { LyricsSegment, Word } from '../types'
|
||||
import { useState, useEffect, useCallback, useMemo, useRef, memo } from 'react'
|
||||
import { useState, useEffect, useCallback, useMemo } from 'react'
|
||||
import { nanoid } from 'nanoid'
|
||||
import useManualSync from '../hooks/useManualSync'
|
||||
import EditTimelineSection from './EditTimelineSection'
|
||||
import EditActionBar from './EditActionBar'
|
||||
import ModeSelectionModal from './ModeSelectionModal'
|
||||
import LyricsSynchronizer from './LyricsSynchronizer'
|
||||
|
||||
// Augment window type for audio functions
|
||||
declare global {
|
||||
@@ -30,6 +28,8 @@ declare global {
|
||||
}
|
||||
}
|
||||
|
||||
type ModalMode = 'selection' | 'replace' | 'resync'
|
||||
|
||||
interface ReplaceAllLyricsModalProps {
|
||||
open: boolean
|
||||
onClose: () => void
|
||||
@@ -37,6 +37,7 @@ interface ReplaceAllLyricsModalProps {
|
||||
onPlaySegment?: (startTime: number) => void
|
||||
currentTime?: number
|
||||
setModalSpacebarHandler: (handler: (() => (e: KeyboardEvent) => void) | undefined) => void
|
||||
existingSegments?: LyricsSegment[] // Current segments for re-sync mode
|
||||
}
|
||||
|
||||
export default function ReplaceAllLyricsModal({
|
||||
@@ -45,22 +46,21 @@ export default function ReplaceAllLyricsModal({
|
||||
onSave,
|
||||
onPlaySegment,
|
||||
currentTime = 0,
|
||||
setModalSpacebarHandler
|
||||
setModalSpacebarHandler,
|
||||
existingSegments = []
|
||||
}: ReplaceAllLyricsModalProps) {
|
||||
const [mode, setMode] = useState<ModalMode>('selection')
|
||||
const [inputText, setInputText] = useState('')
|
||||
const [isReplaced, setIsReplaced] = useState(false)
|
||||
const [globalSegment, setGlobalSegment] = useState<LyricsSegment | null>(null)
|
||||
const [originalSegments, setOriginalSegments] = useState<LyricsSegment[]>([])
|
||||
const [currentSegments, setCurrentSegments] = useState<LyricsSegment[]>([])
|
||||
const [newSegments, setNewSegments] = useState<LyricsSegment[]>([])
|
||||
|
||||
// Get the real audio duration, with fallback
|
||||
const getAudioDuration = useCallback(() => {
|
||||
if (window.getAudioDuration) {
|
||||
const duration = window.getAudioDuration()
|
||||
return duration > 0 ? duration : 600 // Use real duration or 10 min fallback
|
||||
// Reset state when modal opens
|
||||
useEffect(() => {
|
||||
if (open) {
|
||||
setMode('selection')
|
||||
setInputText('')
|
||||
setNewSegments([])
|
||||
}
|
||||
return 600 // 10 minute fallback if audio not loaded
|
||||
}, [])
|
||||
}, [open])
|
||||
|
||||
// Parse the input text to get line and word counts
|
||||
const parseInfo = useMemo(() => {
|
||||
@@ -79,61 +79,31 @@ export default function ReplaceAllLyricsModal({
|
||||
if (!inputText.trim()) return
|
||||
|
||||
const lines = inputText.trim().split('\n').filter(line => line.trim().length > 0)
|
||||
const newSegments: LyricsSegment[] = []
|
||||
const allWords: Word[] = []
|
||||
const segments: LyricsSegment[] = []
|
||||
|
||||
lines.forEach((line) => {
|
||||
const words = line.trim().split(/\s+/).filter(word => word.length > 0)
|
||||
const segmentWords: Word[] = []
|
||||
const segmentWords: Word[] = words.map((wordText) => ({
|
||||
id: nanoid(),
|
||||
text: wordText,
|
||||
start_time: null,
|
||||
end_time: null,
|
||||
confidence: 1.0,
|
||||
created_during_correction: true
|
||||
}))
|
||||
|
||||
words.forEach((wordText) => {
|
||||
const word: Word = {
|
||||
id: nanoid(),
|
||||
text: wordText,
|
||||
start_time: null,
|
||||
end_time: null,
|
||||
confidence: 1.0,
|
||||
created_during_correction: true
|
||||
}
|
||||
segmentWords.push(word)
|
||||
allWords.push(word)
|
||||
})
|
||||
|
||||
const segment: LyricsSegment = {
|
||||
segments.push({
|
||||
id: nanoid(),
|
||||
text: line.trim(),
|
||||
words: segmentWords,
|
||||
start_time: null,
|
||||
end_time: null
|
||||
}
|
||||
|
||||
newSegments.push(segment)
|
||||
})
|
||||
})
|
||||
|
||||
// Create a global segment with all words for manual sync
|
||||
// Set a very large end time to ensure manual sync doesn't stop prematurely
|
||||
const audioDuration = getAudioDuration()
|
||||
const endTime = Math.max(audioDuration, 3600) // At least 1 hour to prevent auto-stop
|
||||
|
||||
console.log('ReplaceAllLyricsModal - Creating global segment', {
|
||||
audioDuration,
|
||||
endTime,
|
||||
wordCount: allWords.length
|
||||
})
|
||||
|
||||
const globalSegment: LyricsSegment = {
|
||||
id: 'global-replacement',
|
||||
text: allWords.map(w => w.text).join(' '),
|
||||
words: allWords,
|
||||
start_time: 0,
|
||||
end_time: endTime
|
||||
}
|
||||
|
||||
setCurrentSegments(newSegments)
|
||||
setOriginalSegments(JSON.parse(JSON.stringify(newSegments)))
|
||||
setGlobalSegment(globalSegment)
|
||||
setIsReplaced(true)
|
||||
}, [inputText, getAudioDuration])
|
||||
setNewSegments(segments)
|
||||
setMode('resync') // Go to synchronizer with the new segments
|
||||
}, [inputText])
|
||||
|
||||
// Handle paste from clipboard
|
||||
const handlePasteFromClipboard = useCallback(async () => {
|
||||
@@ -146,311 +116,90 @@ export default function ReplaceAllLyricsModal({
|
||||
}
|
||||
}, [])
|
||||
|
||||
// Update segment when words change during manual sync
|
||||
const updateSegment = useCallback((newWords: Word[]) => {
|
||||
if (!globalSegment) return
|
||||
|
||||
const validStartTimes = newWords.map(w => w.start_time).filter((t): t is number => t !== null)
|
||||
const validEndTimes = newWords.map(w => w.end_time).filter((t): t is number => t !== null)
|
||||
|
||||
const segmentStartTime = validStartTimes.length > 0 ? Math.min(...validStartTimes) : null
|
||||
const segmentEndTime = validEndTimes.length > 0 ? Math.max(...validEndTimes) : null
|
||||
|
||||
const updatedGlobalSegment = {
|
||||
...globalSegment,
|
||||
words: newWords,
|
||||
text: newWords.map(w => w.text).join(' '),
|
||||
start_time: segmentStartTime,
|
||||
end_time: segmentEndTime
|
||||
}
|
||||
|
||||
// Batch state updates to prevent multiple re-renders
|
||||
setGlobalSegment(updatedGlobalSegment)
|
||||
|
||||
// Update individual segment timing as words get synced - but only calculate when needed
|
||||
const updatedSegments = currentSegments.map(segment => {
|
||||
// Find words that belong to this segment and have been timed
|
||||
const segmentWordsWithTiming = segment.words.map(segmentWord => {
|
||||
const globalWord = newWords.find(w => w.id === segmentWord.id)
|
||||
return globalWord || segmentWord
|
||||
})
|
||||
|
||||
// Calculate segment timing if all words have timing
|
||||
const wordsWithTiming = segmentWordsWithTiming.filter(w =>
|
||||
w.start_time !== null && w.end_time !== null
|
||||
)
|
||||
|
||||
if (wordsWithTiming.length === segmentWordsWithTiming.length && wordsWithTiming.length > 0) {
|
||||
// All words in this segment have timing - update segment timing
|
||||
const segmentStart = Math.min(...wordsWithTiming.map(w => w.start_time!))
|
||||
const segmentEnd = Math.max(...wordsWithTiming.map(w => w.end_time!))
|
||||
|
||||
return {
|
||||
...segment,
|
||||
words: segmentWordsWithTiming,
|
||||
start_time: segmentStart,
|
||||
end_time: segmentEnd
|
||||
}
|
||||
} else {
|
||||
// Some words still don't have timing - just update the words
|
||||
return {
|
||||
...segment,
|
||||
words: segmentWordsWithTiming
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
setCurrentSegments(updatedSegments)
|
||||
}, [globalSegment, currentSegments])
|
||||
|
||||
// Use the manual sync hook
|
||||
const {
|
||||
isManualSyncing,
|
||||
isPaused,
|
||||
syncWordIndex,
|
||||
startManualSync,
|
||||
pauseManualSync,
|
||||
resumeManualSync,
|
||||
cleanupManualSync,
|
||||
handleSpacebar,
|
||||
isSpacebarPressed
|
||||
} = useManualSync({
|
||||
editedSegment: globalSegment,
|
||||
currentTime,
|
||||
onPlaySegment,
|
||||
updateSegment
|
||||
})
|
||||
|
||||
// Handle manual word updates (drag/resize in timeline)
|
||||
const handleWordUpdate = useCallback((wordIndex: number, updates: Partial<Word>) => {
|
||||
if (!globalSegment) return
|
||||
|
||||
// Only allow manual adjustments when manual sync is paused or not active
|
||||
if (isManualSyncing && !isPaused) {
|
||||
console.log('ReplaceAllLyricsModal - Ignoring word update during active manual sync')
|
||||
return
|
||||
}
|
||||
|
||||
console.log('ReplaceAllLyricsModal - Manual word update', {
|
||||
wordIndex,
|
||||
wordText: globalSegment.words[wordIndex]?.text,
|
||||
updates,
|
||||
isManualSyncing,
|
||||
isPaused
|
||||
})
|
||||
|
||||
// Update the word in the global segment
|
||||
const newWords = [...globalSegment.words]
|
||||
newWords[wordIndex] = {
|
||||
...newWords[wordIndex],
|
||||
...updates
|
||||
}
|
||||
|
||||
// Update the global segment through the existing updateSegment function
|
||||
updateSegment(newWords)
|
||||
}, [globalSegment, updateSegment, isManualSyncing, isPaused])
|
||||
|
||||
// Handle un-syncing a word (right-click context menu)
|
||||
const handleUnsyncWord = useCallback((wordIndex: number) => {
|
||||
if (!globalSegment) return
|
||||
|
||||
console.log('ReplaceAllLyricsModal - Un-syncing word', {
|
||||
wordIndex,
|
||||
wordText: globalSegment.words[wordIndex]?.text
|
||||
})
|
||||
|
||||
// Update the word to remove timing
|
||||
const newWords = [...globalSegment.words]
|
||||
newWords[wordIndex] = {
|
||||
...newWords[wordIndex],
|
||||
start_time: null,
|
||||
end_time: null
|
||||
}
|
||||
|
||||
// Update the global segment through the existing updateSegment function
|
||||
updateSegment(newWords)
|
||||
}, [globalSegment, updateSegment])
|
||||
|
||||
// Handle modal close
|
||||
const handleClose = useCallback(() => {
|
||||
cleanupManualSync()
|
||||
setMode('selection')
|
||||
setInputText('')
|
||||
setIsReplaced(false)
|
||||
setGlobalSegment(null)
|
||||
setOriginalSegments([])
|
||||
setCurrentSegments([])
|
||||
setNewSegments([])
|
||||
onClose()
|
||||
}, [onClose, cleanupManualSync])
|
||||
}, [onClose])
|
||||
|
||||
// Handle save
|
||||
const handleSave = useCallback(() => {
|
||||
if (!globalSegment || !currentSegments.length) return
|
||||
|
||||
// Distribute the timed words back to their original segments
|
||||
const finalSegments: LyricsSegment[] = []
|
||||
let wordIndex = 0
|
||||
|
||||
currentSegments.forEach((segment) => {
|
||||
const originalWordCount = segment.words.length
|
||||
const segmentWords = globalSegment.words.slice(wordIndex, wordIndex + originalWordCount)
|
||||
wordIndex += originalWordCount
|
||||
|
||||
if (segmentWords.length > 0) {
|
||||
// Recalculate segment start and end times
|
||||
const validStartTimes = segmentWords.map(w => w.start_time).filter((t): t is number => t !== null)
|
||||
const validEndTimes = segmentWords.map(w => w.end_time).filter((t): t is number => t !== null)
|
||||
|
||||
const segmentStartTime = validStartTimes.length > 0 ? Math.min(...validStartTimes) : null
|
||||
const segmentEndTime = validEndTimes.length > 0 ? Math.max(...validEndTimes) : null
|
||||
|
||||
finalSegments.push({
|
||||
...segment,
|
||||
words: segmentWords,
|
||||
text: segmentWords.map(w => w.text).join(' '),
|
||||
start_time: segmentStartTime,
|
||||
end_time: segmentEndTime
|
||||
})
|
||||
}
|
||||
})
|
||||
|
||||
console.log('ReplaceAllLyricsModal - Saving new segments:', {
|
||||
originalSegmentCount: currentSegments.length,
|
||||
finalSegmentCount: finalSegments.length,
|
||||
totalWords: finalSegments.reduce((count, seg) => count + seg.words.length, 0)
|
||||
})
|
||||
|
||||
onSave(finalSegments)
|
||||
// Handle save from synchronizer
|
||||
const handleSave = useCallback((segments: LyricsSegment[]) => {
|
||||
onSave(segments)
|
||||
handleClose()
|
||||
}, [globalSegment, currentSegments, onSave, handleClose])
|
||||
}, [onSave, handleClose])
|
||||
|
||||
// Handle reset
|
||||
const handleReset = useCallback(() => {
|
||||
if (!originalSegments.length) return
|
||||
// Handle mode selection
|
||||
const handleSelectReplace = useCallback(() => {
|
||||
setMode('replace')
|
||||
}, [])
|
||||
|
||||
console.log('ReplaceAllLyricsModal - Resetting to original state')
|
||||
|
||||
// Reset all words to have null timing (ready for fresh manual sync)
|
||||
const resetWords = originalSegments.flatMap(segment =>
|
||||
segment.words.map(word => ({
|
||||
...word,
|
||||
start_time: null,
|
||||
end_time: null
|
||||
}))
|
||||
)
|
||||
|
||||
const audioDuration = getAudioDuration()
|
||||
const resetGlobalSegment: LyricsSegment = {
|
||||
id: 'global-replacement',
|
||||
text: resetWords.map(w => w.text).join(' '),
|
||||
words: resetWords,
|
||||
start_time: 0,
|
||||
end_time: Math.max(audioDuration, 3600) // At least 1 hour to prevent auto-stop
|
||||
}
|
||||
const handleSelectResync = useCallback(() => {
|
||||
setMode('resync')
|
||||
}, [])
|
||||
|
||||
// Also reset the current segments to have null timing
|
||||
const resetCurrentSegments = originalSegments.map(segment => ({
|
||||
...segment,
|
||||
words: segment.words.map(word => ({
|
||||
...word,
|
||||
start_time: null,
|
||||
end_time: null
|
||||
})),
|
||||
start_time: null,
|
||||
end_time: null
|
||||
}))
|
||||
// Handle back to selection
|
||||
const handleBackToSelection = useCallback(() => {
|
||||
setMode('selection')
|
||||
setInputText('')
|
||||
setNewSegments([])
|
||||
}, [])
|
||||
|
||||
setGlobalSegment(resetGlobalSegment)
|
||||
setCurrentSegments(resetCurrentSegments)
|
||||
}, [originalSegments, getAudioDuration])
|
||||
// Determine which segments to use for synchronizer
|
||||
const segmentsForSync = mode === 'resync' && newSegments.length > 0
|
||||
? newSegments
|
||||
: existingSegments
|
||||
|
||||
// Keep a ref to the current spacebar handler to avoid closure issues
|
||||
const spacebarHandlerRef = useRef(handleSpacebar)
|
||||
spacebarHandlerRef.current = handleSpacebar
|
||||
|
||||
// Update the spacebar handler when modal state changes
|
||||
useEffect(() => {
|
||||
if (open && isReplaced) {
|
||||
console.log('ReplaceAllLyricsModal - Setting up spacebar handler')
|
||||
|
||||
const handleKeyEvent = (e: KeyboardEvent) => {
|
||||
if (e.code === 'Space') {
|
||||
console.log('ReplaceAllLyricsModal - Spacebar captured in modal')
|
||||
e.preventDefault()
|
||||
e.stopPropagation()
|
||||
// Use the ref to get the current handler
|
||||
spacebarHandlerRef.current(e)
|
||||
}
|
||||
}
|
||||
|
||||
setModalSpacebarHandler(() => handleKeyEvent)
|
||||
|
||||
return () => {
|
||||
if (!open) {
|
||||
console.log('ReplaceAllLyricsModal - Clearing spacebar handler')
|
||||
setModalSpacebarHandler(undefined)
|
||||
}
|
||||
}
|
||||
} else if (open) {
|
||||
// Clear handler when not in replaced state
|
||||
setModalSpacebarHandler(undefined)
|
||||
}
|
||||
}, [open, isReplaced, setModalSpacebarHandler])
|
||||
|
||||
// Memoize timeline range to prevent recalculation
|
||||
const timeRange = useMemo(() => {
|
||||
const audioDuration = getAudioDuration()
|
||||
// Always use full song duration for replace-all mode
|
||||
return { start: 0, end: audioDuration }
|
||||
}, [getAudioDuration])
|
||||
|
||||
// Memoize the segment progress props to prevent unnecessary re-renders
|
||||
const segmentProgressProps = useMemo(() => ({
|
||||
currentSegments,
|
||||
globalSegment,
|
||||
syncWordIndex
|
||||
}), [currentSegments, globalSegment, syncWordIndex])
|
||||
// Check if we have existing lyrics
|
||||
const hasExistingLyrics = existingSegments.length > 0 &&
|
||||
existingSegments.some(s => s.words.length > 0)
|
||||
|
||||
return (
|
||||
<Dialog
|
||||
open={open}
|
||||
onClose={handleClose}
|
||||
maxWidth={false}
|
||||
fullWidth={true}
|
||||
onKeyDown={(e) => {
|
||||
if (e.key === 'Enter' && !e.shiftKey && isReplaced) {
|
||||
e.preventDefault()
|
||||
handleSave()
|
||||
}
|
||||
}}
|
||||
PaperProps={{
|
||||
sx: {
|
||||
height: '90vh',
|
||||
margin: '5vh 2vh',
|
||||
maxWidth: 'calc(100vw - 4vh)',
|
||||
width: 'calc(100vw - 4vh)'
|
||||
}
|
||||
}}
|
||||
>
|
||||
<DialogTitle sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>
|
||||
<Box sx={{ flex: 1 }}>
|
||||
Replace All Lyrics
|
||||
</Box>
|
||||
<IconButton onClick={handleClose} sx={{ ml: 'auto' }}>
|
||||
<CloseIcon />
|
||||
</IconButton>
|
||||
</DialogTitle>
|
||||
<>
|
||||
{/* Mode Selection Modal */}
|
||||
<ModeSelectionModal
|
||||
open={open && mode === 'selection'}
|
||||
onClose={handleClose}
|
||||
onSelectReplace={handleSelectReplace}
|
||||
onSelectResync={handleSelectResync}
|
||||
hasExistingLyrics={hasExistingLyrics}
|
||||
/>
|
||||
|
||||
<DialogContent
|
||||
dividers
|
||||
sx={{
|
||||
display: 'flex',
|
||||
flexDirection: 'column',
|
||||
flexGrow: 1,
|
||||
overflow: 'hidden'
|
||||
{/* Replace All Lyrics Modal (Paste Phase) */}
|
||||
<Dialog
|
||||
open={open && mode === 'replace'}
|
||||
onClose={handleClose}
|
||||
maxWidth="md"
|
||||
fullWidth
|
||||
PaperProps={{
|
||||
sx: {
|
||||
height: '80vh',
|
||||
maxHeight: '80vh'
|
||||
}
|
||||
}}
|
||||
>
|
||||
{!isReplaced ? (
|
||||
// Step 1: Input new lyrics
|
||||
<DialogTitle sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>
|
||||
<IconButton onClick={handleBackToSelection} size="small">
|
||||
<ArrowBackIcon />
|
||||
</IconButton>
|
||||
<Box sx={{ flex: 1 }}>
|
||||
Replace All Lyrics
|
||||
</Box>
|
||||
<IconButton onClick={handleClose} sx={{ ml: 'auto' }}>
|
||||
<CloseIcon />
|
||||
</IconButton>
|
||||
</DialogTitle>
|
||||
|
||||
<DialogContent
|
||||
dividers
|
||||
sx={{
|
||||
display: 'flex',
|
||||
flexDirection: 'column',
|
||||
flexGrow: 1,
|
||||
overflow: 'hidden'
|
||||
}}
|
||||
>
|
||||
<Box sx={{ display: 'flex', flexDirection: 'column', gap: 2, height: '100%' }}>
|
||||
<Typography variant="h6" gutterBottom>
|
||||
Paste your new lyrics below:
|
||||
@@ -492,197 +241,96 @@ export default function ReplaceAllLyricsModal({
|
||||
}
|
||||
}}
|
||||
/>
|
||||
|
||||
<Box sx={{ display: 'flex', justifyContent: 'flex-end', gap: 2 }}>
|
||||
<Button
|
||||
variant="contained"
|
||||
onClick={processLyrics}
|
||||
disabled={!inputText.trim()}
|
||||
startIcon={<AutoFixHighIcon />}
|
||||
>
|
||||
Replace All Lyrics
|
||||
</Button>
|
||||
</Box>
|
||||
</Box>
|
||||
) : (
|
||||
// Step 2: Manual sync interface
|
||||
<Box sx={{ display: 'flex', flexDirection: 'column', height: '100%', gap: 2 }}>
|
||||
<Paper sx={{ p: 2, bgcolor: 'background.paper' }}>
|
||||
<Typography variant="h6" gutterBottom>
|
||||
Lyrics Replaced Successfully
|
||||
</Typography>
|
||||
<Typography variant="body2" color="text.secondary">
|
||||
Created {currentSegments.length} segments with {globalSegment?.words.length} words total.
|
||||
Use Manual Sync to set timing for all words.
|
||||
</Typography>
|
||||
</Paper>
|
||||
</DialogContent>
|
||||
|
||||
<Divider />
|
||||
<DialogActions>
|
||||
<Button onClick={handleClose} color="inherit">
|
||||
Cancel
|
||||
</Button>
|
||||
<Button
|
||||
variant="contained"
|
||||
onClick={processLyrics}
|
||||
disabled={!inputText.trim()}
|
||||
startIcon={<AutoFixHighIcon />}
|
||||
>
|
||||
Continue to Sync
|
||||
</Button>
|
||||
</DialogActions>
|
||||
</Dialog>
|
||||
|
||||
{globalSegment && (
|
||||
<Box sx={{ display: 'flex', gap: 2, flexGrow: 1, minHeight: 0 }}>
|
||||
{/* Timeline Section */}
|
||||
<Box sx={{ flex: 2, display: 'flex', flexDirection: 'column', minHeight: 0 }}>
|
||||
<EditTimelineSection
|
||||
words={globalSegment.words}
|
||||
startTime={timeRange.start}
|
||||
endTime={timeRange.end}
|
||||
originalStartTime={0}
|
||||
originalEndTime={getAudioDuration()}
|
||||
currentStartTime={globalSegment.start_time}
|
||||
currentEndTime={globalSegment.end_time}
|
||||
currentTime={currentTime}
|
||||
isManualSyncing={isManualSyncing}
|
||||
syncWordIndex={syncWordIndex}
|
||||
isSpacebarPressed={isSpacebarPressed}
|
||||
onWordUpdate={handleWordUpdate}
|
||||
onUnsyncWord={handleUnsyncWord}
|
||||
onPlaySegment={onPlaySegment}
|
||||
onStopAudio={() => {
|
||||
// Stop audio playback using global function
|
||||
if (window.toggleAudioPlayback && window.isAudioPlaying) {
|
||||
window.toggleAudioPlayback()
|
||||
}
|
||||
}}
|
||||
startManualSync={startManualSync}
|
||||
pauseManualSync={pauseManualSync}
|
||||
resumeManualSync={resumeManualSync}
|
||||
isPaused={isPaused}
|
||||
isGlobal={true}
|
||||
defaultZoomLevel={10} // Show 10 seconds by default
|
||||
isReplaceAllMode={true} // Prevent zoom changes during sync
|
||||
/>
|
||||
</Box>
|
||||
|
||||
{/* Segment Progress Section */}
|
||||
<SegmentProgressPanel
|
||||
currentSegments={segmentProgressProps.currentSegments}
|
||||
globalSegment={segmentProgressProps.globalSegment}
|
||||
syncWordIndex={segmentProgressProps.syncWordIndex}
|
||||
/>
|
||||
</Box>
|
||||
)}
|
||||
</Box>
|
||||
)}
|
||||
</DialogContent>
|
||||
|
||||
<DialogActions>
|
||||
{isReplaced && (
|
||||
<EditActionBar
|
||||
onReset={handleReset}
|
||||
onClose={handleClose}
|
||||
onSave={handleSave}
|
||||
editedSegment={globalSegment}
|
||||
isGlobal={true}
|
||||
/>
|
||||
)}
|
||||
</DialogActions>
|
||||
</Dialog>
|
||||
)
|
||||
}
|
||||
|
||||
// Memoized Segment Progress Item to prevent unnecessary re-renders
|
||||
const SegmentProgressItem = memo(({
|
||||
segment,
|
||||
index,
|
||||
isActive
|
||||
}: {
|
||||
segment: LyricsSegment
|
||||
index: number
|
||||
isActive: boolean
|
||||
}) => {
|
||||
const wordsWithTiming = segment.words.filter(w =>
|
||||
w.start_time !== null && w.end_time !== null
|
||||
).length
|
||||
const totalWords = segment.words.length
|
||||
const isComplete = wordsWithTiming === totalWords
|
||||
|
||||
return (
|
||||
<Paper
|
||||
key={segment.id}
|
||||
ref={isActive ? (el) => {
|
||||
// Auto-scroll to active segment
|
||||
if (el) {
|
||||
el.scrollIntoView({
|
||||
behavior: 'smooth',
|
||||
block: 'center'
|
||||
})
|
||||
}
|
||||
} : undefined}
|
||||
sx={{
|
||||
p: 1,
|
||||
mb: 1,
|
||||
bgcolor: isActive ? 'primary.light' :
|
||||
isComplete ? 'success.light' : 'background.paper',
|
||||
border: isActive ? 2 : 1,
|
||||
borderColor: isActive ? 'primary.main' : 'divider'
|
||||
}}
|
||||
>
|
||||
<Typography
|
||||
variant="body2"
|
||||
sx={{
|
||||
fontWeight: isActive ? 'bold' : 'normal',
|
||||
mb: 0.5
|
||||
{/* Synchronizer Modal */}
|
||||
<Dialog
|
||||
open={open && mode === 'resync'}
|
||||
onClose={handleClose}
|
||||
maxWidth={false}
|
||||
fullWidth
|
||||
PaperProps={{
|
||||
sx: {
|
||||
height: '90vh',
|
||||
margin: '5vh 2vw',
|
||||
maxWidth: 'calc(100vw - 4vw)',
|
||||
width: 'calc(100vw - 4vw)'
|
||||
}
|
||||
}}
|
||||
>
|
||||
Segment {index + 1}: {segment.text.slice(0, 50)}
|
||||
{segment.text.length > 50 ? '...' : ''}
|
||||
</Typography>
|
||||
<Typography variant="caption" color="text.secondary">
|
||||
{wordsWithTiming}/{totalWords} words synced
|
||||
{isComplete && segment.start_time !== null && segment.end_time !== null && (
|
||||
<>
|
||||
<br />
|
||||
{segment.start_time.toFixed(2)}s - {segment.end_time.toFixed(2)}s
|
||||
</>
|
||||
)}
|
||||
</Typography>
|
||||
</Paper>
|
||||
)
|
||||
})
|
||||
<DialogTitle sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>
|
||||
<IconButton onClick={handleBackToSelection} size="small">
|
||||
<ArrowBackIcon />
|
||||
</IconButton>
|
||||
<Box sx={{ flex: 1 }}>
|
||||
{newSegments.length > 0 ? 'Sync New Lyrics' : 'Re-sync Existing Lyrics'}
|
||||
</Box>
|
||||
<IconButton onClick={handleClose} sx={{ ml: 'auto' }}>
|
||||
<CloseIcon />
|
||||
</IconButton>
|
||||
</DialogTitle>
|
||||
|
||||
// Memoized Segment Progress Panel
|
||||
const SegmentProgressPanel = memo(({
|
||||
currentSegments,
|
||||
globalSegment,
|
||||
syncWordIndex
|
||||
}: {
|
||||
currentSegments: LyricsSegment[]
|
||||
globalSegment: LyricsSegment | null
|
||||
syncWordIndex: number
|
||||
}) => {
|
||||
return (
|
||||
<Box sx={{ flex: 1, display: 'flex', flexDirection: 'column', minHeight: 0 }}>
|
||||
<Typography variant="h6" gutterBottom>
|
||||
Segment Progress
|
||||
</Typography>
|
||||
<Box sx={{
|
||||
overflow: 'auto',
|
||||
flexGrow: 1,
|
||||
border: 1,
|
||||
borderColor: 'divider',
|
||||
borderRadius: 1,
|
||||
p: 1
|
||||
}}>
|
||||
{currentSegments.map((segment, index) => {
|
||||
const isActive = Boolean(
|
||||
globalSegment &&
|
||||
syncWordIndex >= 0 &&
|
||||
syncWordIndex < globalSegment.words.length &&
|
||||
globalSegment.words[syncWordIndex] &&
|
||||
segment.words.some(w => w.id === globalSegment.words[syncWordIndex].id)
|
||||
)
|
||||
|
||||
return (
|
||||
<SegmentProgressItem
|
||||
key={segment.id}
|
||||
segment={segment}
|
||||
index={index}
|
||||
isActive={isActive}
|
||||
<DialogContent
|
||||
dividers
|
||||
sx={{
|
||||
display: 'flex',
|
||||
flexDirection: 'column',
|
||||
flexGrow: 1,
|
||||
overflow: 'hidden',
|
||||
p: 2
|
||||
}}
|
||||
>
|
||||
{segmentsForSync.length > 0 ? (
|
||||
<LyricsSynchronizer
|
||||
segments={segmentsForSync}
|
||||
currentTime={currentTime}
|
||||
onPlaySegment={onPlaySegment}
|
||||
onSave={handleSave}
|
||||
onCancel={handleClose}
|
||||
setModalSpacebarHandler={setModalSpacebarHandler}
|
||||
/>
|
||||
)
|
||||
})}
|
||||
</Box>
|
||||
</Box>
|
||||
) : (
|
||||
<Box sx={{
|
||||
display: 'flex',
|
||||
flexDirection: 'column',
|
||||
alignItems: 'center',
|
||||
justifyContent: 'center',
|
||||
height: '100%',
|
||||
gap: 2
|
||||
}}>
|
||||
<Typography variant="h6" color="text.secondary">
|
||||
No lyrics to sync
|
||||
</Typography>
|
||||
<Typography variant="body2" color="text.secondary">
|
||||
Go back and paste new lyrics, or close this modal.
|
||||
</Typography>
|
||||
<Button
|
||||
variant="outlined"
|
||||
onClick={handleBackToSelection}
|
||||
startIcon={<ArrowBackIcon />}
|
||||
>
|
||||
Back to Selection
|
||||
</Button>
|
||||
</Box>
|
||||
)}
|
||||
</DialogContent>
|
||||
</Dialog>
|
||||
</>
|
||||
)
|
||||
})
|
||||
}
|
||||
@@ -1 +1 @@
|
||||
{"root":["./src/app.tsx","./src/api.ts","./src/main.tsx","./src/theme.ts","./src/types.ts","./src/validation.ts","./src/vite-env.d.ts","./src/components/aifeedbackmodal.tsx","./src/components/addlyricsmodal.tsx","./src/components/agenticcorrectionmetrics.tsx","./src/components/audioplayer.tsx","./src/components/correctedwordwithactions.tsx","./src/components/correctionannotationmodal.tsx","./src/components/correctiondetailcard.tsx","./src/components/correctionmetrics.tsx","./src/components/durationtimelineview.tsx","./src/components/editactionbar.tsx","./src/components/editmodal.tsx","./src/components/edittimelinesection.tsx","./src/components/editwordlist.tsx","./src/components/fileupload.tsx","./src/components/findreplacemodal.tsx","./src/components/header.tsx","./src/components/lyricsanalyzer.tsx","./src/components/metricsdashboard.tsx","./src/components/modeselector.tsx","./src/components/modelselector.tsx","./src/components/previewvideosection.tsx","./src/components/referenceview.tsx","./src/components/replacealllyricsmodal.tsx","./src/components/reviewchangesmodal.tsx","./src/components/segmentdetailsmodal.tsx","./src/components/timelineeditor.tsx","./src/components/timingoffsetmodal.tsx","./src/components/transcriptionview.tsx","./src/components/worddivider.tsx","./src/components/shared/constants.ts","./src/components/shared/styles.ts","./src/components/shared/types.ts","./src/components/shared/components/highlightedtext.tsx","./src/components/shared/components/sourceselector.tsx","./src/components/shared/components/word.tsx","./src/components/shared/hooks/usewordclick.ts","./src/components/shared/utils/keyboardhandlers.ts","./src/components/shared/utils/localstorage.ts","./src/components/shared/utils/referencelinecalculator.ts","./src/components/shared/utils/segmentoperations.ts","./src/components/shared/utils/timingutils.ts","./src/components/shared/utils/wordutils.ts","./src/hooks/usemanualsync.ts","./src/types/global.d.ts"],"version":"5.6.3"}
|
||||
{"root":["./src/app.tsx","./src/api.ts","./src/main.tsx","./src/theme.ts","./src/types.ts","./src/validation.ts","./src/vite-env.d.ts","./src/components/aifeedbackmodal.tsx","./src/components/addlyricsmodal.tsx","./src/components/agenticcorrectionmetrics.tsx","./src/components/audioplayer.tsx","./src/components/correctedwordwithactions.tsx","./src/components/correctionannotationmodal.tsx","./src/components/correctiondetailcard.tsx","./src/components/correctionmetrics.tsx","./src/components/durationtimelineview.tsx","./src/components/editactionbar.tsx","./src/components/editmodal.tsx","./src/components/edittimelinesection.tsx","./src/components/editwordlist.tsx","./src/components/fileupload.tsx","./src/components/findreplacemodal.tsx","./src/components/header.tsx","./src/components/lyricsanalyzer.tsx","./src/components/metricsdashboard.tsx","./src/components/modeselectionmodal.tsx","./src/components/modeselector.tsx","./src/components/modelselector.tsx","./src/components/previewvideosection.tsx","./src/components/referenceview.tsx","./src/components/replacealllyricsmodal.tsx","./src/components/reviewchangesmodal.tsx","./src/components/segmentdetailsmodal.tsx","./src/components/timelineeditor.tsx","./src/components/timingoffsetmodal.tsx","./src/components/transcriptionview.tsx","./src/components/worddivider.tsx","./src/components/lyricssynchronizer/synccontrols.tsx","./src/components/lyricssynchronizer/timelinecanvas.tsx","./src/components/lyricssynchronizer/upcomingwordsbar.tsx","./src/components/lyricssynchronizer/index.tsx","./src/components/shared/constants.ts","./src/components/shared/styles.ts","./src/components/shared/types.ts","./src/components/shared/components/highlightedtext.tsx","./src/components/shared/components/sourceselector.tsx","./src/components/shared/components/word.tsx","./src/components/shared/hooks/usewordclick.ts","./src/components/shared/utils/keyboardhandlers.ts","./src/components/shared/utils/localstorage.ts","./src/components/shared/utils/referencelinecalculator.ts","./src/components/shared/utils/segmentoperations.ts","./src/components/shared/utils/timingutils.ts","./src/components/shared/utils/wordutils.ts","./src/hooks/usemanualsync.ts","./src/types/global.d.ts"],"version":"5.6.3"}
|
||||
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"index-COYImAcx.js","sources":["../../node_modules/react/cjs/react.production.min.js","../../node_modules/react/index.js","../../node_modules/react/cjs/react-jsx-runtime.production.min.js","../../node_modules/react/jsx-runtime.js","../../node_modules/scheduler/cjs/scheduler.production.min.js","../../node_modules/scheduler/index.js","../../node_modules/react-dom/cjs/react-dom.production.min.js","../../node_modules/react-dom/index.js","../../node_modules/react-dom/client.js","../../node_modules/@mui/utils/esm/formatMuiErrorMessage/formatMuiErrorMessage.js","../../node_modules/@mui/material/styles/identifier.js","../../node_modules/@babel/runtime/helpers/esm/extends.js","../../node_modules/@emotion/sheet/dist/emotion-sheet.esm.js","../../node_modules/stylis/src/Enum.js","../../node_modules/stylis/src/Utility.js","../../node_modules/stylis/src/Tokenizer.js","../../node_modules/stylis/src/Parser.js","../../node_modules/stylis/src/Serializer.js","../../node_modules/stylis/src/Middleware.js","../../node_modules/@emotion/memoize/dist/emotion-memoize.esm.js","../../node_modules/@emotion/cache/dist/emotion-cache.browser.esm.js","../../node_modules/react-is/cjs/react-is.production.min.js","../../node_modules/react-is/index.js","../../node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js","../../node_modules/@emotion/utils/dist/emotion-utils.browser.esm.js","../../node_modules/@emotion/hash/dist/emotion-hash.esm.js","../../node_modules/@emotion/unitless/dist/emotion-unitless.esm.js","../../node_modules/@emotion/serialize/dist/emotion-serialize.esm.js","../../node_modules/@emotion/use-insertion-effect-with-fallbacks/dist/emotion-use-insertion-effect-with-fallbacks.browser.esm.js","../../node_modules/@emotion/react/dist/emotion-element-f0de968e.browser.esm.js","../../node_modules/@emotion/react/dist/emotion-react.browser.esm.js","../../node_modules/@emotion/is-prop-valid/dist/emotion-is-prop-valid.esm.js","../../node_modules/@emotion/styled/base/dist/emotion-styled-base.browser.esm.js","../../node_modules/@emotion/styled/dist/emotion-styled.browser.esm.js","../../node_modules/@mui/styled-engine/GlobalStyles/GlobalStyles.js","../../node_modules/@mui/styled-engine/index.js","../../node_modules/@mui/utils/node_modules/react-is/cjs/react-is.production.js","../../node_modules/@mui/utils/node_modules/react-is/index.js","../../node_modules/@mui/utils/esm/deepmerge/deepmerge.js","../../node_modules/@mui/system/esm/createBreakpoints/createBreakpoints.js","../../node_modules/@mui/system/esm/cssContainerQueries/cssContainerQueries.js","../../node_modules/@mui/system/esm/createTheme/shape.js","../../node_modules/@mui/system/esm/merge/merge.js","../../node_modules/@mui/system/esm/breakpoints/breakpoints.js","../../node_modules/@mui/utils/esm/capitalize/capitalize.js","../../node_modules/@mui/system/esm/style/style.js","../../node_modules/@mui/system/esm/memoize/memoize.js","../../node_modules/@mui/system/esm/spacing/spacing.js","../../node_modules/@mui/system/esm/createTheme/createSpacing.js","../../node_modules/@mui/system/esm/compose/compose.js","../../node_modules/@mui/system/esm/borders/borders.js","../../node_modules/@mui/system/esm/cssGrid/cssGrid.js","../../node_modules/@mui/system/esm/palette/palette.js","../../node_modules/@mui/system/esm/sizing/sizing.js","../../node_modules/@mui/system/esm/styleFunctionSx/defaultSxConfig.js","../../node_modules/@mui/system/esm/styleFunctionSx/styleFunctionSx.js","../../node_modules/@mui/system/esm/createTheme/applyStyles.js","../../node_modules/@mui/system/esm/createTheme/createTheme.js","../../node_modules/@mui/system/esm/useThemeWithoutDefault/useThemeWithoutDefault.js","../../node_modules/@mui/system/esm/useTheme/useTheme.js","../../node_modules/@mui/system/esm/GlobalStyles/GlobalStyles.js","../../node_modules/@mui/system/esm/styleFunctionSx/extendSxProp.js","../../node_modules/@mui/utils/esm/ClassNameGenerator/ClassNameGenerator.js","../../node_modules/clsx/dist/clsx.mjs","../../node_modules/@mui/system/esm/createBox/createBox.js","../../node_modules/@mui/utils/esm/generateUtilityClass/generateUtilityClass.js","../../node_modules/@mui/utils/esm/generateUtilityClasses/generateUtilityClasses.js","../../node_modules/@mui/system/esm/preprocessStyles.js","../../node_modules/@mui/system/esm/createStyled/createStyled.js","../../node_modules/@mui/system/esm/styled/styled.js","../../node_modules/@mui/utils/esm/resolveProps/resolveProps.js","../../node_modules/@mui/system/esm/useThemeProps/getThemeProps.js","../../node_modules/@mui/system/esm/useThemeProps/useThemeProps.js","../../node_modules/@mui/utils/esm/useEnhancedEffect/useEnhancedEffect.js","../../node_modules/@mui/system/esm/useMediaQuery/useMediaQuery.js","../../node_modules/@mui/utils/esm/clamp/clamp.js","../../node_modules/@mui/system/esm/colorManipulator/colorManipulator.js","../../node_modules/@mui/utils/esm/createChainedFunction/createChainedFunction.js","../../node_modules/@mui/utils/esm/debLine truncated
|
||||
@@ -1 +0,0 @@
|
||||
{"version":3,"file":"index-DdJTDWH3.js","sources":["../../node_modules/react/cjs/react.production.min.js","../../node_modules/react/index.js","../../node_modules/react/cjs/react-jsx-runtime.production.min.js","../../node_modules/react/jsx-runtime.js","../../node_modules/scheduler/cjs/scheduler.production.min.js","../../node_modules/scheduler/index.js","../../node_modules/react-dom/cjs/react-dom.production.min.js","../../node_modules/react-dom/index.js","../../node_modules/react-dom/client.js","../../node_modules/@mui/utils/esm/formatMuiErrorMessage/formatMuiErrorMessage.js","../../node_modules/@mui/material/styles/identifier.js","../../node_modules/@babel/runtime/helpers/esm/extends.js","../../node_modules/@emotion/sheet/dist/emotion-sheet.esm.js","../../node_modules/stylis/src/Enum.js","../../node_modules/stylis/src/Utility.js","../../node_modules/stylis/src/Tokenizer.js","../../node_modules/stylis/src/Parser.js","../../node_modules/stylis/src/Serializer.js","../../node_modules/stylis/src/Middleware.js","../../node_modules/@emotion/memoize/dist/emotion-memoize.esm.js","../../node_modules/@emotion/cache/dist/emotion-cache.browser.esm.js","../../node_modules/react-is/cjs/react-is.production.min.js","../../node_modules/react-is/index.js","../../node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js","../../node_modules/@emotion/utils/dist/emotion-utils.browser.esm.js","../../node_modules/@emotion/hash/dist/emotion-hash.esm.js","../../node_modules/@emotion/unitless/dist/emotion-unitless.esm.js","../../node_modules/@emotion/serialize/dist/emotion-serialize.esm.js","../../node_modules/@emotion/use-insertion-effect-with-fallbacks/dist/emotion-use-insertion-effect-with-fallbacks.browser.esm.js","../../node_modules/@emotion/react/dist/emotion-element-f0de968e.browser.esm.js","../../node_modules/@emotion/react/dist/emotion-react.browser.esm.js","../../node_modules/@emotion/is-prop-valid/dist/emotion-is-prop-valid.esm.js","../../node_modules/@emotion/styled/base/dist/emotion-styled-base.browser.esm.js","../../node_modules/@emotion/styled/dist/emotion-styled.browser.esm.js","../../node_modules/@mui/styled-engine/GlobalStyles/GlobalStyles.js","../../node_modules/@mui/styled-engine/index.js","../../node_modules/@mui/utils/node_modules/react-is/cjs/react-is.production.js","../../node_modules/@mui/utils/node_modules/react-is/index.js","../../node_modules/@mui/utils/esm/deepmerge/deepmerge.js","../../node_modules/@mui/system/esm/createBreakpoints/createBreakpoints.js","../../node_modules/@mui/system/esm/cssContainerQueries/cssContainerQueries.js","../../node_modules/@mui/system/esm/createTheme/shape.js","../../node_modules/@mui/system/esm/merge/merge.js","../../node_modules/@mui/system/esm/breakpoints/breakpoints.js","../../node_modules/@mui/utils/esm/capitalize/capitalize.js","../../node_modules/@mui/system/esm/style/style.js","../../node_modules/@mui/system/esm/memoize/memoize.js","../../node_modules/@mui/system/esm/spacing/spacing.js","../../node_modules/@mui/system/esm/createTheme/createSpacing.js","../../node_modules/@mui/system/esm/compose/compose.js","../../node_modules/@mui/system/esm/borders/borders.js","../../node_modules/@mui/system/esm/cssGrid/cssGrid.js","../../node_modules/@mui/system/esm/palette/palette.js","../../node_modules/@mui/system/esm/sizing/sizing.js","../../node_modules/@mui/system/esm/styleFunctionSx/defaultSxConfig.js","../../node_modules/@mui/system/esm/styleFunctionSx/styleFunctionSx.js","../../node_modules/@mui/system/esm/createTheme/applyStyles.js","../../node_modules/@mui/system/esm/createTheme/createTheme.js","../../node_modules/@mui/system/esm/useThemeWithoutDefault/useThemeWithoutDefault.js","../../node_modules/@mui/system/esm/useTheme/useTheme.js","../../node_modules/@mui/system/esm/GlobalStyles/GlobalStyles.js","../../node_modules/@mui/system/esm/styleFunctionSx/extendSxProp.js","../../node_modules/@mui/utils/esm/ClassNameGenerator/ClassNameGenerator.js","../../node_modules/clsx/dist/clsx.mjs","../../node_modules/@mui/system/esm/createBox/createBox.js","../../node_modules/@mui/utils/esm/generateUtilityClass/generateUtilityClass.js","../../node_modules/@mui/utils/esm/generateUtilityClasses/generateUtilityClasses.js","../../node_modules/@mui/system/esm/preprocessStyles.js","../../node_modules/@mui/system/esm/createStyled/createStyled.js","../../node_modules/@mui/system/esm/styled/styled.js","../../node_modules/@mui/utils/esm/resolveProps/resolveProps.js","../../node_modules/@mui/system/esm/useThemeProps/getThemeProps.js","../../node_modules/@mui/system/esm/useThemeProps/useThemeProps.js","../../node_modules/@mui/utils/esm/useEnhancedEffect/useEnhancedEffect.js","../../node_modules/@mui/system/esm/useMediaQuery/useMediaQuery.js","../../node_modules/@mui/utils/esm/clamp/clamp.js","../../node_modules/@mui/system/esm/colorManipulator/colorManipulator.js","../../node_modules/@mui/utils/esm/createChainedFunction/createChainedFunction.js","../../node_modules/@mui/utils/esm/debLine truncated
|
||||
@@ -10,7 +10,7 @@
|
||||
<link rel="icon" type="image/png" sizes="512x512" href="/android-chrome-512x512.png" />
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
|
||||
<title>Nomad Karaoke: Lyrics Review</title>
|
||||
<script type="module" crossorigin src="/assets/index-DdJTDWH3.js"></script>
|
||||
<script type="module" crossorigin src="/assets/index-COYImAcx.js"></script>
|
||||
</head>
|
||||
<body>
|
||||
<div id="root"></div>
|
||||
|
||||
@@ -629,14 +629,14 @@ class ReviewServer:
|
||||
else ""
|
||||
)
|
||||
|
||||
# Use hosted review UI by default, can be overridden with LYRICS_REVIEW_UI_URL env var
|
||||
# Set to "local" to use the bundled local frontend instead
|
||||
review_ui_url = os.environ.get("LYRICS_REVIEW_UI_URL", "https://lyrics.nomadkaraoke.com")
|
||||
# Use bundled local frontend by default for local karaoke-gen runs
|
||||
# Can override with LYRICS_REVIEW_UI_URL env var (e.g., http://localhost:5173 for Vite dev)
|
||||
review_ui_url = os.environ.get("LYRICS_REVIEW_UI_URL", "local")
|
||||
if review_ui_url.lower() == "local":
|
||||
# Use the bundled local frontend
|
||||
# Use the bundled local frontend served by this FastAPI server
|
||||
browser_url = f"http://localhost:8000?baseApiUrl={encoded_api_url}{audio_hash_param}"
|
||||
else:
|
||||
# Use the hosted/external review UI
|
||||
# Use an external review UI (dev server or hosted)
|
||||
browser_url = f"{review_ui_url}?baseApiUrl={encoded_api_url}{audio_hash_param}"
|
||||
|
||||
self.logger.info(f"Opening review UI: {browser_url}")
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
[tool.poetry]
|
||||
name = "karaoke-gen"
|
||||
version = "0.71.64"
|
||||
version = "0.73.3"
|
||||
description = "Generate karaoke videos with synchronized lyrics. Handles the entire process from downloading audio and lyrics to creating the final video with title screens."
|
||||
authors = ["Andrew Beveridge <andrew@beveridge.uk>"]
|
||||
license = "MIT"
|
||||
|
||||
@@ -435,6 +435,266 @@ class TestExistingInstrumentalPadding:
|
||||
assert '3.0' in call_args or 3.0 in call_args
|
||||
|
||||
|
||||
class TestDetectCountdownPaddingFromLRC:
|
||||
"""Tests for detecting countdown padding from existing LRC files."""
|
||||
|
||||
def test_detect_padding_from_lrc_with_padding(self, basic_karaoke_gen, temp_dir):
|
||||
"""Test that countdown padding is detected when first lyric is after 3 seconds."""
|
||||
lrc_file = os.path.join(temp_dir, 'test.lrc')
|
||||
|
||||
# Create an LRC file with first lyric at 3 seconds (padding was applied)
|
||||
lrc_content = """[ti:Test Song]
|
||||
[ar:Test Artist]
|
||||
[00:03.50]First line of lyrics
|
||||
[00:06.20]Second line of lyrics
|
||||
[00:10.00]Third line of lyrics
|
||||
"""
|
||||
with open(lrc_file, 'w') as f:
|
||||
f.write(lrc_content)
|
||||
|
||||
padding_added, padding_seconds = basic_karaoke_gen.lyrics_processor._detect_countdown_padding_from_lrc(lrc_file)
|
||||
|
||||
assert padding_added is True
|
||||
assert padding_seconds == 3.0
|
||||
|
||||
def test_detect_padding_from_lrc_without_padding(self, basic_karaoke_gen, temp_dir):
|
||||
"""Test that no padding is detected when first lyric is before 3 seconds."""
|
||||
lrc_file = os.path.join(temp_dir, 'test.lrc')
|
||||
|
||||
# Create an LRC file with first lyric at 0.5 seconds (no padding)
|
||||
lrc_content = """[ti:Test Song]
|
||||
[ar:Test Artist]
|
||||
[00:00.50]First line of lyrics
|
||||
[00:03.20]Second line of lyrics
|
||||
[00:06.00]Third line of lyrics
|
||||
"""
|
||||
with open(lrc_file, 'w') as f:
|
||||
f.write(lrc_content)
|
||||
|
||||
padding_added, padding_seconds = basic_karaoke_gen.lyrics_processor._detect_countdown_padding_from_lrc(lrc_file)
|
||||
|
||||
assert padding_added is False
|
||||
assert padding_seconds == 0.0
|
||||
|
||||
def test_detect_padding_from_lrc_edge_case(self, basic_karaoke_gen, temp_dir):
|
||||
"""Test detection at the 2.5 second boundary."""
|
||||
lrc_file = os.path.join(temp_dir, 'test.lrc')
|
||||
|
||||
# Create an LRC file with first lyric at exactly 2.5 seconds (boundary)
|
||||
lrc_content = """[00:02.50]First line at boundary
|
||||
[00:05.00]Second line
|
||||
"""
|
||||
with open(lrc_file, 'w') as f:
|
||||
f.write(lrc_content)
|
||||
|
||||
padding_added, padding_seconds = basic_karaoke_gen.lyrics_processor._detect_countdown_padding_from_lrc(lrc_file)
|
||||
|
||||
# 2.5 is the boundary - should be detected as padding
|
||||
assert padding_added is True
|
||||
assert padding_seconds == 3.0
|
||||
|
||||
def test_detect_padding_from_lrc_just_below_boundary(self, basic_karaoke_gen, temp_dir):
|
||||
"""Test detection just below the 2.5 second boundary."""
|
||||
lrc_file = os.path.join(temp_dir, 'test.lrc')
|
||||
|
||||
# Create an LRC file with first lyric at 2.4 seconds (just below boundary)
|
||||
lrc_content = """[00:02.40]First line just below boundary
|
||||
[00:05.00]Second line
|
||||
"""
|
||||
with open(lrc_file, 'w') as f:
|
||||
f.write(lrc_content)
|
||||
|
||||
padding_added, padding_seconds = basic_karaoke_gen.lyrics_processor._detect_countdown_padding_from_lrc(lrc_file)
|
||||
|
||||
# 2.4 is below boundary - should NOT be detected as padding
|
||||
assert padding_added is False
|
||||
assert padding_seconds == 0.0
|
||||
|
||||
def test_detect_padding_from_lrc_empty_file(self, basic_karaoke_gen, temp_dir):
|
||||
"""Test handling of empty LRC file."""
|
||||
lrc_file = os.path.join(temp_dir, 'test.lrc')
|
||||
|
||||
with open(lrc_file, 'w') as f:
|
||||
f.write('')
|
||||
|
||||
padding_added, padding_seconds = basic_karaoke_gen.lyrics_processor._detect_countdown_padding_from_lrc(lrc_file)
|
||||
|
||||
assert padding_added is False
|
||||
assert padding_seconds == 0.0
|
||||
|
||||
def test_detect_padding_from_lrc_no_timestamps(self, basic_karaoke_gen, temp_dir):
|
||||
"""Test handling of LRC file with no valid timestamps."""
|
||||
lrc_file = os.path.join(temp_dir, 'test.lrc')
|
||||
|
||||
lrc_content = """[ti:Test Song]
|
||||
[ar:Test Artist]
|
||||
Just text without timestamps
|
||||
More text
|
||||
"""
|
||||
with open(lrc_file, 'w') as f:
|
||||
f.write(lrc_content)
|
||||
|
||||
padding_added, padding_seconds = basic_karaoke_gen.lyrics_processor._detect_countdown_padding_from_lrc(lrc_file)
|
||||
|
||||
assert padding_added is False
|
||||
assert padding_seconds == 0.0
|
||||
|
||||
def test_detect_padding_from_lrc_missing_file(self, basic_karaoke_gen, temp_dir):
|
||||
"""Test handling of missing LRC file."""
|
||||
lrc_file = os.path.join(temp_dir, 'nonexistent.lrc')
|
||||
|
||||
padding_added, padding_seconds = basic_karaoke_gen.lyrics_processor._detect_countdown_padding_from_lrc(lrc_file)
|
||||
|
||||
assert padding_added is False
|
||||
assert padding_seconds == 0.0
|
||||
|
||||
def test_detect_padding_from_lrc_three_digit_milliseconds(self, basic_karaoke_gen, temp_dir):
|
||||
"""Test parsing LRC files with three-digit milliseconds."""
|
||||
lrc_file = os.path.join(temp_dir, 'test.lrc')
|
||||
|
||||
# Some LRC files use [mm:ss.xxx] format
|
||||
lrc_content = """[00:03.500]First line at 3.5 seconds
|
||||
[00:06.200]Second line
|
||||
"""
|
||||
with open(lrc_file, 'w') as f:
|
||||
f.write(lrc_content)
|
||||
|
||||
padding_added, padding_seconds = basic_karaoke_gen.lyrics_processor._detect_countdown_padding_from_lrc(lrc_file)
|
||||
|
||||
assert padding_added is True
|
||||
assert padding_seconds == 3.0
|
||||
|
||||
|
||||
class TestExistingFilesWithPaddingDetection:
|
||||
"""Tests for transcribe_lyrics returning padding info from existing files."""
|
||||
|
||||
def test_transcribe_lyrics_existing_files_returns_padding_info(self, basic_karaoke_gen, temp_dir):
|
||||
"""Test that transcribe_lyrics returns padding info when using existing files."""
|
||||
track_output_dir = temp_dir
|
||||
artist = "Test Artist"
|
||||
title = "Test Title"
|
||||
|
||||
# Create existing files
|
||||
video_path = os.path.join(track_output_dir, f"{artist} - {title} (With Vocals).mkv")
|
||||
lrc_path = os.path.join(track_output_dir, f"{artist} - {title} (Karaoke).lrc")
|
||||
|
||||
# Create the video file
|
||||
with open(video_path, 'w') as f:
|
||||
f.write('mock video')
|
||||
|
||||
# Create LRC file with countdown padding (first lyric at 3.5s)
|
||||
lrc_content = """[00:03.50]First line with padding
|
||||
[00:06.00]Second line
|
||||
"""
|
||||
with open(lrc_path, 'w') as f:
|
||||
f.write(lrc_content)
|
||||
|
||||
# Call transcribe_lyrics - it should detect existing files and return padding info
|
||||
result = basic_karaoke_gen.lyrics_processor.transcribe_lyrics(
|
||||
input_audio_wav=None, # Not needed when existing files found
|
||||
artist=artist,
|
||||
title=title,
|
||||
track_output_dir=track_output_dir,
|
||||
)
|
||||
|
||||
# Should return padding info from LRC detection
|
||||
assert result['countdown_padding_added'] is True
|
||||
assert result['countdown_padding_seconds'] == 3.0
|
||||
assert result['padded_audio_filepath'] is None # Original padded audio not available
|
||||
|
||||
def test_transcribe_lyrics_existing_files_no_padding(self, basic_karaoke_gen, temp_dir):
|
||||
"""Test existing files case when there's no countdown padding."""
|
||||
track_output_dir = temp_dir
|
||||
artist = "Test Artist"
|
||||
title = "Test Title"
|
||||
|
||||
# Create existing files
|
||||
video_path = os.path.join(track_output_dir, f"{artist} - {title} (With Vocals).mkv")
|
||||
lrc_path = os.path.join(track_output_dir, f"{artist} - {title} (Karaoke).lrc")
|
||||
|
||||
# Create the video file
|
||||
with open(video_path, 'w') as f:
|
||||
f.write('mock video')
|
||||
|
||||
# Create LRC file WITHOUT countdown padding (first lyric at 0.5s)
|
||||
lrc_content = """[00:00.50]First line starts immediately
|
||||
[00:03.00]Second line
|
||||
"""
|
||||
with open(lrc_path, 'w') as f:
|
||||
f.write(lrc_content)
|
||||
|
||||
result = basic_karaoke_gen.lyrics_processor.transcribe_lyrics(
|
||||
input_audio_wav=None,
|
||||
artist=artist,
|
||||
title=title,
|
||||
track_output_dir=track_output_dir,
|
||||
)
|
||||
|
||||
# Should return no padding info
|
||||
assert result['countdown_padding_added'] is False
|
||||
assert result['countdown_padding_seconds'] == 0.0
|
||||
|
||||
|
||||
class TestScanDirectoryForInstrumentals:
|
||||
"""Tests for scanning directory for existing instrumentals."""
|
||||
|
||||
def test_scan_directory_finds_clean_instrumental(self, basic_karaoke_gen, temp_dir):
|
||||
"""Test that _scan_directory_for_instrumentals finds clean instrumentals."""
|
||||
artist_title = "Test Artist - Test Song"
|
||||
|
||||
# Create a clean instrumental file
|
||||
instrumental_file = os.path.join(temp_dir, f"{artist_title} (Instrumental Clean).flac")
|
||||
with open(instrumental_file, 'w') as f:
|
||||
f.write('mock instrumental')
|
||||
|
||||
result = basic_karaoke_gen._scan_directory_for_instrumentals(temp_dir, artist_title)
|
||||
|
||||
assert result['clean_instrumental']['instrumental'] == instrumental_file
|
||||
|
||||
def test_scan_directory_finds_combined_instrumentals(self, basic_karaoke_gen, temp_dir):
|
||||
"""Test that _scan_directory_for_instrumentals finds combined instrumentals."""
|
||||
artist_title = "Test Artist - Test Song"
|
||||
|
||||
# Create combined instrumental files
|
||||
bv_file = os.path.join(temp_dir, f"{artist_title} (Instrumental +BV HTDemucs).flac")
|
||||
with open(bv_file, 'w') as f:
|
||||
f.write('mock instrumental with backing')
|
||||
|
||||
result = basic_karaoke_gen._scan_directory_for_instrumentals(temp_dir, artist_title)
|
||||
|
||||
assert 'HTDemucs' in result['combined_instrumentals']
|
||||
assert result['combined_instrumentals']['HTDemucs'] == bv_file
|
||||
|
||||
def test_scan_directory_skips_padded_files(self, basic_karaoke_gen, temp_dir):
|
||||
"""Test that _scan_directory_for_instrumentals skips already-padded files."""
|
||||
artist_title = "Test Artist - Test Song"
|
||||
|
||||
# Create both original and padded files
|
||||
original_file = os.path.join(temp_dir, f"{artist_title} (Instrumental Clean).flac")
|
||||
padded_file = os.path.join(temp_dir, f"{artist_title} (Instrumental Clean) (Padded).flac")
|
||||
|
||||
with open(original_file, 'w') as f:
|
||||
f.write('mock original')
|
||||
with open(padded_file, 'w') as f:
|
||||
f.write('mock padded')
|
||||
|
||||
result = basic_karaoke_gen._scan_directory_for_instrumentals(temp_dir, artist_title)
|
||||
|
||||
# Should return original, not padded
|
||||
assert result['clean_instrumental']['instrumental'] == original_file
|
||||
assert 'Padded' not in result['clean_instrumental']['instrumental']
|
||||
|
||||
def test_scan_directory_empty_directory(self, basic_karaoke_gen, temp_dir):
|
||||
"""Test _scan_directory_for_instrumentals on empty directory."""
|
||||
artist_title = "Test Artist - Test Song"
|
||||
|
||||
result = basic_karaoke_gen._scan_directory_for_instrumentals(temp_dir, artist_title)
|
||||
|
||||
# Should return empty structure
|
||||
assert result['clean_instrumental'].get('instrumental') is None
|
||||
assert len(result['combined_instrumentals']) == 0
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
pytest.main([__file__, '-v'])
|
||||
|
||||
@@ -299,7 +299,7 @@ def test_check_if_video_title_exists_found_confirm(mock_input, mock_fuzz_ratio,
|
||||
found_video_id = "existing_video_id"
|
||||
found_video_title = f"{ARTIST} - {TITLE} (Karaoke) Official"
|
||||
mock_youtube_service.search.return_value.list.return_value.execute.return_value = {
|
||||
"items": [{"id": {"videoId": found_video_id}, "snippet": {"title": found_video_title}}]
|
||||
"items": [{"id": {"videoId": found_video_id}, "snippet": {"title": found_video_title, "channelId": "UC_test_channel_id"}}]
|
||||
}
|
||||
mock_fuzz_ratio.return_value = 85 # High similarity
|
||||
|
||||
@@ -322,7 +322,7 @@ def test_check_if_video_title_exists_found_reject(mock_input, mock_fuzz_ratio, m
|
||||
found_video_id = "existing_video_id"
|
||||
found_video_title = f"{ARTIST} - {TITLE} (Karaoke) Official"
|
||||
mock_youtube_service.search.return_value.list.return_value.execute.return_value = {
|
||||
"items": [{"id": {"videoId": found_video_id}, "snippet": {"title": found_video_title}}]
|
||||
"items": [{"id": {"videoId": found_video_id}, "snippet": {"title": found_video_title, "channelId": "UC_test_channel_id"}}]
|
||||
}
|
||||
mock_fuzz_ratio.return_value = 85
|
||||
|
||||
@@ -344,7 +344,7 @@ def test_check_if_video_title_exists_low_similarity(mock_fuzz_ratio, mock_auth,
|
||||
found_video_id = "existing_video_id"
|
||||
found_video_title = "Completely Different Title"
|
||||
mock_youtube_service.search.return_value.list.return_value.execute.return_value = {
|
||||
"items": [{"id": {"videoId": found_video_id}, "snippet": {"title": found_video_title}}]
|
||||
"items": [{"id": {"videoId": found_video_id}, "snippet": {"title": found_video_title, "channelId": "UC_test_channel_id"}}]
|
||||
}
|
||||
mock_fuzz_ratio.return_value = 30 # Low similarity
|
||||
|
||||
@@ -367,7 +367,7 @@ def test_check_if_video_title_exists_non_interactive(mock_input, mock_fuzz_ratio
|
||||
found_video_id = "existing_video_id"
|
||||
found_video_title = f"{ARTIST} - {TITLE} (Karaoke) Official"
|
||||
mock_youtube_service.search.return_value.list.return_value.execute.return_value = {
|
||||
"items": [{"id": {"videoId": found_video_id}, "snippet": {"title": found_video_title}}]
|
||||
"items": [{"id": {"videoId": found_video_id}, "snippet": {"title": found_video_title, "channelId": "UC_test_channel_id"}}]
|
||||
}
|
||||
mock_fuzz_ratio.return_value = 85
|
||||
|
||||
@@ -392,6 +392,63 @@ def test_check_if_video_title_exists_not_found(mock_auth, finaliser_for_yt, mock
|
||||
assert finaliser_for_yt.youtube_url is None # Check initial state remains None
|
||||
assert finaliser_for_yt.skip_notifications is False
|
||||
|
||||
@patch.object(KaraokeFinalise, 'authenticate_youtube')
|
||||
@patch('thefuzz.fuzz.ratio')
|
||||
@patch('builtins.input')
|
||||
def test_check_if_video_title_exists_filters_other_channels(mock_input, mock_fuzz_ratio, mock_auth, finaliser_for_yt, mock_youtube_service):
|
||||
"""Test that videos from other channels are filtered out even if returned by search API.
|
||||
|
||||
The YouTube search API sometimes returns results from other channels even when
|
||||
channelId parameter is specified. This test verifies we filter those out.
|
||||
"""
|
||||
mock_auth.return_value = mock_youtube_service
|
||||
youtube_title = f"{ARTIST} - {TITLE} (Karaoke)"
|
||||
|
||||
# Simulate YouTube API bug: returns videos from other channels despite channelId filter
|
||||
mock_youtube_service.search.return_value.list.return_value.execute.return_value = {
|
||||
"items": [
|
||||
# Video from another channel - should be skipped
|
||||
{"id": {"videoId": "other_channel_video_1"}, "snippet": {"title": f"{ARTIST} - {TITLE}", "channelId": "UC_other_channel_1"}},
|
||||
{"id": {"videoId": "other_channel_video_2"}, "snippet": {"title": f"{ARTIST} - {TITLE} (Official)", "channelId": "UC_other_channel_2"}},
|
||||
# Video from user's channel - should be matched
|
||||
{"id": {"videoId": "my_channel_video"}, "snippet": {"title": f"{ARTIST} - {TITLE} (Karaoke)", "channelId": "UC_test_channel_id"}},
|
||||
]
|
||||
}
|
||||
mock_fuzz_ratio.return_value = 95
|
||||
mock_input.return_value = 'y'
|
||||
|
||||
exists = finaliser_for_yt.check_if_video_title_exists_on_youtube_channel(youtube_title)
|
||||
|
||||
assert exists is True
|
||||
# Should match the video from our channel, not the ones from other channels
|
||||
assert finaliser_for_yt.youtube_video_id == "my_channel_video"
|
||||
# fuzz.ratio should only be called for videos from our channel (1 video)
|
||||
assert mock_fuzz_ratio.call_count == 1
|
||||
|
||||
|
||||
@patch.object(KaraokeFinalise, 'authenticate_youtube')
|
||||
@patch('thefuzz.fuzz.ratio')
|
||||
def test_check_if_video_title_exists_all_from_other_channels(mock_fuzz_ratio, mock_auth, finaliser_for_yt, mock_youtube_service):
|
||||
"""Test that if all returned videos are from other channels, no match is found."""
|
||||
mock_auth.return_value = mock_youtube_service
|
||||
youtube_title = f"{ARTIST} - {TITLE} (Karaoke)"
|
||||
|
||||
# All results are from other channels
|
||||
mock_youtube_service.search.return_value.list.return_value.execute.return_value = {
|
||||
"items": [
|
||||
{"id": {"videoId": "other_channel_video_1"}, "snippet": {"title": f"{ARTIST} - {TITLE}", "channelId": "UC_other_channel_1"}},
|
||||
{"id": {"videoId": "other_channel_video_2"}, "snippet": {"title": f"{ARTIST} - {TITLE} (Official)", "channelId": "UC_other_channel_2"}},
|
||||
]
|
||||
}
|
||||
|
||||
exists = finaliser_for_yt.check_if_video_title_exists_on_youtube_channel(youtube_title)
|
||||
|
||||
assert exists is False
|
||||
# fuzz.ratio should never be called since all videos are filtered out
|
||||
mock_fuzz_ratio.assert_not_called()
|
||||
# Should log debug messages about skipping videos from other channels
|
||||
assert finaliser_for_yt.logger.debug.call_count >= 2
|
||||
|
||||
# --- Delete / Upload Tests ---
|
||||
|
||||
@patch.object(KaraokeFinalise, 'authenticate_youtube')
|
||||
|
||||
@@ -74,6 +74,7 @@ class TestJobStatus:
|
||||
assert JobStatus.UPLOADING == "uploading"
|
||||
assert JobStatus.NOTIFYING == "notifying"
|
||||
assert JobStatus.COMPLETE == "complete"
|
||||
assert JobStatus.PREP_COMPLETE == "prep_complete" # Batch 6: Prep-only jobs stop here
|
||||
assert JobStatus.FAILED == "failed"
|
||||
assert JobStatus.CANCELLED == "cancelled"
|
||||
assert JobStatus.ERROR == "error"
|
||||
@@ -963,10 +964,10 @@ class TestMain:
|
||||
@patch('karaoke_gen.utils.remote_cli.create_parser')
|
||||
@patch('karaoke_gen.utils.remote_cli.get_auth_token')
|
||||
@patch('karaoke_gen.utils.remote_cli.check_prerequisites')
|
||||
def test_main_finalise_only_not_supported(
|
||||
def test_main_finalise_only_requires_folder_and_args(
|
||||
self, mock_check, mock_auth, mock_create_parser
|
||||
):
|
||||
"""Test main rejects --finalise-only in remote mode."""
|
||||
"""Test main --finalise-only requires folder and artist/title args (Batch 6)."""
|
||||
mock_parser = MagicMock()
|
||||
mock_args = MagicMock()
|
||||
mock_args.service_url = "https://api.example.com"
|
||||
@@ -984,12 +985,14 @@ class TestMain:
|
||||
mock_args.filter_client_id = None
|
||||
mock_args.environment = ""
|
||||
mock_args.client_id = ""
|
||||
mock_args.args = [] # No args provided - should fail
|
||||
mock_parser.parse_args.return_value = mock_args
|
||||
mock_create_parser.return_value = mock_parser
|
||||
mock_auth.return_value = "token"
|
||||
|
||||
result = main()
|
||||
|
||||
# Should fail because no folder/artist/title provided
|
||||
assert result == 1
|
||||
|
||||
@patch('karaoke_gen.utils.remote_cli.create_parser')
|
||||
@@ -2035,3 +2038,201 @@ class TestSignedUrlUploadFlow:
|
||||
assert hasattr(client, '_get_content_type')
|
||||
assert callable(client._upload_file_to_signed_url)
|
||||
assert callable(client._get_content_type)
|
||||
|
||||
|
||||
class TestJobMonitorDownloadProgress:
|
||||
"""Tests for JobMonitor download progress display."""
|
||||
|
||||
@pytest.fixture
|
||||
def config(self):
|
||||
return Config(
|
||||
service_url="https://api.example.com",
|
||||
review_ui_url="https://review.example.com",
|
||||
poll_interval=1,
|
||||
output_dir="/tmp/output"
|
||||
)
|
||||
|
||||
@pytest.fixture
|
||||
def logger(self):
|
||||
return logging.getLogger("test")
|
||||
|
||||
@pytest.fixture
|
||||
def monitor(self, config, logger):
|
||||
client = MagicMock()
|
||||
return JobMonitor(client, config, logger)
|
||||
|
||||
def test_show_download_progress_youtube(self, monitor, caplog):
|
||||
"""Test that YouTube downloads show simple message."""
|
||||
job_data = {
|
||||
'state_data': {
|
||||
'selected_audio_provider': 'YouTube'
|
||||
}
|
||||
}
|
||||
|
||||
with caplog.at_level(logging.INFO):
|
||||
monitor._show_download_progress(job_data)
|
||||
|
||||
assert "Downloading from YouTube" in caplog.text
|
||||
|
||||
@patch('karaoke_gen.utils.remote_cli.requests.get')
|
||||
def test_show_download_progress_torrent_with_active_torrents(self, mock_get, monitor, caplog):
|
||||
"""Test that active torrents show progress details."""
|
||||
job_data = {
|
||||
'state_data': {
|
||||
'selected_audio_provider': 'Redacted'
|
||||
}
|
||||
}
|
||||
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = {
|
||||
'dependencies': {
|
||||
'transmission': {
|
||||
'available': True,
|
||||
'torrents': [{
|
||||
'progress': 45.5,
|
||||
'peers': 3,
|
||||
'download_speed': 1250.0,
|
||||
'stalled': False
|
||||
}]
|
||||
}
|
||||
}
|
||||
}
|
||||
mock_get.return_value = mock_response
|
||||
|
||||
with caplog.at_level(logging.INFO):
|
||||
monitor._show_download_progress(job_data)
|
||||
|
||||
assert "Downloading from Redacted" in caplog.text
|
||||
assert "45.5%" in caplog.text
|
||||
assert "1250.0 KB/s" in caplog.text
|
||||
assert "3 peers" in caplog.text
|
||||
|
||||
@patch('karaoke_gen.utils.remote_cli.requests.get')
|
||||
def test_show_download_progress_torrent_stalled(self, mock_get, monitor, caplog):
|
||||
"""Test that stalled torrents show warning."""
|
||||
job_data = {
|
||||
'state_data': {
|
||||
'selected_audio_provider': 'OPS'
|
||||
}
|
||||
}
|
||||
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = {
|
||||
'dependencies': {
|
||||
'transmission': {
|
||||
'available': True,
|
||||
'torrents': [{
|
||||
'progress': 0.0,
|
||||
'peers': 0,
|
||||
'download_speed': 0,
|
||||
'stalled': True
|
||||
}]
|
||||
}
|
||||
}
|
||||
}
|
||||
mock_get.return_value = mock_response
|
||||
|
||||
with caplog.at_level(logging.INFO):
|
||||
monitor._show_download_progress(job_data)
|
||||
|
||||
assert "STALLED" in caplog.text
|
||||
assert "no peers" in caplog.text
|
||||
|
||||
@patch('karaoke_gen.utils.remote_cli.requests.get')
|
||||
def test_show_download_progress_no_torrents(self, mock_get, monitor, caplog):
|
||||
"""Test message when no active torrents."""
|
||||
job_data = {
|
||||
'state_data': {
|
||||
'selected_audio_provider': 'Redacted'
|
||||
}
|
||||
}
|
||||
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = {
|
||||
'dependencies': {
|
||||
'transmission': {
|
||||
'available': True,
|
||||
'torrents': []
|
||||
}
|
||||
}
|
||||
}
|
||||
mock_get.return_value = mock_response
|
||||
|
||||
with caplog.at_level(logging.INFO):
|
||||
monitor._show_download_progress(job_data)
|
||||
|
||||
assert "Starting download" in caplog.text
|
||||
|
||||
@patch('karaoke_gen.utils.remote_cli.requests.get')
|
||||
def test_show_download_progress_transmission_unavailable(self, mock_get, monitor, caplog):
|
||||
"""Test warning when Transmission not available."""
|
||||
job_data = {
|
||||
'state_data': {
|
||||
'selected_audio_provider': 'Redacted'
|
||||
}
|
||||
}
|
||||
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 200
|
||||
mock_response.json.return_value = {
|
||||
'dependencies': {
|
||||
'transmission': {
|
||||
'available': False
|
||||
}
|
||||
}
|
||||
}
|
||||
mock_get.return_value = mock_response
|
||||
|
||||
with caplog.at_level(logging.INFO):
|
||||
monitor._show_download_progress(job_data)
|
||||
|
||||
assert "not available" in caplog.text
|
||||
|
||||
@patch('karaoke_gen.utils.remote_cli.requests.get')
|
||||
def test_show_download_progress_request_error(self, mock_get, monitor, caplog):
|
||||
"""Test fallback message on request error."""
|
||||
job_data = {
|
||||
'state_data': {
|
||||
'selected_audio_provider': 'Redacted'
|
||||
}
|
||||
}
|
||||
|
||||
mock_get.side_effect = Exception("Connection error")
|
||||
|
||||
with caplog.at_level(logging.INFO):
|
||||
monitor._show_download_progress(job_data)
|
||||
|
||||
assert "Downloading audio" in caplog.text
|
||||
|
||||
@patch('karaoke_gen.utils.remote_cli.requests.get')
|
||||
def test_show_download_progress_http_error(self, mock_get, monitor, caplog):
|
||||
"""Test fallback on non-200 HTTP response."""
|
||||
job_data = {
|
||||
'state_data': {
|
||||
'selected_audio_provider': 'Redacted'
|
||||
}
|
||||
}
|
||||
|
||||
mock_response = MagicMock()
|
||||
mock_response.status_code = 500
|
||||
mock_get.return_value = mock_response
|
||||
|
||||
with caplog.at_level(logging.INFO):
|
||||
monitor._show_download_progress(job_data)
|
||||
|
||||
assert "Downloading from Redacted" in caplog.text
|
||||
|
||||
def test_show_download_progress_missing_provider(self, monitor, caplog):
|
||||
"""Test handling of missing provider in state_data."""
|
||||
job_data = {
|
||||
'state_data': {}
|
||||
}
|
||||
|
||||
with caplog.at_level(logging.INFO):
|
||||
monitor._show_download_progress(job_data)
|
||||
|
||||
# Should use 'unknown' as default
|
||||
assert "unknown" in caplog.text.lower() or "Downloading" in caplog.text
|
||||