Compare commits

...
Author SHA1 Message Date
Andrew Beveridge 398c100785 Add Modal web application with separated frontend/backend
- Add Modal backend (app.py, core.py) with GPU-powered processing
- Add static frontend in docs/ for GitHub Pages deployment
- Frontend communicates with Modal API via CORS
- Supports custom domain deployment (gen.nomadkaraoke.com)
- Comprehensive admin dashboard with real-time monitoring
2025-07-02 15:29:41 -04:00
Andrew Beveridge 06397b7a60 Added modal migration plan doc 2025-07-02 01:21:24 -04:00
Andrew Beveridge 8c283c7987 Added architecture documentation 2025-07-02 01:21:00 -04:00
Andrew Beveridge f3f508b563 Simplify CI pipeline to replace etils publish action with single build 2025-07-01 23:37:23 -04:00
Andrew Beveridge c9c1456dbb Fix CI disk space fail 2025-07-01 23:28:42 -04:00
Andrew Beveridge efa9e85121 Fixed integration test 2025-07-01 23:16:42 -04:00
Andrew Beveridge 7c6e6992b9 Hopefully fix CI 2025-07-01 16:38:49 -04:00
Andrew Beveridge 54ecde878f Fixed integration tests 2025-07-01 15:53:09 -04:00
Andrew Beveridge aada7c84e7 Fix bug with lyrics_title param 2025-07-01 14:11:39 -04:00
Andrew Beveridge cc76db0c04 Hopefully fix CI, upgrade to latest version of lyrics-transcriber 2025-06-29 20:59:04 -04:00
Andrew Beveridge aa9a6e8659 Fix unit test mocking to fix CI 2025-06-29 16:55:50 -04:00
Andrew Beveridge 9169e5b4a7 Restructured tests, fixed support for python 3.13, updated to latest audio-separator and numpy etc. 2025-06-29 16:36:59 -04:00
Andrew Beveridge 9599dd595e Fixed integration tests by generating background images for use in styles.json and copying files to /tmp for test 2025-06-29 16:12:45 -04:00
Andrew Beveridge 4775d97d3f Hopefully fix CI 2025-06-29 15:22:22 -04:00
Andrew Beveridge bd42951779 Added badges / shields to readme 2025-06-29 15:12:30 -04:00
Andrew Beveridge d53d015e72 Fixed tests, tidied up pytest config to match other projects 2025-06-29 15:05:45 -04:00
Andrew Beveridge 193f8367b8 Update to latest pytorch and lyrics-transcriber 2025-06-29 02:09:25 -04:00
Andrew Beveridge ☄️ 3d3393ab89 Merge pull request #2 from nomadkaraoke/test-everything
Major refactor, rename to Karaoke Gen, implement tests for everything
2025-06-28 18:35:39 -04:00
62 changed files with 6266 additions and 2455 deletions

No files matched your search

-51
View File
@@ -1,51 +0,0 @@
name: Auto-publish
on: [push, workflow_dispatch]
jobs:
# Auto-publish when version is increased
publish-pypi:
# Only publish on `main` branch
if: github.ref == 'refs/heads/main'
runs-on: ubuntu-latest
permissions: # Don't forget permissions
contents: write
steps:
- uses: etils-actions/pypi-auto-publish@v1
with:
pypi-token: ${{ secrets.PYPI_API_TOKEN }}
gh-token: ${{ secrets.GITHUB_TOKEN }}
parse-changelog: false
# build-windows:
# runs-on: windows-latest
# steps:
# - uses: actions/checkout@v2
# - name: Set up Python
# uses: actions/setup-python@v2
# with:
# python-version: '3.9'
# - name: Install dependencies with Poetry
# run: |
# pip install poetry
# poetry install
# - name: Download ffmpeg binary
# run: python platform/download_ffmpeg.py
# - name: Build EXE with PyInstaller
# run: poetry run pyinstaller karaoke-gen.spec
# - name: Upload EXE as Artifact
# uses: actions/upload-artifact@v2
# with:
# name: karaoke-gen-windows
# path: |
# build/
# *.exe
# */*.exe
+132
View File
@@ -0,0 +1,132 @@
name: Test and Publish
on: [push, pull_request, workflow_dispatch]
jobs:
test:
runs-on: ubuntu-latest
strategy:
matrix:
python-version: ['3.13']
steps:
- uses: actions/checkout@v3
- name: Set up Python ${{ matrix.python-version }}
uses: actions/setup-python@v5
with:
python-version: ${{ matrix.python-version }}
- name: Install Poetry
uses: snok/install-poetry@v1
with:
virtualenvs-create: true
virtualenvs-in-project: true
- name: Install dependencies
run: |
poetry install --with dev
- name: Install system dependencies
run: |
sudo apt-get update
sudo apt-get install -y ffmpeg
- name: Install spaCy language models
run: |
poetry run python -m spacy download en_core_web_sm
- name: Run unit tests
run: |
poetry run pytest tests/unit/ -v --cov=karaoke_gen --cov-report=xml --cov-report=term-missing --cov-fail-under=70
- name: Upload coverage reports
uses: codecov/codecov-action@v5
with:
token: ${{ secrets.CODECOV_TOKEN }}
files: ./coverage.xml
flags: unittests
name: codecov-umbrella
- name: Run integration tests
run: |
poetry run pytest tests/integration/ -v
- name: Build package
run: |
poetry build
- name: Free Disk Space (GHA Ubuntu Runner)
uses: jlumbroso/free-disk-space@main
with:
# this might remove tools that are actually needed,
# if set to "true" but frees about 6 GB
tool-cache: false
# all of these default to true, but feel free to set to
# "false" if necessary for your workflow
android: true
haskell: true
dotnet: false
large-packages: false
docker-images: false
swap-storage: false
- name: Test package installation
run: |
pip install dist/*.whl
python -m karaoke_gen.utils.gen_cli --help
- if: github.ref == 'refs/heads/main' && github.event_name == 'push'
name: Publish to PyPI
run: |
echo "📦 Publishing the following files to PyPI:"
ls -la dist/
echo "🚀 Publishing to PyPI..."
poetry config pypi-token.pypi ${{ secrets.PYPI_API_TOKEN }}
poetry publish
- if: github.ref == 'refs/heads/main' && github.event_name == 'push'
name: Extract version
id: extract_version
run: |
VERSION=$(poetry version --short)
echo "version=$VERSION" >> $GITHUB_OUTPUT
echo "📋 Extracted version: $VERSION"
- if: github.ref == 'refs/heads/main' && github.event_name == 'push'
name: Create Git Tag
run: |
git config user.name github-actions
git config user.email github-actions@github.com
git tag -a "v${{ steps.extract_version.outputs.version }}" -m "Release v${{ steps.extract_version.outputs.version }}"
git push origin "v${{ steps.extract_version.outputs.version }}"
- if: github.ref == 'refs/heads/main' && github.event_name == 'push'
name: Create GitHub Release
uses: softprops/action-gh-release@v1
with:
tag_name: "v${{ steps.extract_version.outputs.version }}"
name: "v${{ steps.extract_version.outputs.version }}"
body: |
## Changes in v${{ steps.extract_version.outputs.version }}
This release was automatically created from the main branch.
### Installation
```bash
pip install karaoke-gen==${{ steps.extract_version.outputs.version }}
```
### Assets
- Python package published to PyPI
- Frontend assets included in the package
For detailed changes, see the commit history.
draft: false
prerelease: false
files: |
dist/*.whl
dist/*.tar.gz
+1 -1
View File
@@ -9,7 +9,7 @@ audio/
lyrics/
karaoke/
tests/outputs
input
# Byte-compiled / optimized / DLL files
__pycache__/
+271
View File
@@ -0,0 +1,271 @@
# Karaoke Generator - Technical Architecture Overview
## Core Functionality
The Karaoke Generator is a comprehensive pipeline that transforms audio files (local files or YouTube URLs) into professional karaoke videos with synchronized lyrics. It handles the complete workflow from raw audio input to final deliverable files.
## Main Processing Pipeline
### 1. **Input Processing**
- **Input Sources**: Local audio files (FLAC, WAV, MP3) or YouTube URLs
- **Metadata**: Artist name and song title (can search YouTube if URL not provided)
- **File Handling**: Converts input media to WAV format for processing
### 2. **Parallel Processing Phase**
The tool runs two major operations concurrently:
#### **Audio Separation** (Compute-Intensive)
- **Models Used**: Multiple AI models for different separation tasks:
- `model_bs_roformer_ep_317_sdr_12.9755.ckpt` (clean instrumental)
- `htdemucs_6s.yaml` (6-stem separation)
- `mel_band_roformer_karaoke_aufr33_viperx_sdr_10.1956.ckpt` (backing vocals)
- **Hardware Requirements**:
- GPU acceleration preferred (uses Apple Silicon MPS, CUDA, or CPU fallback)
- Significant processing time (12+ minutes for a ~5-minute song)
- Large model files (requires dedicated model storage directory)
- **Output**: Multiple stems (vocals, instrumental, backing vocals, drums, bass, etc.)
#### **Lyrics Processing**
- **Lyrics Fetching**: Genius API integration for lyric retrieval
- **Transcription**: AudioShake API for timing synchronization
- **Correction**: AI-powered lyrics correction using reference sources
- **Processing Time**: ~5-6 minutes for transcription + correction
### 3. **Human Review Phase** (Interactive)
- **Web Interface**: React-based web UI launches in browser
- **Functionality**: Users review and correct automatically transcribed lyrics
- **Timing**: Allows fine-tuning of lyric timing and text accuracy
- **Critical Dependency**: Requires human interaction - cannot be fully automated
### 4. **Output Generation**
Creates multiple synchronized lyric formats:
- **LRC files** (timed lyrics for media players)
- **CDG files** (CD+Graphics karaoke format)
- **ASS/SSA files** (Advanced SubStation Alpha for video)
- **Plain text files** (reference versions)
- **Video files** with lyric overlays
### 5. **Video Production**
- **Title/End Screens**: Generated with custom branding and styling
- **Video Composition**: Combines title + karaoke content + end screen
- **Multiple Formats**:
- 4K lossless (PCM audio)
- 4K lossy (AAC audio)
- 720p compressed
- MKV with FLAC audio (YouTube optimized)
## External API Dependencies
### **Required APIs**
1. **AudioShake API**: Core dependency for lyrics transcription/timing
- Upload audio files (can be large - 280+ seconds in example)
- Wait for processing completion
- Retrieve timed transcription data
2. **Genius API**: Lyrics text retrieval
- Search by artist/title
- Fetch reference lyrics text
3. **YouTube Data API v3**: Video management
- Upload videos
- Set thumbnails
- Check for existing videos
### **Optional Integrations**
- **Discord Webhooks**: Completion notifications
- **Email APIs**: Draft creation for delivery notifications
- **Rclone**: Cloud storage synchronization (Google Drive, Dropbox)
## User Interaction Points
### **Critical Interactive Elements**
1. **Instrumental Selection**:
- Terminal-based choice between separation models
- Presents numbered options (e.g., "Choose instrumental audio file: [1]/2")
- Requires user input to proceed
2. **Human Review Interface**:
- Launches React web application
- Browser-based editing of transcribed lyrics
- Users can modify text and timing
- Must submit reviewed data to continue processing
3. **Confirmation Prompts**:
- Feature confirmation before finalization
- Video quality check before proceeding
- Manual approval gates throughout process
## Computing Requirements
### **Hardware Needs**
- **GPU/Accelerated Processing**:
- NVIDIA CUDA (preferred)
- Apple Silicon MPS (Metal Performance Shaders)
- CPU fallback available but significantly slower
- **Storage**:
- Large model files (multiple GB)
- Temporary processing files during separation
- Final output files (videos can be several GB each)
- **Memory**: Significant RAM for audio processing (8GB+ recommended)
- **CPU**: Multi-core processing for parallel operations
### **Processing Time Estimates**
Based on a ~5-minute song:
- Audio separation: ~15 minutes (GPU) / 45+ minutes (CPU)
- Lyrics transcription: ~5 minutes (API dependent)
- Human review: ~5-15 minutes (user-dependent)
- Video encoding: ~7 minutes
- Upload/organization: ~5 minutes
- **Total**: 32-47 minutes per track
### **External Dependencies**
- **FFmpeg**: Video/audio processing and encoding
- **Python 3.10+**: Runtime environment
- **PyTorch**: AI model execution framework
- **Audio Processing Libraries**: librosa, soundfile, pydub
- **Web Framework**: For human review interface
- **Rclone**: Cloud storage synchronization (optional)
## File Input/Output Structure
### **Input Files**
- **Audio Sources**: Any FFmpeg-supported format (FLAC, WAV, MP3, etc.)
- **Configuration**:
- Style parameters JSON (branding, colors, fonts)
- YouTube credentials and templates
- Email templates
- **Assets**:
- Background images for title/end screens
- Custom fonts
- Branding elements
### **Working Directory Structure**
```
Artist - Song Title/
├── Artist - Song Title (Original).wav # Converted input
├── Artist - Song Title (Title).mov # Generated title screen
├── Artist - Song Title (End).mov # Generated end screen
├── Artist - Song Title (With Vocals).mkv # Karaoke video with vocals
├── Artist - Song Title (Karaoke).lrc # Timed lyrics
├── stems/ # Audio separation outputs
│ ├── Artist - Song Title (Vocals ...).flac
│ ├── Artist - Song Title (Drums ...).flac
│ └── ...
└── lyrics/ # Lyrics processing files
├── Artist - Song Title (Lyrics Genius).txt
├── Artist - Song Title (Lyrics Corrected).txt
├── Artist - Song Title (Karaoke).cdg
└── ...
```
### **Final Output Files**
- **Video Formats**:
- 4K lossless MP4 (PCM audio)
- 4K lossy MP4 (AAC audio)
- 720p MP4 (compressed for sharing)
- MKV with FLAC audio (YouTube optimized)
- **Karaoke Packages**:
- CDG+MP3 ZIP (CD+Graphics format)
- TXT+MP3 ZIP (text-based karaoke)
- **Individual Formats**: LRC, CDG, ASS subtitle files
### **Organization System**
- **Brand-coded directories**: `BRAND-####` sequence numbering
- **Automated file organization** to configured paths
- **Public sharing directory** with cloud synchronization
- **Multi-location backup** integration
## Current Architecture Limitations for Cloud Deployment
The tool currently assumes:
### **Local System Dependencies**
- Local file system access for model storage and temporary files
- Terminal-based user interaction for choices and confirmations
- Browser access on same machine for web UI components
- Local application launching (e.g., Audacity integration)
- Direct file system paths for organization and sharing
### **Interactive Elements**
- Terminal prompts requiring keyboard input
- Web browser launching on local machine
- File system browsing for path selection
- Manual approval gates that pause execution
### **Resource Management**
- Static model file paths
- Local GPU/hardware detection and usage
- Temporary file cleanup assumes local storage
- Process management tied to single-machine execution
## Cloud Deployment Challenges
Key architectural changes needed for cloud deployment:
1. **User Interface Migration**
- Replace terminal interactions with web-based interfaces
- Implement session management for multi-step workflows
- Handle asynchronous processing with status updates
2. **Resource Management**
- Dynamic GPU allocation and queuing
- Distributed model file storage and caching
- Scalable temporary storage management
- Container orchestration for processing jobs
3. **Interactive Workflow Adaptation**
- Web-based instrumental selection interface
- Embedded lyrics review interface
- Progress tracking and resumable workflows
- Real-time collaboration features
4. **File Management**
- Cloud storage integration for inputs/outputs
- Streaming upload/download for large files
- Multi-tenant file isolation
- Automated cleanup and retention policies
5. **API Integration Scaling**
- Rate limiting and quota management
- API key rotation and security
- Fallback providers for critical services
- Cost optimization for external API usage
This architecture provides a foundation for understanding the current system's capabilities and the considerations needed for cloud deployment transformation.
## Approach 1: The Managed Platform (Easier Start)
This approach uses "Platform as a Service" (PaaS) providers that specialize in running containerized applications and backend tasks, including those requiring GPUs. This abstracts away much of the server management.
A great fit for this would be Modal. It's designed almost exactly for your use case: turning Python scripts into serverless functions that can be called via an API and can have GPUs attached.
How it would work with Modal:
Refactor karaoke-gen: You'd wrap your core processing logic in functions within a Modal script. You would use decorators to specify requirements like the GPU type (@modal.function(gpu="any")), secrets (API keys), and shared storage for your models.
Web Frontend: You could build a simple web app using Flask or FastAPI that also runs on Modal. This app would serve your HTML/React interface.
Job Submission: When you hit "Generate" in the web app, it calls your Modal GPU function asynchronously (my_gpu_function.spawn(...)). This immediately returns a job ID.
State Management: The worker function updates its status in a shared dictionary or a simple database. The web app can have an endpoint that you poll from the frontend to check on the job's progress.
Lyric Review: When the job reaches the AWAITING_REVIEW state, it saves the transcribed lyrics to storage. The web app loads this data into your React editor. When you submit your corrections, it saves the updated data and triggers the next part of the Modal function to resume the job.
Technology Stack:
Backend/Worker: Python on Modal
Web Framework: Flask or FastAPI (also on Modal)
Frontend: Your existing React app, served by the web framework.
Storage: Modal's Network File System for models and temporary files.
Pros & Cons:
✅ Fastest to implement: Drastically reduces infrastructure setup.
✅ Cost-effective for sporadic use: You only pay for the GPU while it's actively processing a job.
❌ Less control: You're dependent on the Modal platform's features and pricing.
+326
View File
@@ -0,0 +1,326 @@
This is a detailed, step-by-step plan for an IDE-based AI agent to refactor your `karaoke-gen` CLI tool into a multi-step, GPU-powered web application using Modal.
This plan prioritizes minimal refactoring of your core generation logic and focuses on wrapping it in the necessary Modal structure to achieve your goal.
-----
### **Objective:**
Transform the `karaoke-gen` Python CLI tool into a web-based solution hosted on Modal. The solution will feature a simple web interface for job submission and lyric review, with all heavy processing (audio separation, video rendering) handled by GPU-powered, serverless functions.
### **Core Principles:**
1. **Isolate Core Logic:** Your existing processing functions are valuable. We will treat them as a library, changing as little as possible internally.
2. **Embrace Asynchronicity:** Web requests must be fast. All long-running tasks will be "spawned" as background jobs on Modal, allowing the web UI to remain responsive.
3. **Use Persistent Storage:** AI Models and job artifacts (audio, lyrics, videos) will be stored in a `modal.Volume` to persist them between function runs and share them across different steps.
4. **Manage State:** The multi-step process (e.g., waiting for human lyric review) will be managed using a `modal.Dict` as a simple, serverless database to track the state of each job.
-----
### \#\# Phase 1: Setup and Initial Refactoring
**Goal:** Prepare the codebase and set up the basic Modal application structure.
**Instructions for the Agent:**
1. **Install Modal:** Ensure the `modal` client is installed in the development environment. If not, run:
```bash
pip install modal
```
2. **Set Up Modal Token:** Authenticate with the Modal service by running the following command in the terminal. This will require a one-time browser login.
```bash
modal setup
```
3. **Create New Project Files:**
* Create a new file named `app.py`. This will be the main entry point for our Modal application.
* Create a file named `core.py`.
4. **Isolate Core Logic:**
* Move the primary processing functions from your `karaoke-gen` script into `core.py`. This includes functions for audio separation, lyrics fetching, transcription, and video generation.
* Modify these functions to **remove all `print()` statements and `input()` prompts**. They should now accept all necessary information as function arguments and return results (like file paths or data structures) instead of printing to the console.
5. **Create a Persistent Volume for Models:** In the project's root directory, run the following one-time command in your terminal. This creates a remote, persistent filesystem on Modal to store your large AI models so they aren't downloaded every single time.
```bash
modal volume create karaoke-models
```
* Next, upload your models to this volume. Create a temporary script called `upload_models.py`:
```python
import modal
volume = modal.Volume.from_name("karaoke-models")
local_model_dir = "./path/to/your/models" # Change this path
def upload():
import os
model_dest_dir = "/models"
os.makedirs(model_dest_dir, exist_ok=True)
for model_file in os.listdir(local_model_dir):
source_path = os.path.join(local_model_dir, model_file)
dest_path = os.path.join(model_dest_dir, model_file)
with open(source_path, "rb") as f:
volume.write_file(dest_path, f.read())
print(f"Uploaded {model_file}")
volume.commit()
if __name__ == "__main__":
upload()
```
* Run this script with `python upload_models.py`. After it completes, you can delete the script.
-----
### \#\# Phase 2: Create the Modal App and Worker Functions
**Goal:** Define the Modal application, its environment, and the GPU-powered functions that will execute the karaoke generation steps.
**Instructions for the Agent:**
1. **Define the Modal App in `app.py`:**
* At the top of `app.py`, define the basic app structure, including the custom Docker image, secrets, and volumes.
<!-- end list -->
```python
import modal
import uuid
from pathlib import Path
# Define the environment for our functions
karaoke_image = (
modal.Image.debian_slim(python_version="3.10")
.pip_install(
"demucs", "youtube-dl", "pydub", "ffmpeg-python", "torch", "torchaudio",
"requests", "genius", "faster-whisper", "numpy" # Add all your project's dependencies
)
.apt_install("ffmpeg")
)
# Define the Modal app
app = modal.App("karaoke-generator-webapp")
# Define persistent storage volumes
model_volume = modal.Volume.from_name("karaoke-models", create_if_missing=True)
output_volume = modal.Volume.from_name("karaoke-output", create_if_missing=True)
# Define a serverless dictionary to hold job states
job_status_dict = modal.Dict.from_name("karaoke-job-statuses", create_if_missing=True)
# Mount volumes to a specific path inside the container
VOLUME_CONFIG = {
"/models": model_volume,
"/output": output_volume
}
```
2. **Create the GPU Worker Function:**
* In `app.py`, create a main processing function decorated with `@app.function`. This function will perform the first heavy step: audio separation and transcription.
* This function must be *asynchronous* and should accept a unique `job_id` and the song details.
<!-- end list -->
```python
@app.function(
image=karaoke_image,
gpu="any", # Request any available GPU
volumes=VOLUME_CONFIG,
secrets=[modal.Secret.from_name("my-api-keys")], # Create this in the Modal UI for Genius/AudioShake/etc.
timeout=1800 # 30 minutes
)
def process_part_one(job_id: str, youtube_url: str):
from core import download_and_prep_audio, run_audio_separation, transcribe_lyrics
job_status_dict[job_id] = {"status": "processing_audio", "progress": 10}
# Paths inside the container
output_dir = Path(f"/output/{job_id}")
output_dir.mkdir(exist_ok=True)
# 1. Download and Separate Audio
original_audio_path = download_and_prep_audio(youtube_url, output_dir)
instrumental_path, vocals_path = run_audio_separation(original_audio_path, "/models")
job_status_dict[job_id] = {"status": "transcribing", "progress": 50}
# 2. Transcribe
transcription_data = transcribe_lyrics(vocals_path) # Assumes a function in core.py
# 3. Save artifacts and update state
output_volume.write_file(f"{job_id}/transcription_raw.json", transcription_data)
output_volume.commit()
job_status_dict[job_id] = {"status": "awaiting_review", "progress": 75}
return "Awaiting lyric review."
```
3. **Create the Finalization Function:**
* Create a second function for the steps that happen *after* human review.
<!-- end list -->
```python
@app.function(
image=karaoke_image,
gpu="any", # Video rendering can also benefit from a GPU
volumes=VOLUME_CONFIG,
timeout=1800
)
def process_part_two(job_id: str):
from core import generate_video_assets
job_status_dict[job_id] = {"status": "rendering", "progress": 80}
# Load corrected lyrics and instrumental from the volume
corrected_lyrics = output_volume.read_file(f"{job_id}/lyrics_corrected.json")
instrumental_path = f"/output/{job_id}/instrumental.wav"
# Generate final video
video_path = generate_video_assets(corrected_lyrics, instrumental_path)
job_status_dict[job_id] = {"status": "complete", "progress": 100, "video_url": f"/output/{job_id}/final.mp4"}
output_volume.commit()
return "Job complete."
```
-----
### \#\# Phase 3: Build the Web Interface
**Goal:** Create API endpoints using Modal to submit jobs, check status, and handle the lyric review process.
**Instructions for the Agent:**
1. **Create a FastAPI Web Endpoint:**
* In `app.py`, we will create a web frontend using FastAPI, which is seamlessly integrated into Modal.
<!-- end list -->
```python
from fastapi import FastAPI, Request, Form
from fastapi.responses import HTMLResponse, JSONResponse
web_app = FastAPI()
# Basic HTML for the UI
HTML_TEMPLATE = """
<!DOCTYPE html>
<html>
<head><title>Karaoke Gen</title></head>
<body>
<h1>Submit a new Karaoke Job</h1>
<form action="/submit" method="post">
<input type="text" name="url" placeholder="YouTube URL" size="50">
<button type="submit">Generate</button>
</form>
<h2>Job Statuses</h2>
<div id="jobs">Loading...</div>
<script>
async function updateJobs() {
const response = await fetch('/jobs');
const jobs = await response.json();
const jobsDiv = document.getElementById('jobs');
jobsDiv.innerHTML = '';
for (const [job_id, data] of Object.entries(jobs)) {
jobsDiv.innerHTML += `<p><b>${job_id}</b>: ${data.status} (${data.progress}%)</p>`;
if (data.status === 'awaiting_review') {
jobsDiv.innerHTML += `<a href="/review/${job_id}" target="_blank">Review Lyrics</a>`;
}
}
}
setInterval(updateJobs, 5000);
updateJobs();
</script>
</body>
</html>
"""
@app.get("/", response_class=HTMLResponse)
def home():
return HTML_TEMPLATE
@app.post("/submit")
async def submit_job(url: str = Form(...)):
job_id = str(uuid.uuid4())[:8]
job_status_dict[job_id] = {"status": "queued", "progress": 0}
# Spawn the long-running job in the background
process_part_one.spawn(job_id, url)
return JSONResponse({"status": "success", "job_id": job_id}, status_code=202)
@app.get("/jobs")
async def get_all_job_statuses():
return dict(job_status_dict.items())
# This is a placeholder for your React app.
# For now, it's a simple form.
@app.get("/review/{job_id}", response_class=HTMLResponse)
async def review_lyrics_page(job_id: str):
# In a real app, this would load data into your React component
raw_lyrics = output_volume.read_file(f"{job_id}/transcription_raw.json").decode()
return f"""
<h1>Review Lyrics for {job_id}</h1>
<form action="/review/{job_id}" method="post">
<textarea name="lyrics" rows="20" cols="80">{raw_lyrics}</textarea><br>
<button type="submit">Approve and Render Video</button>
</form>
"""
@app.post("/review/{job_id}")
async def submit_review(job_id: str, lyrics: str = Form(...)):
# Save the corrected lyrics
output_volume.write_file(f"{job_id}/lyrics_corrected.json", lyrics.encode())
output_volume.commit()
# Spawn the second part of the job
process_part_two.spawn(job_id)
return JSONResponse({"status": "Final rendering started"}, status_code=202)
```
2. **Mount the Web App:**
* Finally, at the bottom of `app.py`, mount the FastAPI application to the Modal app.
<!-- end list -->
```python
@app.function()
def web_endpoint():
return web_app
```
-----
### \#\# Phase 4: Deployment and Iteration
**Goal:** Run the application locally for testing and deploy it for production access.
**Instructions for the Agent:**
1. **Run for Development:** To test the application, run the following command in your terminal. This will create a temporary, live-reloading URL.
```bash
modal serve app.py
```
* You can now access the UI from the provided URL, submit jobs, and see the workflow in action. Check the logs in your terminal for debugging information from the worker functions.
2. **Deploy for Production:** Once you are satisfied with the functionality, deploy it to a permanent URL.
```bash
modal deploy app.py
```
* Modal will provide a persistent URL for your web application. You can then point your `gen.nomadkaraoke.com` subdomain to this URL using a CNAME record in your DNS settings. Modal's documentation provides instructions for setting up custom domains.
+27 -3
View File
@@ -1,10 +1,15 @@
# Karaoke Gen
# Karaoke Generator 🎶 🎥 🚀
Generate karaoke videos with synchronized lyrics. Handles the entire process from downloading audio and lyrics to creating the final video with title screens.
![PyPI - Version](https://img.shields.io/pypi/v/karaoke-gen)
![Python Version](https://img.shields.io/badge/python-3.10+-blue)
![Tests](https://github.com/nomadkaraoke/karaoke-gen/workflows/Test%20and%20Publish/badge.svg)
![Test Coverage](https://codecov.io/gh/nomadkaraoke/karaoke-gen/branch/main/graph/badge.svg)
Generate karaoke videos with instrumental audio and synchronized lyrics. Handles the entire process from downloading audio and lyrics to creating the final video with title screens, uploading the resulting video to YouTube.
## Overview
Karaoke Gen is a comprehensive tool for creating high-quality karaoke videos. It automates the entire workflow:
Karaoke Generator is a comprehensive tool for creating high-quality karaoke videos. It automates the entire workflow:
1. **Download** audio and lyrics for a specified song
2. **Separate** audio stems (vocals, instrumental)
@@ -90,6 +95,25 @@ For a complete list of options:
karaoke-gen --help
```
## Development
### Running Tests
The project uses pytest for testing with unit and integration tests:
```bash
# Run all tests (unit tests first, then integration tests)
pytest
# Run only unit tests (fast feedback during development)
pytest -m "not integration"
# Run only integration tests (comprehensive end-to-end testing)
pytest -m integration
```
Unit tests run quickly and provide fast feedback, while integration tests are slower but test the full workflow end-to-end.
## License
MIT
+634
View File
@@ -0,0 +1,634 @@
"""
Modal Karaoke Generator API Backend
This module contains the Modal application structure for running karaoke generation
as serverless functions with GPU acceleration and API endpoints for the frontend.
"""
import modal
import uuid
import json
import traceback
import datetime
from pathlib import Path
from typing import Dict, Any, List, Optional
from fastapi import FastAPI, Request, Form, HTTPException
from fastapi.responses import JSONResponse, FileResponse
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
# Define the environment for our functions - using Python 3.13 for latest features
karaoke_image = (
modal.Image.debian_slim(python_version="3.13")
.pip_install([
# Core dependencies
"torch>=2.7",
"requests>=2",
"beautifulsoup4>=4",
"yt-dlp",
"lyricsgenius>=3",
"fetch-lyrics-from-genius>=0.1",
"pillow>=10.1",
"google-api-python-client",
"google-auth",
"google-auth-oauthlib",
"google-auth-httplib2",
"thefuzz>=0.22",
"numpy>=2",
"audio-separator[cpu]>=0.34.0",
"lyrics-converter>=0.2.1",
"lyrics-transcriber>=0.54",
"kbputils>=0.0.12",
"fuzzywuzzy>=0.18",
"ffmpeg-python>=0.2.0",
"pydub>=0.25",
"opencv-python>=4.8",
"openai-whisper>=20240930",
"soundfile>=0.12",
"librosa>=0.10",
"demucs>=4.0.1",
# FastAPI dependencies
"fastapi>=0.104.0",
"uvicorn>=0.24.0",
"python-multipart>=0.0.6",
])
.apt_install([
"ffmpeg",
"libsndfile1",
"libsox-dev",
"sox",
])
.add_local_dir("karaoke_gen", "/root/karaoke_gen")
.add_local_file("core.py", "/root/core.py")
)
# Define the Modal app
app = modal.App("karaoke-generator-webapp")
# Define persistent storage volumes
model_volume = modal.Volume.from_name("karaoke-models", create_if_missing=True)
output_volume = modal.Volume.from_name("karaoke-output", create_if_missing=True)
# Define serverless dictionaries to hold job states and logs
job_status_dict = modal.Dict.from_name("karaoke-job-statuses", create_if_missing=True)
job_logs_dict = modal.Dict.from_name("karaoke-job-logs", create_if_missing=True)
# Mount volumes to specific paths inside the container
VOLUME_CONFIG = {
"/models": model_volume,
"/output": output_volume
}
# Pydantic models for API requests
class JobSubmissionRequest(BaseModel):
url: str
class LyricsReviewRequest(BaseModel):
lyrics: str
# GPU Worker Functions
@app.function(
image=karaoke_image,
gpu="any",
volumes=VOLUME_CONFIG,
secrets=[modal.Secret.from_name("karaoke-api-keys")],
timeout=1800,
)
def process_part_one(job_id: str, youtube_url: str):
"""First phase: Download audio, separate, and transcribe lyrics."""
import sys
import traceback
from datetime import datetime
def log_message(level: str, message: str):
"""Log a message with timestamp and level."""
timestamp = datetime.now().isoformat()
log_entry = {
"timestamp": timestamp,
"level": level,
"message": message
}
# Get existing logs or create new list
existing_logs = job_logs_dict.get(job_id, [])
existing_logs.append(log_entry)
job_logs_dict[job_id] = existing_logs
print(f"[{level}] {message}")
try:
from core import CoreKaraokeProcessor
log_message("INFO", f"Starting job {job_id} for URL: {youtube_url}")
# Update status
job_status_dict[job_id] = {
"status": "processing_audio",
"progress": 10,
"url": youtube_url,
"created_at": datetime.now().isoformat()
}
# Initialize processor
processor = CoreKaraokeProcessor()
# Phase 1: Download and prep audio
log_message("INFO", "Downloading and preparing audio...")
output_dir = Path(f"/output/{job_id}")
output_dir.mkdir(parents=True, exist_ok=True)
original_audio_path = processor.download_and_prep_audio(youtube_url, str(output_dir))
log_message("INFO", f"Audio downloaded to: {original_audio_path}")
# Phase 2: Audio separation
job_status_dict[job_id] = {"status": "processing_audio", "progress": 30, "url": youtube_url}
log_message("INFO", "Starting audio separation...")
instrumental_path, vocals_path = processor.run_audio_separation(original_audio_path, "/models")
log_message("INFO", f"Audio separated - Instrumental: {instrumental_path}, Vocals: {vocals_path}")
# Phase 3: Transcribe lyrics
job_status_dict[job_id] = {"status": "transcribing", "progress": 60, "url": youtube_url}
log_message("INFO", "Starting lyrics transcription...")
transcription_data = processor.transcribe_lyrics(vocals_path)
log_message("INFO", "Lyrics transcribed successfully")
# Save transcription data
transcription_path = output_dir / "transcription_raw.json"
with open(transcription_path, 'w') as f:
json.dump(transcription_data, f, indent=2)
# Update status to awaiting review
job_status_dict[job_id] = {
"status": "awaiting_review",
"progress": 75,
"url": youtube_url,
"transcription_path": str(transcription_path)
}
log_message("SUCCESS", f"Phase 1 completed for job {job_id}. Awaiting lyrics review.")
return {"status": "success", "message": "Phase 1 completed, awaiting lyrics review"}
except Exception as e:
error_msg = str(e)
error_traceback = traceback.format_exc()
log_message("ERROR", f"Phase 1 failed: {error_msg}")
log_message("ERROR", f"Traceback: {error_traceback}")
job_status_dict[job_id] = {
"status": "error",
"progress": 0,
"url": youtube_url,
"error": error_msg,
"traceback": error_traceback
}
raise Exception(f"Phase 1 failed: {error_msg}")
@app.function(
image=karaoke_image,
gpu="any",
volumes=VOLUME_CONFIG,
timeout=1800,
)
def process_part_two(job_id: str):
"""Second phase: Generate final video with corrected lyrics."""
import sys
import traceback
from datetime import datetime
def log_message(level: str, message: str):
"""Log a message with timestamp and level."""
timestamp = datetime.now().isoformat()
log_entry = {
"timestamp": timestamp,
"level": level,
"message": message
}
# Get existing logs or create new list
existing_logs = job_logs_dict.get(job_id, [])
existing_logs.append(log_entry)
job_logs_dict[job_id] = existing_logs
print(f"[{level}] {message}")
try:
from core import CoreKaraokeProcessor
log_message("INFO", f"Starting phase 2 for job {job_id}")
# Update status
job_status_dict[job_id] = {"status": "rendering", "progress": 80}
# Initialize processor
processor = CoreKaraokeProcessor()
# Load corrected lyrics
output_dir = Path(f"/output/{job_id}")
corrected_lyrics_path = output_dir / "lyrics_corrected.json"
if not corrected_lyrics_path.exists():
raise Exception("Corrected lyrics file not found")
with open(corrected_lyrics_path, 'r') as f:
corrected_lyrics = json.load(f)
log_message("INFO", "Corrected lyrics loaded")
# Generate video assets
log_message("INFO", "Starting video generation...")
instrumental_path = output_dir / "instrumental.wav"
video_path = processor.generate_video_assets(corrected_lyrics, str(instrumental_path))
log_message("INFO", f"Video generated: {video_path}")
# Update status to complete
job_status_dict[job_id] = {
"status": "complete",
"progress": 100,
"video_path": video_path,
"video_url": f"/api/jobs/{job_id}/download"
}
log_message("SUCCESS", f"Job {job_id} completed successfully!")
return {"status": "success", "message": "Video generation completed", "video_path": video_path}
except Exception as e:
error_msg = str(e)
error_traceback = traceback.format_exc()
log_message("ERROR", f"Phase 2 failed: {error_msg}")
log_message("ERROR", f"Traceback: {error_traceback}")
job_status_dict[job_id] = {
"status": "error",
"progress": 0,
"error": error_msg,
"traceback": error_traceback
}
raise Exception(f"Phase 2 failed: {error_msg}")
# FastAPI Application for API endpoints
api_app = FastAPI(title="Karaoke Generator API", version="1.0.0")
# Add CORS middleware
api_app.add_middleware(
CORSMiddleware,
allow_origins=["*"], # In production, replace with specific origins
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
# API Routes
@api_app.post("/api/submit")
async def submit_job(request: JobSubmissionRequest):
"""Submit a new karaoke generation job."""
try:
job_id = str(uuid.uuid4())[:8]
# Initialize job status
job_status_dict[job_id] = {
"status": "queued",
"progress": 0,
"url": request.url,
"created_at": datetime.datetime.now().isoformat()
}
# Initialize job logs
job_logs_dict[job_id] = []
# Spawn the background job
process_part_one.spawn(job_id, request.url)
return JSONResponse({
"status": "success",
"job_id": job_id,
"message": "Job submitted successfully"
}, status_code=202)
except Exception as e:
return JSONResponse({
"status": "error",
"message": str(e)
}, status_code=500)
@api_app.get("/api/jobs")
async def get_all_jobs():
"""Get status of all jobs."""
try:
jobs = dict(job_status_dict.items())
return JSONResponse(jobs)
except Exception as e:
return JSONResponse({"error": str(e)}, status_code=500)
@api_app.get("/api/jobs/{job_id}")
async def get_job_status(job_id: str):
"""Get status of a specific job."""
try:
job_data = job_status_dict.get(job_id)
if not job_data:
raise HTTPException(status_code=404, detail="Job not found")
return JSONResponse(job_data)
except HTTPException:
raise
except Exception as e:
return JSONResponse({"error": str(e)}, status_code=500)
@api_app.delete("/api/jobs/{job_id}")
async def delete_job(job_id: str):
"""Delete a specific job."""
try:
if job_id not in job_status_dict:
raise HTTPException(status_code=404, detail="Job not found")
# Remove from status and logs
del job_status_dict[job_id]
if job_id in job_logs_dict:
del job_logs_dict[job_id]
return JSONResponse({"status": "success", "message": f"Job {job_id} deleted"})
except HTTPException:
raise
except Exception as e:
return JSONResponse({"error": str(e)}, status_code=500)
@api_app.post("/api/jobs/{job_id}/retry")
async def retry_job(job_id: str):
"""Retry a failed job."""
try:
job_data = job_status_dict.get(job_id)
if not job_data:
raise HTTPException(status_code=404, detail="Job not found")
if job_data.get("status") != "error":
raise HTTPException(status_code=400, detail="Job is not in error state")
# Reset job status
job_status_dict[job_id] = {
"status": "queued",
"progress": 0,
"url": job_data.get("url", ""),
"created_at": datetime.datetime.now().isoformat()
}
# Clear error logs and add retry log
job_logs_dict[job_id] = [{
"timestamp": datetime.datetime.now().isoformat(),
"level": "INFO",
"message": "Job retry initiated"
}]
# Respawn the job
process_part_one.spawn(job_id, job_data.get("url", ""))
return JSONResponse({"status": "success", "message": f"Job {job_id} retry initiated"})
except HTTPException:
raise
except Exception as e:
return JSONResponse({"error": str(e)}, status_code=500)
@api_app.get("/api/logs")
async def get_all_logs():
"""Get logs for all jobs."""
try:
logs = dict(job_logs_dict.items())
return JSONResponse(logs)
except Exception as e:
return JSONResponse({"error": str(e)}, status_code=500)
@api_app.get("/api/logs/{job_id}")
async def get_job_logs(job_id: str):
"""Get logs for a specific job."""
try:
logs = job_logs_dict.get(job_id, [])
return JSONResponse(logs)
except Exception as e:
return JSONResponse({"error": str(e)}, status_code=500)
@api_app.get("/api/stats")
async def get_stats():
"""Get statistics about all jobs."""
try:
jobs = dict(job_status_dict.items())
stats = {
"total": len(jobs),
"processing": len([j for j in jobs.values() if j.get("status") in ["queued", "processing_audio", "transcribing", "rendering"]]),
"awaiting_review": len([j for j in jobs.values() if j.get("status") == "awaiting_review"]),
"complete": len([j for j in jobs.values() if j.get("status") == "complete"]),
"error": len([j for j in jobs.values() if j.get("status") == "error"])
}
return JSONResponse(stats)
except Exception as e:
return JSONResponse({"error": str(e)}, status_code=500)
@api_app.get("/api/review/{job_id}")
async def get_lyrics_for_review(job_id: str):
"""Get lyrics for review (returns HTML page)."""
try:
job_data = job_status_dict.get(job_id)
if not job_data:
raise HTTPException(status_code=404, detail="Job not found")
if job_data.get("status") != "awaiting_review":
raise HTTPException(status_code=400, detail="Job is not awaiting review")
# Load raw transcription
output_dir = Path(f"/output/{job_id}")
transcription_path = output_dir / "transcription_raw.json"
if not transcription_path.exists():
raise HTTPException(status_code=404, detail="Transcription not found")
with open(transcription_path, 'r') as f:
raw_lyrics = json.load(f)
# Return HTML page for lyrics review
html_content = f"""
<!DOCTYPE html>
<html>
<head>
<title>Review Lyrics - Job {job_id}</title>
<style>
body {{ font-family: Arial, sans-serif; max-width: 800px; margin: 0 auto; padding: 20px; }}
textarea {{ width: 100%; height: 400px; font-family: monospace; }}
button {{ padding: 10px 20px; background: #007bff; color: white; border: none; border-radius: 5px; cursor: pointer; }}
button:hover {{ background: #0056b3; }}
</style>
</head>
<body>
<h1>Review Lyrics for Job {job_id}</h1>
<form action="/api/review/{job_id}" method="post">
<textarea name="lyrics" placeholder="Edit the lyrics here...">{json.dumps(raw_lyrics, indent=2)}</textarea>
<br><br>
<button type="submit">✅ Approve and Continue to Video Generation</button>
</form>
</body>
</html>
"""
from fastapi.responses import HTMLResponse
return HTMLResponse(content=html_content)
except HTTPException:
raise
except Exception as e:
return JSONResponse({"error": str(e)}, status_code=500)
@api_app.post("/api/review/{job_id}")
async def submit_lyrics_review(job_id: str, lyrics: str = Form(...)):
"""Submit reviewed lyrics and continue to video generation."""
try:
job_data = job_status_dict.get(job_id)
if not job_data:
raise HTTPException(status_code=404, detail="Job not found")
# Save corrected lyrics
output_dir = Path(f"/output/{job_id}")
corrected_lyrics_path = output_dir / "lyrics_corrected.json"
# Parse the lyrics JSON
try:
lyrics_data = json.loads(lyrics)
except json.JSONDecodeError:
# If not valid JSON, treat as plain text
lyrics_data = {"text": lyrics}
with open(corrected_lyrics_path, 'w') as f:
json.dump(lyrics_data, f, indent=2)
# Update job status
job_status_dict[job_id] = {
**job_data,
"status": "rendering",
"progress": 80
}
# Add log entry
existing_logs = job_logs_dict.get(job_id, [])
existing_logs.append({
"timestamp": datetime.datetime.now().isoformat(),
"level": "INFO",
"message": "Lyrics approved, starting video generation"
})
job_logs_dict[job_id] = existing_logs
# Spawn phase 2
process_part_two.spawn(job_id)
return JSONResponse({
"status": "success",
"message": "Lyrics approved, video generation started"
})
except HTTPException:
raise
except Exception as e:
return JSONResponse({"error": str(e)}, status_code=500)
@api_app.get("/api/jobs/{job_id}/download")
async def download_video(job_id: str):
"""Download the completed video."""
try:
job_data = job_status_dict.get(job_id)
if not job_data:
raise HTTPException(status_code=404, detail="Job not found")
if job_data.get("status") != "complete":
raise HTTPException(status_code=400, detail="Job is not complete")
video_path = job_data.get("video_path")
if not video_path or not Path(video_path).exists():
raise HTTPException(status_code=404, detail="Video file not found")
return FileResponse(
path=video_path,
filename=f"karaoke-{job_id}.mp4",
media_type="video/mp4"
)
except HTTPException:
raise
except Exception as e:
return JSONResponse({"error": str(e)}, status_code=500)
# Admin Routes
@api_app.post("/api/admin/clear-errors")
async def clear_error_jobs():
"""Clear all jobs with error status."""
try:
jobs_to_delete = []
for job_id, job_data in job_status_dict.items():
if job_data.get("status") == "error":
jobs_to_delete.append(job_id)
for job_id in jobs_to_delete:
del job_status_dict[job_id]
if job_id in job_logs_dict:
del job_logs_dict[job_id]
return JSONResponse({
"status": "success",
"message": f"Cleared {len(jobs_to_delete)} error jobs"
})
except Exception as e:
return JSONResponse({"error": str(e)}, status_code=500)
@api_app.get("/api/admin/export-logs")
async def export_logs():
"""Export all logs as JSON file."""
try:
logs_data = {
"exported_at": datetime.datetime.now().isoformat(),
"jobs": dict(job_status_dict.items()),
"logs": dict(job_logs_dict.items())
}
import tempfile
import os
# Create temporary file
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
json.dump(logs_data, f, indent=2)
temp_path = f.name
return FileResponse(
path=temp_path,
filename=f"karaoke-logs-{datetime.datetime.now().strftime('%Y%m%d')}.json",
media_type="application/json"
)
except Exception as e:
return JSONResponse({"error": str(e)}, status_code=500)
# Health check
@api_app.get("/api/health")
async def health_check():
"""Health check endpoint."""
return JSONResponse({
"status": "healthy",
"timestamp": datetime.datetime.now().isoformat(),
"version": "1.0.0"
})
# Mount the FastAPI application to the Modal app
@app.function(
image=karaoke_image,
volumes=VOLUME_CONFIG,
min_containers=1, # Keep at least 1 container warm
max_containers=10, # Allow scaling up to 10 containers
scaledown_window=5 * 60, # Wait 5 minutes before scaling down
)
@modal.concurrent(max_inputs=100)
@modal.asgi_app()
def web_endpoint():
"""Mount the FastAPI application."""
return api_app
+389
View File
@@ -0,0 +1,389 @@
"""
Core processing functions for karaoke generation.
This module contains the isolated core logic from the original karaoke-gen CLI tool,
modified to remove interactive elements and print statements for serverless execution.
"""
import os
import sys
import json
import logging
import tempfile
import shutil
import asyncio
from pathlib import Path
from typing import Dict, Any, Optional, Tuple
# Import the existing processor classes
from karaoke_gen.audio_processor import AudioProcessor
from karaoke_gen.lyrics_processor import LyricsProcessor
from karaoke_gen.video_generator import VideoGenerator
from karaoke_gen.file_handler import FileHandler
from karaoke_gen.metadata import extract_info_for_online_media, parse_track_metadata
from karaoke_gen.config import (
load_style_params,
setup_title_format,
setup_end_format,
get_video_durations,
get_existing_images,
setup_ffmpeg_command,
)
def setup_logger(log_level=logging.INFO) -> logging.Logger:
"""Set up a basic logger for core processing functions."""
logger = logging.getLogger(__name__)
logger.setLevel(log_level)
if not logger.handlers:
handler = logging.StreamHandler()
formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(module)s - %(message)s")
handler.setFormatter(formatter)
logger.addHandler(handler)
return logger
def download_and_prep_audio(url: str, output_dir: Path) -> str:
"""
Download audio from URL and convert to WAV format.
Args:
url: YouTube or other media URL
output_dir: Directory to store downloaded files
Returns:
Path to the converted WAV audio file
"""
logger = setup_logger()
# Create a temporary FileHandler instance for download operations
file_handler = FileHandler(
logger=logger,
ffmpeg_base_command=setup_ffmpeg_command(logging.INFO),
create_track_subfolders=False,
dry_run=False,
)
# Extract metadata from URL
extracted_info = extract_info_for_online_media(url, None, None, logger)
if not extracted_info:
raise ValueError(f"Could not extract metadata from URL: {url}")
metadata_result = parse_track_metadata(
extracted_info, None, None, None, logger
)
artist = metadata_result["artist"]
title = metadata_result["title"]
extractor = metadata_result["extractor"]
media_id = metadata_result["media_id"]
# Create filename
filename_suffix = f"{extractor} {media_id}" if media_id else extractor
artist_title = f"{artist} - {title}"
output_filename_no_extension = output_dir / f"{artist_title} ({filename_suffix})"
# Download video
downloaded_file = file_handler.download_video(str(url), str(output_filename_no_extension))
# Convert to WAV
wav_file = file_handler.convert_to_wav(downloaded_file, str(output_filename_no_extension))
return wav_file
def run_audio_separation(audio_file: str, model_dir: str) -> Tuple[str, str]:
"""
Run audio separation on the input audio file.
Args:
audio_file: Path to input audio WAV file
model_dir: Directory containing AI models
Returns:
Tuple of (instrumental_path, vocals_path)
"""
logger = setup_logger()
# Get artist and title from filename for output naming
filename = os.path.basename(audio_file)
artist_title = filename.replace(".wav", "").replace(" (Original)", "")
track_output_dir = os.path.dirname(audio_file)
# Initialize AudioProcessor
audio_processor = AudioProcessor(
logger=logger,
log_level=logging.INFO,
log_formatter=None,
model_file_dir=model_dir,
lossless_output_format="FLAC",
clean_instrumental_model="model_bs_roformer_ep_317_sdr_12.9755.ckpt",
backing_vocals_models=["mel_band_roformer_karaoke_aufr33_viperx_sdr_10.1956.ckpt"],
other_stems_models=["htdemucs_6s.yaml"],
ffmpeg_base_command=setup_ffmpeg_command(logging.INFO),
)
# Run separation
separation_results = audio_processor.process_audio_separation(
audio_file=audio_file,
artist_title=artist_title,
track_output_dir=track_output_dir,
)
# Extract paths for instrumental and vocals
instrumental_path = separation_results["clean_instrumental"]["instrumental"]
vocals_path = separation_results["clean_instrumental"]["vocals"]
return instrumental_path, vocals_path
def transcribe_lyrics(vocals_path: str, artist: str, title: str, output_dir: str) -> Dict[str, Any]:
"""
Transcribe lyrics from vocals audio file.
Args:
vocals_path: Path to vocals audio file
artist: Artist name
title: Song title
output_dir: Output directory for lyrics files
Returns:
Dictionary containing transcription results and file paths
"""
logger = setup_logger()
# Initialize LyricsProcessor
lyrics_processor = LyricsProcessor(
logger=logger,
style_params_json=None, # Use default styles
lyrics_file=None,
skip_transcription=False,
skip_transcription_review=True, # Skip interactive review for serverless
render_video=False, # Don't render video in transcription step
subtitle_offset_ms=0,
)
# Run transcription
transcription_results = lyrics_processor.transcribe_lyrics(
input_audio_wav=vocals_path,
artist=artist,
title=title,
track_output_dir=output_dir,
)
return transcription_results
def generate_video_assets(lyrics_data: str, instrumental_path: str, output_dir: str, artist: str, title: str) -> str:
"""
Generate final karaoke video with synchronized lyrics.
Args:
lyrics_data: Corrected lyrics text or LRC content
instrumental_path: Path to instrumental audio
output_dir: Output directory
artist: Artist name
title: Song title
Returns:
Path to generated video file
"""
logger = setup_logger()
# Initialize VideoGenerator
video_generator = VideoGenerator(
logger=logger,
ffmpeg_base_command=setup_ffmpeg_command(logging.INFO),
render_bounding_boxes=False,
output_png=True,
output_jpg=True,
)
# Load default style parameters
style_params = load_style_params(None, logger)
title_format = setup_title_format(style_params)
end_format = setup_end_format(style_params)
# Generate title screen
title_output_path = os.path.join(output_dir, f"{artist} - {title} (Title)")
title_video_path = os.path.join(output_dir, f"{artist} - {title} (Title).mov")
video_generator.create_title_video(
artist=artist,
title=title,
format=title_format,
output_image_filepath_noext=title_output_path,
output_video_filepath=title_video_path,
existing_title_image=None,
intro_video_duration=5, # 5 second title
)
# Generate end screen
end_output_path = os.path.join(output_dir, f"{artist} - {title} (End)")
end_video_path = os.path.join(output_dir, f"{artist} - {title} (End).mov")
video_generator.create_end_video(
artist=artist,
title=title,
format=end_format,
output_image_filepath_noext=end_output_path,
output_video_filepath=end_video_path,
existing_end_image=None,
end_video_duration=5, # 5 second end screen
)
# For now, return the title video path as a placeholder
# In a full implementation, this would combine title + karaoke content + end screen
final_video_path = os.path.join(output_dir, f"{artist} - {title} (Final).mp4")
# Create a simple combined video (placeholder logic)
# This would be replaced with proper karaoke video generation
ffmpeg_command = (
f'ffmpeg -i "{title_video_path}" -i "{end_video_path}" '
f'-filter_complex "[0:v][1:v]concat=n=2:v=1[v]" -map "[v]" '
f'"{final_video_path}"'
)
os.system(ffmpeg_command)
return final_video_path
class CoreKaraokeProcessor:
"""
Main processor class that orchestrates the karaoke generation workflow.
"""
def __init__(self, model_dir: str = "/models", output_dir: str = "/output"):
self.model_dir = model_dir
self.output_dir = output_dir
self.logger = setup_logger()
async def process_track(self, job_id: str, url: str, status_callback=None) -> Dict[str, Any]:
"""
Process a single track through the complete karaoke generation pipeline.
Args:
job_id: Unique identifier for this job
url: YouTube or media URL
status_callback: Optional callback function to update job status
Returns:
Dictionary with processing results and output file paths
"""
try:
job_output_dir = Path(self.output_dir) / job_id
job_output_dir.mkdir(parents=True, exist_ok=True)
if status_callback:
status_callback(job_id, {"status": "downloading", "progress": 10})
# Step 1: Download and prep audio
audio_path = download_and_prep_audio(url, job_output_dir)
if status_callback:
status_callback(job_id, {"status": "separating_audio", "progress": 25})
# Step 2: Run audio separation
instrumental_path, vocals_path = run_audio_separation(audio_path, self.model_dir)
if status_callback:
status_callback(job_id, {"status": "transcribing", "progress": 50})
# Step 3: Transcribe lyrics (extract artist/title from filename)
filename = os.path.basename(audio_path)
# Parse artist - title from filename (assumes format "Artist - Title (...)...")
if " - " in filename:
artist, title_part = filename.split(" - ", 1)
title = title_part.split(" (")[0] # Remove extractor info
else:
artist, title = "Unknown Artist", "Unknown Title"
transcription_results = transcribe_lyrics(
vocals_path, artist, title, str(job_output_dir)
)
if status_callback:
status_callback(job_id, {"status": "awaiting_review", "progress": 75})
return {
"job_id": job_id,
"artist": artist,
"title": title,
"audio_path": audio_path,
"instrumental_path": instrumental_path,
"vocals_path": vocals_path,
"transcription_results": transcription_results,
"status": "awaiting_review"
}
except Exception as e:
self.logger.error(f"Error processing track {job_id}: {str(e)}")
if status_callback:
status_callback(job_id, {"status": "error", "progress": 0, "error": str(e)})
raise
async def finalize_track(self, job_id: str, corrected_lyrics: str, status_callback=None) -> Dict[str, Any]:
"""
Finalize track processing with corrected lyrics.
Args:
job_id: Job identifier
corrected_lyrics: Human-corrected lyrics
status_callback: Optional status callback
Returns:
Dictionary with final processing results
"""
try:
job_output_dir = Path(self.output_dir) / job_id
if status_callback:
status_callback(job_id, {"status": "generating_video", "progress": 80})
# Find the instrumental file
instrumental_files = list(job_output_dir.glob("*Instrumental*.flac"))
if not instrumental_files:
raise ValueError("No instrumental file found")
instrumental_path = str(instrumental_files[0])
# Extract artist/title from directory structure or files
audio_files = list(job_output_dir.glob("*.wav"))
if audio_files:
filename = audio_files[0].stem
if " - " in filename:
artist, title_part = filename.split(" - ", 1)
title = title_part.split(" (")[0]
else:
artist, title = "Unknown Artist", "Unknown Title"
else:
artist, title = "Unknown Artist", "Unknown Title"
# Generate final video
final_video_path = generate_video_assets(
corrected_lyrics, instrumental_path, str(job_output_dir), artist, title
)
if status_callback:
status_callback(job_id, {
"status": "complete",
"progress": 100,
"video_path": final_video_path
})
return {
"job_id": job_id,
"status": "complete",
"final_video_path": final_video_path,
"artist": artist,
"title": title
}
except Exception as e:
self.logger.error(f"Error finalizing track {job_id}: {str(e)}")
if status_callback:
status_callback(job_id, {"status": "error", "progress": 0, "error": str(e)})
raise
+1
View File
@@ -0,0 +1 @@
gen.nomadkaraoke.com
+141
View File
@@ -0,0 +1,141 @@
# Karaoke Generator Frontend
This is the static frontend for the Karaoke Generator web application. It's designed to be deployed on GitHub Pages with a custom domain.
## Architecture
- **Frontend**: Static HTML/CSS/JS hosted on GitHub Pages → `gen.nomadkaraoke.com`
- **Backend**: Modal API endpoints → `nomadkaraoke--karaoke-generator-webapp-web-endpoint.modal.run/api`
## Files
- `index.html` - Main application page
- `styles.css` - All CSS styles and responsive design
- `app.js` - JavaScript application logic and API communication
- `README.md` - This file
## Features
- 🎵 YouTube URL submission for karaoke generation
- 📊 Real-time job monitoring with progress bars
- 📋 Comprehensive logging and admin controls
- 📝 Lyrics review interface
- 📥 Video download functionality
- 🔧 Admin panel for job management
- 📱 Responsive mobile design
## Deployment to GitHub Pages
### 1. Create GitHub Repository
```bash
# Initialize git repository
cd frontend
git init
git add .
git commit -m "Initial frontend setup"
# Create GitHub repository and push
git remote add origin https://github.com/YOUR_USERNAME/karaoke-gen-frontend.git
git branch -M main
git push -u origin main
```
### 2. Enable GitHub Pages
1. Go to your repository on GitHub
2. Click **Settings** tab
3. Scroll to **Pages** section
4. Under **Source**, select **Deploy from a branch**
5. Choose **main** branch and **/ (root)** folder
6. Click **Save**
### 3. Configure Custom Domain
1. In the **Pages** section, add your custom domain: `gen.nomadkaraoke.com`
2. Enable **Enforce HTTPS**
### 4. DNS Configuration (Cloudflare)
Add a CNAME record in your Cloudflare DNS:
```
Type: CNAME
Name: gen
Target: YOUR_USERNAME.github.io
Proxy status: Proxied (orange cloud)
```
## Development
### Local Testing
You can test the frontend locally using Python's built-in server:
```bash
cd frontend
python -m http.server 8000
```
Then visit `http://localhost:8000`
### API Configuration
The API endpoint is configured in `app.js`:
```javascript
const API_BASE_URL = 'https://nomadkaraoke--karaoke-generator-webapp-web-endpoint.modal.run/api';
```
Update this URL if your Modal deployment changes.
## Features Overview
### Job Management
- Submit YouTube URLs for processing
- Monitor job progress in real-time
- View detailed logs for each job
- Delete, retry, or download completed jobs
### Admin Controls
- Clear error jobs in bulk
- Export all logs as JSON
- Real-time statistics dashboard
- Auto-refresh functionality
### Responsive Design
- Mobile-friendly interface
- Progressive enhancement
- Modern CSS with gradients and animations
- Accessible design patterns
## Browser Support
- Chrome/Chromium 80+
- Firefox 75+
- Safari 13+
- Edge 80+
## Security Notes
- CORS is configured on the backend to allow requests from your domain
- All API communication uses HTTPS
- No sensitive data is stored in the frontend
- GitHub Pages provides automatic HTTPS with custom domains
## Troubleshooting
### API Connection Issues
1. Check that the Modal backend is running
2. Verify the API_BASE_URL in app.js
3. Check browser console for CORS errors
### GitHub Pages Not Updating
1. Check the Actions tab for deployment status
2. Ensure all files are committed and pushed
3. Wait 5-10 minutes for propagation
### Custom Domain Issues
1. Verify DNS settings in Cloudflare
2. Ensure CNAME record points to YOUR_USERNAME.github.io
3. Enable HTTPS enforcement in GitHub Pages settings
+478
View File
@@ -0,0 +1,478 @@
// Configuration
const API_BASE_URL = 'https://nomadkaraoke--karaoke-generator-webapp-web-endpoint.modal.run/api';
// Global variables
let autoRefreshInterval;
let currentJobs = {};
let currentLogs = {};
let currentStats = {};
// DOM elements
const submitForm = document.getElementById('submitForm');
const urlInput = document.getElementById('urlInput');
const submitStatus = document.getElementById('submitStatus');
const jobsContainer = document.getElementById('jobs');
const statsContainer = document.getElementById('stats');
const autoRefreshCheckbox = document.getElementById('autoRefresh');
// Initialize the application
document.addEventListener('DOMContentLoaded', function() {
console.log('🎤 Karaoke Generator Frontend Initialized');
// Set up form submission
submitForm.addEventListener('submit', handleSubmit);
// Set up auto-refresh
autoRefreshCheckbox.addEventListener('change', toggleAutoRefresh);
// Initial data load
refreshData();
// Start auto-refresh if enabled
if (autoRefreshCheckbox.checked) {
startAutoRefresh();
}
});
// Handle form submission
async function handleSubmit(event) {
event.preventDefault();
const url = urlInput.value.trim();
if (!url) {
showStatus('Please enter a YouTube URL', 'error');
return;
}
if (!isValidYouTubeURL(url)) {
showStatus('Please enter a valid YouTube URL', 'error');
return;
}
try {
showStatus('Submitting job...', 'info');
const response = await fetch(`${API_BASE_URL}/submit`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify({ url: url })
});
if (!response.ok) {
throw new Error(`HTTP error! status: ${response.status}`);
}
const result = await response.json();
if (result.status === 'success') {
showStatus(`Job submitted successfully! Job ID: ${result.job_id}`, 'success');
urlInput.value = '';
// Refresh data to show new job
setTimeout(refreshData, 1000);
} else {
showStatus(result.message || 'Failed to submit job', 'error');
}
} catch (error) {
console.error('Submit error:', error);
showStatus(`Error: ${error.message}`, 'error');
}
}
// Refresh all data
async function refreshData() {
console.log('🔄 Refreshing data...');
try {
// Fetch all data in parallel
const [jobsResponse, logsResponse, statsResponse] = await Promise.all([
fetch(`${API_BASE_URL}/jobs`).catch(err => ({ ok: false, error: err })),
fetch(`${API_BASE_URL}/logs`).catch(err => ({ ok: false, error: err })),
fetch(`${API_BASE_URL}/stats`).catch(err => ({ ok: false, error: err }))
]);
// Process jobs
if (jobsResponse.ok) {
currentJobs = await jobsResponse.json();
} else {
console.warn('Failed to fetch jobs:', jobsResponse.error);
}
// Process logs
if (logsResponse.ok) {
currentLogs = await logsResponse.json();
} else {
console.warn('Failed to fetch logs:', logsResponse.error);
}
// Process stats
if (statsResponse.ok) {
currentStats = await statsResponse.json();
} else {
console.warn('Failed to fetch stats:', statsResponse.error);
}
// Update UI
updateStatsDisplay();
updateJobsDisplay();
} catch (error) {
console.error('Refresh error:', error);
showStatus(`Error refreshing data: ${error.message}`, 'error');
}
}
// Update statistics display
function updateStatsDisplay() {
if (!currentStats || Object.keys(currentStats).length === 0) {
statsContainer.innerHTML = '<div class="stat-card"><div class="stat-number">-</div><div>No stats available</div></div>';
return;
}
const statsHTML = `
<div class="stat-card">
<div class="stat-number">${currentStats.total || 0}</div>
<div>Total Jobs</div>
</div>
<div class="stat-card">
<div class="stat-number">${currentStats.processing || 0}</div>
<div>Processing</div>
</div>
<div class="stat-card">
<div class="stat-number">${currentStats.awaiting_review || 0}</div>
<div>Awaiting Review</div>
</div>
<div class="stat-card">
<div class="stat-number">${currentStats.complete || 0}</div>
<div>Complete</div>
</div>
<div class="stat-card">
<div class="stat-number">${currentStats.error || 0}</div>
<div>Errors</div>
</div>
`;
statsContainer.innerHTML = statsHTML;
}
// Update jobs display
function updateJobsDisplay() {
if (!currentJobs || Object.keys(currentJobs).length === 0) {
jobsContainer.innerHTML = '<p>No jobs found. Submit a YouTube URL to get started!</p>';
return;
}
const jobsHTML = Object.entries(currentJobs)
.sort(([, a], [, b]) => new Date(b.created_at || 0) - new Date(a.created_at || 0))
.map(([jobId, job]) => createJobHTML(jobId, job))
.join('');
jobsContainer.innerHTML = jobsHTML;
}
// Create HTML for a single job
function createJobHTML(jobId, job) {
const status = job.status || 'unknown';
const progress = job.progress || 0;
const createdAt = job.created_at ? new Date(job.created_at).toLocaleString() : 'Unknown';
// Get logs for this job
const jobLogs = currentLogs[jobId] || [];
// Determine status class
const statusClass = getStatusClass(status);
// Create actions based on status
const actions = createJobActions(jobId, job);
// Create logs section
const logsSection = createLogsSection(jobId, jobLogs);
return `
<div class="job ${statusClass}">
<div class="job-header">
<h4>🎵 Job ${jobId}</h4>
<span class="timestamp">Created: ${createdAt}</span>
</div>
<div class="job-info">
<p><strong>Status:</strong> ${formatStatus(status)}</p>
${job.url ? `<p><strong>URL:</strong> <a href="${job.url}" target="_blank">${job.url}</a></p>` : ''}
${job.error ? `<div class="error-details"><strong>Error:</strong><br>${job.error}</div>` : ''}
</div>
<div class="progress-bar">
<div class="progress-fill" style="width: ${progress}%"></div>
</div>
<div class="progress-text">${progress}%</div>
${actions}
${logsSection}
</div>
`;
}
// Get CSS class for job status
function getStatusClass(status) {
const statusMap = {
'queued': 'processing',
'processing_audio': 'processing',
'transcribing': 'processing',
'awaiting_review': 'awaiting_review',
'rendering': 'processing',
'complete': 'complete',
'error': 'error'
};
return statusMap[status] || 'processing';
}
// Format status for display
function formatStatus(status) {
const statusMap = {
'queued': '⏳ Queued',
'processing_audio': '🎵 Processing Audio',
'transcribing': '📝 Transcribing Lyrics',
'awaiting_review': '👀 Awaiting Review',
'rendering': '🎬 Rendering Video',
'complete': '✅ Complete',
'error': '❌ Error'
};
return statusMap[status] || `⚠️ ${status}`;
}
// Create job action buttons
function createJobActions(jobId, job) {
const status = job.status || 'unknown';
let actions = [];
// Always show delete button
actions.push(`<button onclick="deleteJob('${jobId}')" class="btn btn-danger">🗑️ Delete</button>`);
// Status-specific actions
if (status === 'awaiting_review') {
actions.push(`<button onclick="reviewLyrics('${jobId}')" class="btn btn-success">📝 Review Lyrics</button>`);
}
if (status === 'complete' && job.video_url) {
actions.push(`<button onclick="downloadVideo('${jobId}')" class="btn btn-success">📥 Download Video</button>`);
}
if (status === 'error') {
actions.push(`<button onclick="retryJob('${jobId}')" class="btn">🔄 Retry</button>`);
}
// Toggle logs button
actions.push(`<button onclick="toggleLogs('${jobId}')" class="toggle-details">📋 Toggle Logs</button>`);
return `<div class="job-actions">${actions.join('')}</div>`;
}
// Create logs section
function createLogsSection(jobId, logs) {
if (!logs || logs.length === 0) {
return `<div id="logs-${jobId}" class="job-details hidden"><p>No logs available for this job.</p></div>`;
}
const logsHTML = logs.map(log => {
const timestamp = new Date(log.timestamp).toLocaleTimeString();
const levelClass = log.level.toLowerCase();
return `<div class="log-entry ${levelClass}">
<span class="timestamp">${timestamp}</span>
<span class="log-message">${escapeHtml(log.message)}</span>
</div>`;
}).join('');
return `<div id="logs-${jobId}" class="job-details hidden">${logsHTML}</div>`;
}
// Job action functions
async function deleteJob(jobId) {
if (!confirm(`Are you sure you want to delete job ${jobId}?`)) {
return;
}
try {
const response = await fetch(`${API_BASE_URL}/jobs/${jobId}`, {
method: 'DELETE'
});
if (response.ok) {
showStatus(`Job ${jobId} deleted successfully`, 'success');
refreshData();
} else {
throw new Error(`Failed to delete job: ${response.status}`);
}
} catch (error) {
console.error('Delete error:', error);
showStatus(`Error deleting job: ${error.message}`, 'error');
}
}
async function reviewLyrics(jobId) {
try {
// Open lyrics review in a new window/tab
const reviewUrl = `${API_BASE_URL}/review/${jobId}`;
window.open(reviewUrl, '_blank');
showStatus('Lyrics review page opened in new tab', 'info');
} catch (error) {
console.error('Review error:', error);
showStatus(`Error opening review: ${error.message}`, 'error');
}
}
async function retryJob(jobId) {
try {
const response = await fetch(`${API_BASE_URL}/jobs/${jobId}/retry`, {
method: 'POST'
});
if (response.ok) {
showStatus(`Job ${jobId} retry initiated`, 'success');
refreshData();
} else {
throw new Error(`Failed to retry job: ${response.status}`);
}
} catch (error) {
console.error('Retry error:', error);
showStatus(`Error retrying job: ${error.message}`, 'error');
}
}
async function downloadVideo(jobId) {
try {
const downloadUrl = `${API_BASE_URL}/jobs/${jobId}/download`;
const link = document.createElement('a');
link.href = downloadUrl;
link.download = `karaoke-${jobId}.mp4`;
document.body.appendChild(link);
link.click();
document.body.removeChild(link);
showStatus('Download started', 'success');
} catch (error) {
console.error('Download error:', error);
showStatus(`Error downloading video: ${error.message}`, 'error');
}
}
// Admin functions
async function clearErrorJobs() {
if (!confirm('Are you sure you want to clear all error jobs?')) {
return;
}
try {
const response = await fetch(`${API_BASE_URL}/admin/clear-errors`, {
method: 'POST'
});
if (response.ok) {
showStatus('Error jobs cleared successfully', 'success');
refreshData();
} else {
throw new Error(`Failed to clear errors: ${response.status}`);
}
} catch (error) {
console.error('Clear errors error:', error);
showStatus(`Error clearing error jobs: ${error.message}`, 'error');
}
}
async function exportLogs() {
try {
const response = await fetch(`${API_BASE_URL}/admin/export-logs`);
if (response.ok) {
const blob = await response.blob();
const url = window.URL.createObjectURL(blob);
const link = document.createElement('a');
link.href = url;
link.download = `karaoke-logs-${new Date().toISOString().split('T')[0]}.json`;
document.body.appendChild(link);
link.click();
document.body.removeChild(link);
window.URL.revokeObjectURL(url);
showStatus('Logs exported successfully', 'success');
} else {
throw new Error(`Failed to export logs: ${response.status}`);
}
} catch (error) {
console.error('Export error:', error);
showStatus(`Error exporting logs: ${error.message}`, 'error');
}
}
// UI utility functions
function toggleLogs(jobId) {
const logsElement = document.getElementById(`logs-${jobId}`);
if (logsElement) {
logsElement.classList.toggle('hidden');
}
}
function toggleAutoRefresh() {
if (autoRefreshCheckbox.checked) {
startAutoRefresh();
} else {
stopAutoRefresh();
}
}
function startAutoRefresh() {
stopAutoRefresh(); // Clear any existing interval
autoRefreshInterval = setInterval(refreshData, 5000);
console.log('Auto-refresh started (5s interval)');
}
function stopAutoRefresh() {
if (autoRefreshInterval) {
clearInterval(autoRefreshInterval);
autoRefreshInterval = null;
console.log('Auto-refresh stopped');
}
}
function showStatus(message, type = 'info') {
submitStatus.textContent = message;
submitStatus.className = `status-message ${type}`;
// Auto-clear success/info messages after 5 seconds
if (type === 'success' || type === 'info') {
setTimeout(() => {
submitStatus.textContent = '';
submitStatus.className = 'status-message';
}, 5000);
}
}
// Utility functions
function isValidYouTubeURL(url) {
const patterns = [
/^(https?:\/\/)?(www\.)?(youtube\.com\/watch\?v=|youtu\.be\/|youtube\.com\/embed\/|youtube\.com\/v\/)/i
];
return patterns.some(pattern => pattern.test(url));
}
function escapeHtml(text) {
const div = document.createElement('div');
div.textContent = text;
return div.innerHTML;
}
// Error handling for unhandled promises
window.addEventListener('unhandledrejection', function(event) {
console.error('Unhandled promise rejection:', event.reason);
showStatus('An unexpected error occurred', 'error');
});
// Log when frontend is ready
console.log('🎤 Karaoke Generator Frontend Ready!');
+52
View File
@@ -0,0 +1,52 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Karaoke Generator - Professional AI-Powered Karaoke Creation</title>
<meta name="description" content="Transform YouTube videos into professional karaoke tracks with synchronized lyrics using AI-powered audio separation and transcription.">
<link rel="stylesheet" href="styles.css">
<link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><text y='.9em' font-size='90'>🎤</text></svg>">
</head>
<body>
<div class="container">
<header>
<h1>🎤 Karaoke Generator</h1>
<p>Transform YouTube videos into professional karaoke tracks with synchronized lyrics!</p>
</header>
<div class="admin-controls">
<h3>🔧 Admin Controls</h3>
<button onclick="refreshData()" class="btn">🔄 Refresh Data</button>
<button onclick="clearErrorJobs()" class="btn btn-danger">🗑️ Clear Error Jobs</button>
<button onclick="exportLogs()" class="btn">📥 Export Logs</button>
<label>
<input type="checkbox" id="autoRefresh" checked> Auto-refresh (5s)
</label>
</div>
<div class="form-group">
<h2>Submit a New Job</h2>
<form id="submitForm">
<input type="text" id="urlInput" placeholder="Enter YouTube URL" required>
<br><br>
<button type="submit">🚀 Generate Karaoke</button>
</form>
<div id="submitStatus" class="status-message"></div>
</div>
</div>
<div class="stats" id="stats"></div>
<div class="container">
<h2>Job Status & Logs</h2>
<div id="jobs">Loading...</div>
</div>
<footer>
<p>Powered by AI • Made with ❤️ by <a href="https://nomadkaraoke.com" target="_blank">Nomad Karaoke</a></p>
</footer>
<script src="app.js"></script>
</body>
</html>
+428
View File
@@ -0,0 +1,428 @@
/* Reset and base styles */
* {
box-sizing: border-box;
}
body {
font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', sans-serif;
max-width: 1400px;
margin: 0 auto;
padding: 20px;
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
min-height: 100vh;
line-height: 1.6;
color: #333;
}
/* Container styles */
.container {
background: white;
padding: 30px;
border-radius: 15px;
box-shadow: 0 10px 30px rgba(0,0,0,0.2);
margin-bottom: 30px;
transition: transform 0.2s ease, box-shadow 0.2s ease;
}
.container:hover {
transform: translateY(-2px);
box-shadow: 0 15px 40px rgba(0,0,0,0.25);
}
/* Header styles */
header {
text-align: center;
margin-bottom: 30px;
padding-bottom: 20px;
border-bottom: 2px solid #f0f0f0;
}
h1 {
color: #2c3e50;
margin-bottom: 10px;
font-size: 2.5em;
font-weight: 700;
}
h2 {
color: #34495e;
margin-bottom: 20px;
font-size: 1.8em;
font-weight: 600;
}
h3 {
color: #34495e;
margin-bottom: 15px;
font-size: 1.3em;
font-weight: 600;
}
/* Form styles */
.form-group {
margin-bottom: 30px;
}
input[type="text"] {
width: 100%;
padding: 15px;
border: 2px solid #e0e0e0;
border-radius: 10px;
font-size: 16px;
transition: border-color 0.3s ease, box-shadow 0.3s ease;
}
input[type="text"]:focus {
outline: none;
border-color: #667eea;
box-shadow: 0 0 0 3px rgba(102, 126, 234, 0.1);
}
/* Button styles */
button, .btn {
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
color: white;
padding: 12px 30px;
border: none;
border-radius: 25px;
font-size: 16px;
font-weight: 600;
cursor: pointer;
text-decoration: none;
display: inline-block;
margin: 5px;
transition: all 0.3s ease;
box-shadow: 0 4px 15px rgba(102, 126, 234, 0.3);
}
button:hover, .btn:hover {
transform: translateY(-2px);
box-shadow: 0 8px 25px rgba(102, 126, 234, 0.4);
}
button:active, .btn:active {
transform: translateY(0);
}
.btn-danger {
background: linear-gradient(135deg, #e74c3c 0%, #c0392b 100%);
box-shadow: 0 4px 15px rgba(231, 76, 60, 0.3);
}
.btn-danger:hover {
box-shadow: 0 8px 25px rgba(231, 76, 60, 0.4);
}
.btn-success {
background: linear-gradient(135deg, #2ecc71 0%, #27ae60 100%);
box-shadow: 0 4px 15px rgba(46, 204, 113, 0.3);
}
.btn-success:hover {
box-shadow: 0 8px 25px rgba(46, 204, 113, 0.4);
}
/* Job status styles */
.job {
padding: 25px;
margin: 20px 0;
border-left: 5px solid #667eea;
background: linear-gradient(135deg, #f8f9fa 0%, #e9ecef 100%);
border-radius: 10px;
position: relative;
transition: all 0.3s ease;
}
.job:hover {
transform: translateX(5px);
box-shadow: 0 5px 20px rgba(0,0,0,0.1);
}
.job.awaiting_review {
border-left-color: #f39c12;
background: linear-gradient(135deg, #fff3cd 0%, #ffeaa7 100%);
}
.job.complete {
border-left-color: #27ae60;
background: linear-gradient(135deg, #d4edda 0%, #a8e6cf 100%);
}
.job.error {
border-left-color: #e74c3c;
background: linear-gradient(135deg, #f8d7da 0%, #ffb3ba 100%);
}
.job.processing {
border-left-color: #3498db;
background: linear-gradient(135deg, #d1ecf1 0%, #a8d8ea 100%);
}
/* Progress bar styles */
.progress-bar {
width: 100%;
height: 8px;
background-color: #e9ecef;
border-radius: 10px;
overflow: hidden;
margin: 15px 0;
box-shadow: inset 0 2px 4px rgba(0,0,0,0.1);
}
.progress-fill {
height: 100%;
background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
transition: width 0.5s ease;
border-radius: 10px;
}
/* Job actions */
.job-actions {
margin-top: 15px;
display: flex;
flex-wrap: wrap;
gap: 10px;
}
/* Job details and logs */
.job-details {
background-color: #fff;
border: 1px solid #dee2e6;
border-radius: 8px;
padding: 20px;
margin-top: 15px;
font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
font-size: 13px;
max-height: 400px;
overflow-y: auto;
box-shadow: inset 0 2px 4px rgba(0,0,0,0.05);
}
.log-entry {
margin: 8px 0;
padding: 5px 0;
border-bottom: 1px solid #f8f9fa;
}
.log-entry:last-child {
border-bottom: none;
}
.log-entry.error {
color: #e74c3c;
font-weight: bold;
background-color: #fdf2f2;
padding: 8px;
border-radius: 5px;
margin: 10px 0;
}
.log-entry.warning {
color: #f39c12;
background-color: #fefbf3;
padding: 8px;
border-radius: 5px;
margin: 10px 0;
}
.log-entry.info {
color: #3498db;
}
.timestamp {
color: #6c757d;
margin-right: 15px;
font-weight: 500;
}
/* Error details */
.error-details {
background: linear-gradient(135deg, #f8d7da 0%, #ffb3ba 100%);
border: 1px solid #f5c6cb;
border-radius: 8px;
padding: 15px;
margin-top: 15px;
color: #721c24;
font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
font-size: 13px;
}
/* Statistics dashboard */
.stats {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
gap: 20px;
margin-bottom: 30px;
}
.stat-card {
background: white;
padding: 25px;
border-radius: 15px;
box-shadow: 0 10px 30px rgba(0,0,0,0.1);
text-align: center;
transition: transform 0.3s ease, box-shadow 0.3s ease;
border-top: 4px solid #667eea;
}
.stat-card:hover {
transform: translateY(-5px);
box-shadow: 0 15px 40px rgba(0,0,0,0.15);
}
.stat-number {
font-size: 3em;
font-weight: bold;
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-webkit-background-clip: text;
-webkit-text-fill-color: transparent;
background-clip: text;
margin-bottom: 10px;
}
/* Admin controls */
.admin-controls {
background: linear-gradient(135deg, #f8f9fa 0%, #e9ecef 100%);
padding: 20px;
border-radius: 10px;
margin-bottom: 30px;
border: 1px solid #dee2e6;
}
.admin-controls label {
display: flex;
align-items: center;
margin-top: 10px;
font-weight: 500;
}
.admin-controls input[type="checkbox"] {
margin-right: 8px;
transform: scale(1.2);
}
/* Toggle and utility styles */
.toggle-details {
background: #6c757d;
color: white;
border: none;
padding: 8px 15px;
border-radius: 20px;
cursor: pointer;
font-size: 12px;
font-weight: 500;
transition: all 0.3s ease;
}
.toggle-details:hover {
background: #5a6268;
transform: translateY(-1px);
}
.hidden {
display: none;
}
/* Status message */
.status-message {
margin-top: 15px;
padding: 10px;
border-radius: 8px;
font-weight: 500;
text-align: center;
transition: all 0.3s ease;
}
.status-message.success {
background-color: #d4edda;
color: #155724;
border: 1px solid #c3e6cb;
}
.status-message.error {
background-color: #f8d7da;
color: #721c24;
border: 1px solid #f5c6cb;
}
.status-message.info {
background-color: #d1ecf1;
color: #0c5460;
border: 1px solid #bee5eb;
}
/* Footer */
footer {
text-align: center;
padding: 30px;
background: rgba(255, 255, 255, 0.9);
border-radius: 15px;
margin-top: 30px;
box-shadow: 0 10px 30px rgba(0,0,0,0.1);
}
footer a {
color: #667eea;
text-decoration: none;
font-weight: 600;
transition: color 0.3s ease;
}
footer a:hover {
color: #764ba2;
}
/* Responsive design */
@media (max-width: 768px) {
body {
padding: 10px;
}
.container {
padding: 20px;
}
h1 {
font-size: 2em;
}
.stats {
grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
gap: 15px;
}
.stat-number {
font-size: 2.5em;
}
.job-actions {
flex-direction: column;
}
button, .btn {
width: 100%;
margin: 5px 0;
}
}
/* Loading animation */
@keyframes pulse {
0% {
opacity: 1;
}
50% {
opacity: 0.5;
}
100% {
opacity: 1;
}
}
.loading {
animation: pulse 2s infinite;
}
/* Smooth scrolling */
html {
scroll-behavior: smooth;
}
+7
View File
@@ -0,0 +1,7 @@
import warnings
# Suppress specific SyntaxWarnings from third-party packages
warnings.filterwarnings("ignore", category=SyntaxWarning, module="pydub.*")
warnings.filterwarnings("ignore", category=SyntaxWarning, module="syrics.*")
from .karaoke_gen import KaraokePrep
@@ -133,8 +133,13 @@ class AudioProcessor:
runtime_mins = runtime.total_seconds() / 60
# Get process command line
proc = psutil.Process(pid)
cmd = " ".join(proc.cmdline())
try:
proc = psutil.Process(pid)
cmdline_args = proc.cmdline()
# Handle potential bytes in cmdline args (cross-platform compatibility)
cmd = " ".join(arg.decode('utf-8', errors='replace') if isinstance(arg, bytes) else arg for arg in cmdline_args)
except (psutil.AccessDenied, psutil.NoSuchProcess):
cmd = "<command unavailable>"
self.logger.info(
f"Waiting for other audio separation process to complete before starting separation for {artist_title}...\n"
@@ -182,7 +187,7 @@ class AudioProcessor:
stems_dir = self._create_stems_directory(track_output_dir)
result = {"clean_instrumental": {}, "other_stems": {}, "backing_vocals": {}, "combined_instrumentals": {}}
if os.environ.get("KARAOKE_PREP_SKIP_AUDIO_SEPARATION"):
if os.environ.get("KARAOKE_GEN_SKIP_AUDIO_SEPARATION"):
return result
result["clean_instrumental"] = self._separate_clean_instrumental(
File renamed without changes.
File renamed without changes.
@@ -924,7 +924,14 @@ class KaraokeFinalise:
else:
shutil.copy2(output_files["final_karaoke_lossy_mp4"], dest_mp4_file) # Changed to use lossy MP4
shutil.copy2(output_files["final_karaoke_lossy_720p_mp4"], dest_720p_mp4_file)
shutil.copy2(output_files["final_karaoke_cdg_zip"], dest_zip_file)
# Only copy CDG ZIP if CDG creation is enabled
if self.enable_cdg and "final_karaoke_cdg_zip" in output_files:
shutil.copy2(output_files["final_karaoke_cdg_zip"], dest_zip_file)
self.logger.info(f"Copied CDG ZIP file to public share directory")
else:
self.logger.info(f"CDG creation disabled, skipping CDG ZIP copy")
self.logger.info(f"Copied final files to public share directory")
def sync_public_share_dir_to_rclone_destination(self):
@@ -382,14 +382,20 @@ class KaraokePrep:
# Run transcription in a separate thread
transcription_future = asyncio.create_task(
asyncio.to_thread(
# Delegate to LyricsProcessor
self.lyrics_processor.transcribe_lyrics, processed_track["input_audio_wav"], lyrics_artist, lyrics_title, track_output_dir
# Delegate to LyricsProcessor - pass original artist/title for filenames, lyrics_artist/lyrics_title for processing
self.lyrics_processor.transcribe_lyrics,
processed_track["input_audio_wav"],
self.artist, # Original artist for filename generation
self.title, # Original title for filename generation
track_output_dir,
lyrics_artist, # Lyrics artist for processing
lyrics_title # Lyrics title for processing
)
)
self.logger.info(f"Transcription future created, type: {type(transcription_future)}")
# Default to a placeholder future if separation won't run
separation_future = asyncio.sleep(0)
# Default to a placeholder task if separation won't run
separation_future = asyncio.create_task(asyncio.sleep(0))
# Only create real separation future if not skipping AND no existing instrumental provided
if not self.skip_separation and not self.existing_instrumental:
@@ -501,7 +507,7 @@ class KaraokePrep:
processed_track["title_video"] = os.path.join(track_output_dir, f"{artist_title} (Title).mov")
# Use FileHandler._file_exists
if not self.file_handler._file_exists(processed_track["title_video"]) and not os.environ.get("KARAOKE_PREP_SKIP_TITLE_END_SCREENS"):
if not self.file_handler._file_exists(processed_track["title_video"]) and not os.environ.get("KARAOKE_GEN_SKIP_TITLE_END_SCREENS"):
self.logger.info(f"Creating title video...")
# Delegate to VideoGenerator
self.video_generator.create_title_video(
@@ -520,7 +526,7 @@ class KaraokePrep:
processed_track["end_video"] = os.path.join(track_output_dir, f"{artist_title} (End).mov")
# Use FileHandler._file_exists
if not self.file_handler._file_exists(processed_track["end_video"]) and not os.environ.get("KARAOKE_PREP_SKIP_TITLE_END_SCREENS"):
if not self.file_handler._file_exists(processed_track["end_video"]) and not os.environ.get("KARAOKE_GEN_SKIP_TITLE_END_SCREENS"):
self.logger.info(f"Creating end screen video...")
# Delegate to VideoGenerator
self.video_generator.create_end_video(
@@ -102,14 +102,33 @@ class LyricsProcessor:
return processed_lines
def transcribe_lyrics(self, input_audio_wav, artist, title, track_output_dir):
def transcribe_lyrics(self, input_audio_wav, artist, title, track_output_dir, lyrics_artist=None, lyrics_title=None):
"""
Transcribe lyrics for a track.
Args:
input_audio_wav: Path to the audio file
artist: Original artist name (used for filename generation)
title: Original title (used for filename generation)
track_output_dir: Output directory path
lyrics_artist: Artist name for lyrics processing (defaults to artist if None)
lyrics_title: Title for lyrics processing (defaults to title if None)
"""
# Use original artist/title for filename generation
filename_artist = artist
filename_title = title
# Use lyrics_artist/lyrics_title for actual lyrics processing, fall back to originals if not provided
processing_artist = lyrics_artist or artist
processing_title = lyrics_title or title
self.logger.info(
f"Transcribing lyrics for track {artist} - {title} from audio file: {input_audio_wav} with output directory: {track_output_dir}"
f"Transcribing lyrics for track {processing_artist} - {processing_title} from audio file: {input_audio_wav} with output directory: {track_output_dir}"
)
# Check for existing files first using sanitized names
sanitized_artist = sanitize_filename(artist)
sanitized_title = sanitize_filename(title)
# Check for existing files first using sanitized names from ORIGINAL artist/title for consistency
sanitized_artist = sanitize_filename(filename_artist)
sanitized_title = sanitize_filename(filename_title)
parent_video_path = os.path.join(track_output_dir, f"{sanitized_artist} - {sanitized_title} (With Vocals).mkv")
parent_lrc_path = os.path.join(track_output_dir, f"{sanitized_artist} - {sanitized_title} (Karaoke).lrc")
@@ -137,10 +156,15 @@ class LyricsProcessor:
"ass_filepath": parent_video_path,
}
# Create lyrics subdirectory for new transcription
# Create lyrics directory if it doesn't exist
os.makedirs(lyrics_dir, exist_ok=True)
self.logger.info(f"Created lyrics directory: {lyrics_dir}")
# Set render_video to False if explicitly disabled
render_video = self.render_video
if not render_video:
self.logger.info("Video rendering disabled, skipping video output")
# Load environment variables
load_dotenv()
env_config = {
@@ -165,7 +189,7 @@ class LyricsProcessor:
output_config = OutputConfig(
output_styles_json=self.style_params_json,
output_dir=lyrics_dir,
render_video=self.render_video,
render_video=render_video,
fetch_lyrics=True,
run_transcription=not self.skip_transcription,
run_correction=True,
@@ -180,11 +204,11 @@ class LyricsProcessor:
# Add this log entry to debug the OutputConfig
self.logger.info(f"Instantiating LyricsTranscriber with OutputConfig: {output_config}")
# Initialize transcriber with new config objects
# Initialize transcriber with new config objects - use PROCESSING artist/title for lyrics work
transcriber = LyricsTranscriber(
audio_filepath=input_audio_wav,
artist=artist,
title=title,
artist=processing_artist, # Use lyrics_artist for processing
title=processing_title, # Use lyrics_title for processing
transcriber_config=transcriber_config,
lyrics_config=lyrics_config,
output_config=output_config,
File renamed without changes.
File renamed without changes.
File renamed without changes.
@@ -7,8 +7,8 @@ import csv
import asyncio
import json
import sys
from karaoke_prep import KaraokePrep
from karaoke_prep.karaoke_finalise import KaraokeFinalise
from karaoke_gen import KaraokePrep
from karaoke_gen.karaoke_finalise import KaraokeFinalise
# Global logger
logger = logging.getLogger(__name__)
@@ -1,5 +1,4 @@
#!/usr/bin/env python
print("DEBUG: gen_cli.py starting imports...")
import argparse
import logging
from importlib import metadata
@@ -10,10 +9,8 @@ import json
import asyncio
import time
import pyperclip
from karaoke_prep import KaraokePrep
from karaoke_prep.karaoke_finalise import KaraokeFinalise
print("DEBUG: gen_cli.py imports complete.")
from karaoke_gen import KaraokePrep
from karaoke_gen.karaoke_finalise import KaraokeFinalise
def is_url(string):
@@ -27,15 +24,12 @@ def is_file(string):
async def async_main():
print("DEBUG: async_main() started.")
logger = logging.getLogger(__name__)
log_handler = logging.StreamHandler()
log_formatter = logging.Formatter(fmt="%(asctime)s.%(msecs)03d - %(levelname)s - %(module)s - %(message)s", datefmt="%Y-%m-%d %H:%M:%S")
log_handler.setFormatter(log_formatter)
logger.addHandler(log_handler)
print("DEBUG: async_main() logger configured.")
parser = argparse.ArgumentParser(
description="Generate karaoke videos with synchronized lyrics. Handles the entire process from downloading audio and lyrics to creating the final video.",
formatter_class=lambda prog: argparse.RawTextHelpFormatter(prog, max_help_position=54),
@@ -53,7 +47,6 @@ async def async_main():
package_version = metadata.version("karaoke-gen")
except metadata.PackageNotFoundError:
package_version = "unknown"
print("DEBUG: Could not find version for karaoke-gen")
parser.add_argument("-v", "--version", action="version", version=f"%(prog)s {package_version}")
@@ -290,8 +283,6 @@ async def async_main():
args = parser.parse_args()
print("DEBUG: async_main() args parsed.")
# Handle test email template case first
if args.test_email_template:
log_level = getattr(logging, args.log_level.upper())
@@ -305,8 +296,6 @@ async def async_main():
kfinalise.test_email_template()
return
print("DEBUG: async_main() continuing after test_email_template check.")
# Handle edit-lyrics mode
if args.edit_lyrics:
log_level = getattr(logging, args.log_level.upper())
@@ -484,8 +473,6 @@ async def async_main():
raise e
return
print("DEBUG: async_main() continuing after edit_lyrics check.")
# Handle finalise-only mode
if args.finalise_only:
@@ -512,7 +499,11 @@ async def async_main():
logger.error(f"Invalid JSON in CDG styles configuration file: {e}")
sys.exit(1)
return # Explicit return for testing
except KeyError:
logger.error(f"'cdg' key not found in style parameters file: {args.style_params_json}")
sys.exit(1)
return # Explicit return for testing
kfinalise = KaraokeFinalise(
log_formatter=log_formatter,
log_level=log_level,
@@ -530,13 +521,16 @@ async def async_main():
discord_webhook_url=args.discord_webhook_url,
email_template_file=args.email_template_file,
cdg_styles=cdg_styles,
keep_brand_code=args.keep_brand_code,
keep_brand_code=getattr(args, 'keep_brand_code', False),
non_interactive=args.yes,
)
try:
track = kfinalise.process()
logger.info(f"Karaoke finalisation processing complete! Output files:")
logger.info(f"Successfully completed finalisation for: {track['artist']} - {track['title']}")
# Display summary of outputs
logger.info(f"Karaoke finalisation complete! Output files:")
logger.info(f"")
logger.info(f"Track: {track['artist']} - {track['title']}")
logger.info(f"")
@@ -564,7 +558,7 @@ async def async_main():
logger.info(f"")
logger.info(f"Organization:")
logger.info(f" Brand Code: {track['brand_code']}")
logger.info(f" New Directory: {track['new_brand_code_dir_path']}")
logger.info(f" Directory: {track['new_brand_code_dir_path']}")
if track["youtube_url"] or track["brand_code_dir_sharing_link"]:
logger.info(f"")
@@ -592,8 +586,6 @@ async def async_main():
return
print("DEBUG: async_main() parsed positional args.")
# For prep or full workflow, parse input arguments
input_media, artist, title, filename_pattern = None, None, None, None
@@ -643,23 +635,18 @@ async def async_main():
log_level = getattr(logging, args.log_level.upper())
logger.setLevel(log_level)
print("DEBUG: async_main() log level set.")
# Set up environment variables for lyrics-only mode
if args.lyrics_only:
args.skip_separation = True
os.environ["KARAOKE_PREP_SKIP_AUDIO_SEPARATION"] = "1"
os.environ["KARAOKE_PREP_SKIP_TITLE_END_SCREENS"] = "1"
os.environ["KARAOKE_GEN_SKIP_AUDIO_SEPARATION"] = "1"
os.environ["KARAOKE_GEN_SKIP_TITLE_END_SCREENS"] = "1"
logger.info("Lyrics-only mode enabled: skipping audio separation and title/end screen generation")
print("DEBUG: async_main() instantiating KaraokePrep...")
# Step 1: Run KaraokePrep
logger.info(f"KaraokePrep beginning with input_media: {input_media} artist: {artist} and title: {title}")
kprep_coroutine = KaraokePrep(
input_media=input_media,
artist=artist,
title=title,
input_media=input_media,
filename_pattern=filename_pattern,
dry_run=args.dry_run,
log_formatter=log_formatter,
@@ -688,64 +675,16 @@ async def async_main():
# No await needed for constructor
kprep = kprep_coroutine
print("DEBUG: async_main() KaraokePrep instantiated.")
print(f"DEBUG: kprep type: {type(kprep)}")
print(f"DEBUG: kprep.process type: {type(kprep.process)}")
process_coroutine = kprep.process()
print(f"DEBUG: process_coroutine type: {type(process_coroutine)}")
tracks = await process_coroutine
# Create final tracks data structure
tracks = await kprep.process()
print("DEBUG: async_main() kprep.process() finished.")
# If prep-only mode, display detailed output and exit
# If prep-only mode, we're done
if args.prep_only:
logger.info(f"Karaoke Prep complete! Output files:")
for track in tracks:
logger.info(f"")
logger.info(f"Track: {track['artist']} - {track['title']}")
logger.info(f" Input Media: {track['input_media']}")
logger.info(f" Input WAV Audio: {track['input_audio_wav']}")
logger.info(f" Input Still Image: {track['input_still_image']}")
logger.info(f" Lyrics: {track['lyrics']}")
logger.info(f" Processed Lyrics: {track['processed_lyrics']}")
logger.info(f" Separated Audio:")
# Clean Instrumental
logger.info(f" Clean Instrumental Model:")
for stem_type, file_path in track["separated_audio"]["clean_instrumental"].items():
logger.info(f" {stem_type.capitalize()}: {file_path}")
# Other Stems
logger.info(f" Other Stems Models:")
for model, stems in track["separated_audio"]["other_stems"].items():
logger.info(f" Model: {model}")
for stem_type, file_path in stems.items():
logger.info(f" {stem_type.capitalize()}: {file_path}")
# Backing Vocals
logger.info(f" Backing Vocals Models:")
for model, stems in track["separated_audio"]["backing_vocals"].items():
logger.info(f" Model: {model}")
for stem_type, file_path in stems.items():
logger.info(f" {stem_type.capitalize()}: {file_path}")
# Combined Instrumentals
logger.info(f" Combined Instrumentals:")
for model, file_path in track["separated_audio"]["combined_instrumentals"].items():
logger.info(f" Model: {model}")
logger.info(f" Combined Instrumental: {file_path}")
logger.info("Preparation phase complete. Exiting due to --prep-only flag.")
logger.info("Prep-only mode: skipping finalisation phase")
return
print("DEBUG: async_main() continuing after prep_only check.")
# Step 2: For each track, run KaraokeFinalise
for track in tracks:
print(f"DEBUG: async_main() starting finalise loop for track: {track.get('track_output_dir')}")
logger.info(f"Starting finalisation phase for {track['artist']} - {track['title']}...")
# Use the track directory that was actually created by KaraokePrep
@@ -776,8 +715,11 @@ async def async_main():
logger.error(f"Invalid JSON in CDG styles configuration file: {e}")
sys.exit(1)
return # Explicit return for testing
except KeyError:
logger.error(f"'cdg' key not found in style parameters file: {args.style_params_json}")
sys.exit(1)
return # Explicit return for testing
# Initialize KaraokeFinalise
kfinalise = KaraokeFinalise(
log_formatter=log_formatter,
log_level=log_level,
@@ -795,16 +737,16 @@ async def async_main():
discord_webhook_url=args.discord_webhook_url,
email_template_file=args.email_template_file,
cdg_styles=cdg_styles,
keep_brand_code=args.keep_brand_code,
keep_brand_code=getattr(args, 'keep_brand_code', False),
non_interactive=args.yes,
)
try:
final_track = kfinalise.process()
logger.info(f"Successfully completed processing for: {track['artist']} - {track['title']}")
logger.info(f"Successfully completed processing: {final_track['artist']} - {final_track['title']}")
# Display summary of outputs
logger.info(f"Karaoke processing complete! Output files:")
logger.info(f"Karaoke generation complete! Output files:")
logger.info(f"")
logger.info(f"Track: {final_track['artist']} - {final_track['title']}")
logger.info(f"")
@@ -832,7 +774,7 @@ async def async_main():
logger.info(f"")
logger.info(f"Organization:")
logger.info(f" Brand Code: {final_track['brand_code']}")
logger.info(f" New Directory: {final_track['new_brand_code_dir_path']}")
logger.info(f" Directory: {final_track['new_brand_code_dir_path']}")
if final_track["youtube_url"] or final_track["brand_code_dir_sharing_link"]:
logger.info(f"")
@@ -854,20 +796,16 @@ async def async_main():
logger.info(f" (YouTube URL copied to clipboard)")
except Exception as e:
logger.warning(f" Failed to copy YouTube URL to clipboard: {str(e)}")
except Exception as e:
logger.error(f"Error during finalisation: {str(e)}")
logger.error(f"An error occurred during finalisation, see stack trace below: {str(e)}")
raise e
print("DEBUG: async_main() finished.")
return
def main():
print("DEBUG: main() started.")
asyncio.run(async_main())
print("DEBUG: main() finished.")
if __name__ == "__main__":
print("DEBUG: __main__ block executing.")
main()
@@ -71,7 +71,7 @@ class VideoGenerator:
else:
# Try to load from package resources
try:
with pkg_resources.path("karaoke_prep.resources", format["font"]) as font_path:
with pkg_resources.path("karaoke_gen.resources", format["font"]) as font_path:
font_path = str(font_path)
except Exception as e:
self.logger.warning(f"Could not load font from resources: {e}, falling back to default font")
@@ -96,7 +96,7 @@ class VideoGenerator:
def calculate_text_size_to_fit(self, draw, text, font_path, region):
font_size = 500 # Start with a large font size
font = ImageFont.truetype(font_path, size=font_size) if os.path.exists(font_path) else ImageFont.load_default()
font = ImageFont.truetype(font_path, size=font_size) if font_path and os.path.exists(font_path) else ImageFont.load_default()
def get_text_size(text, font):
bbox = draw.textbbox((0, 0), text, font=font)
@@ -117,7 +117,7 @@ class VideoGenerator:
# Reset font size for two-line layout
font_size = 500
font = ImageFont.truetype(font_path, size=font_size) if os.path.exists(font_path) else ImageFont.load_default()
font = ImageFont.truetype(font_path, size=font_size) if font_path and os.path.exists(font_path) else ImageFont.load_default()
while True:
text_width1, text_height1 = get_text_size(line1, font)
@@ -134,9 +134,9 @@ class VideoGenerator:
font_size -= 10
if font_size <= 0:
raise ValueError("Cannot fit text within the defined region.")
font = ImageFont.truetype(font_path, size=font_size) if os.path.exists(font_path) else ImageFont.load_default()
font = ImageFont.truetype(font_path, size=font_size) if font_path and os.path.exists(font_path) else ImageFont.load_default()
font = ImageFont.truetype(font_path, size=font_size) if os.path.exists(font_path) else ImageFont.load_default()
font = ImageFont.truetype(font_path, size=font_size) if font_path and os.path.exists(font_path) else ImageFont.load_default()
text_width, text_height = get_text_size(text, font)
return font, text
-1
View File
@@ -1 +0,0 @@
from .karaoke_prep import KaraokePrep
Generated
+2292 -1523
View File
File diff suppressed because it is too large. Load diff
+38 -13
View File
@@ -1,18 +1,18 @@
[tool.poetry]
name = "karaoke-gen"
version = "0.50.0"
version = "0.55.0"
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"
readme = "README.md"
packages = [{ include = "karaoke_prep" }]
homepage = "https://github.com/karaokenerds/karaoke-gen"
repository = "https://github.com/karaokenerds/karaoke-gen"
documentation = "https://github.com/karaokenerds/karaoke-gen/blob/main/README.md"
packages = [{ include = "karaoke_gen" }]
homepage = "https://github.com/nomadkaraoke/karaoke-gen"
repository = "https://github.com/nomadkaraoke/karaoke-gen"
documentation = "https://github.com/nomadkaraoke/karaoke-gen/blob/main/README.md"
[tool.poetry.dependencies]
python = ">=3.10,<3.13"
torch = "<2.5"
python = ">=3.10,<3.14"
torch = ">=2.7"
requests = ">=2"
beautifulsoup4 = ">=4"
yt-dlp = "*"
@@ -25,10 +25,10 @@ google-auth = "*"
google-auth-oauthlib = "*"
google-auth-httplib2 = "*"
thefuzz = ">=0.22"
numpy = "^1"
audio-separator = { version = ">=0.21.0", extras = ["cpu"] }
numpy = ">=2"
audio-separator = { version = ">=0.34.0", extras = ["cpu"] }
lyrics-converter = ">=0.2.1"
lyrics-transcriber = ">=0.34"
lyrics-transcriber = ">=0.54"
kbputils = "^0.0.16"
attrs = ">=24.2.0"
cattrs = ">=24.1.2"
@@ -42,11 +42,15 @@ ffmpeg-python = "^0.2.0"
[tool.poetry.group.dev.dependencies]
black = ">=23"
poetry = "*"
pytest-mock = "*"
pytest = ">=7.0"
pytest-cov = ">=4.0"
pytest-mock = ">=3.10"
pytest-asyncio = ">=0.21.0"
[tool.poetry.scripts]
karaoke-gen = 'karaoke_prep.utils.gen_cli:main'
karaoke-bulk = 'karaoke_prep.utils.bulk_cli:main'
karaoke-gen = 'karaoke_gen.utils.gen_cli:main'
karaoke-bulk = 'karaoke_gen.utils.bulk_cli:main'
[tool.black]
line-length = 140
@@ -54,3 +58,24 @@ line-length = 140
[build-system]
requires = ["poetry-core"]
build-backend = "poetry.core.masonry.api"
[tool.pytest.ini_options]
testpaths = ["tests/unit", "tests/integration"]
python_files = ["test_*.py"]
addopts = [
"--cov=karaoke_gen",
"--cov-report=term-missing",
"--cov-report=html:htmlcov",
"--asyncio-mode=auto",
]
markers = [
"slow: marks tests as slow (deselect with '-m \"not slow\"')",
"integration: marks tests as integration tests",
"asyncio: mark test as async",
]
filterwarnings = [
"ignore::DeprecationWarning",
"ignore:'audioop' is deprecated:DeprecationWarning",
"ignore::RuntimeWarning",
"ignore::UserWarning",
]
-7
View File
@@ -1,7 +0,0 @@
[pytest]
markers =
slow: marks tests as slow (deselect with '-m "not slow"')
asyncio: mark test as async
# By default, skip slow tests
addopts = -m "not slow"
Binary file not shown.

After

Width:  |  Height:  |  Size: 683 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 683 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 24 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 29 KiB

+10 -10
View File
@@ -3,8 +3,8 @@
"video_duration": 5,
"existing_image": null,
"background_color": "#000000",
"background_image": "/Users/andrew/AB Dropbox/Andrew Beveridge/MediaUnsynced/Karaoke/NomadBranding/karaoke-title-screen-background-nomad-4k.png",
"font": "/Users/andrew/AB Dropbox/Andrew Beveridge/MediaUnsynced/Karaoke/NomadBranding/AvenirNext-Bold.ttf",
"background_image": "/tmp/karaoke-title-screen-background-nomad-4k.png",
"font": "/tmp/AvenirNext-Bold.ttf",
"artist_color": "#ffdf6b",
"artist_text_transform": "uppercase",
"title_color": "#ffffff",
@@ -20,9 +20,9 @@
"extra_text_text_transform": "uppercase"
},
"karaoke": {
"background_image": "/Users/andrew/AB Dropbox/Andrew Beveridge/MediaUnsynced/Karaoke/NomadBranding/karaoke-background-image-nomad-4k.png",
"background_image": "/tmp/karaoke-background-image-nomad-4k.png",
"background_color": "#000000",
"font_path": "/Users/andrew/AB Dropbox/Andrew Beveridge/MediaUnsynced/Karaoke/NomadBranding/AvenirNext-Bold.ttf",
"font_path": "/tmp/AvenirNext-Bold.ttf",
"font": "Avenir Next Bold",
"ass_name": "Nomad",
"primary_color": "112, 112, 247, 255",
@@ -49,8 +49,8 @@
"video_duration": 5,
"existing_image": null,
"background_color": "#000000",
"background_image": "/Users/andrew/AB Dropbox/Andrew Beveridge/MediaUnsynced/Karaoke/NomadBranding/karaoke-background-image-nomad-4k.png",
"font": "/Users/andrew/AB Dropbox/Andrew Beveridge/MediaUnsynced/Karaoke/NomadBranding/AvenirNext-Bold.ttf",
"background_image": "/tmp/karaoke-background-image-nomad-4k.png",
"font": "/tmp/AvenirNext-Bold.ttf",
"artist_color": "#ffdf6b",
"artist_text_transform": "uppercase",
"title_color": "#ffffff",
@@ -91,7 +91,7 @@
"instrumental_font_color": "#ffdf6b",
"//font": "Font settings",
"font_path": "/Users/andrew/AB Dropbox/Andrew Beveridge/MediaUnsynced/Karaoke/NomadBranding/AvenirNext-Bold.ttf",
"font_path": "/tmp/AvenirNext-Bold.ttf",
"font_size": 18,
"stroke_width": 0,
"stroke_style": "octagon",
@@ -99,18 +99,18 @@
"//instrumental": "Instrumental section settings",
"instrumental_gap_threshold": 1500,
"instrumental_text": "INSTRUMENTAL",
"instrumental_background": "/Users/andrew/AB Dropbox/Andrew Beveridge/MediaUnsynced/Karaoke/NomadBranding/cdg-instrumental-background-nomad-notes.png",
"instrumental_background": "/tmp/cdg-instrumental-background-nomad-notes.png",
"instrumental_transition": "topleftmusicalnotes",
"//title": "Title screen settings",
"title_screen_background": "/Users/andrew/AB Dropbox/Andrew Beveridge/MediaUnsynced/Karaoke/NomadBranding/cdg-title-screen-background-nomad-simple.png",
"title_screen_background": "/tmp/cdg-title-screen-background-nomad-simple.png",
"title_screen_transition": "largecentertexttoplogo",
"title_artist_gap": 10,
"intro_duration_seconds": 5.0,
"first_syllable_buffer_seconds": 3.0,
"//outro": "Outro screen settings",
"outro_background": "/Users/andrew/AB Dropbox/Andrew Beveridge/MediaUnsynced/Karaoke/NomadBranding/cdg-title-screen-background-nomad-simple.png",
"outro_background": "/tmp/cdg-title-screen-background-nomad-simple.png",
"outro_transition": "largecentertexttoplogo",
"outro_text_line1": "THANK YOU FOR SINGING!",
"outro_text_line2": "nomadkaraoke.com",
@@ -2,11 +2,11 @@ import os
import pytest
import sys
import json
from karaoke_prep.karaoke_prep import KaraokePrep
from karaoke_prep.file_handler import FileHandler
from karaoke_gen.karaoke_gen import KaraokePrep
from karaoke_gen.file_handler import FileHandler
from unittest.mock import MagicMock, call, patch, AsyncMock, ANY
from karaoke_prep.utils.gen_cli import async_main
from karaoke_prep.karaoke_finalise.karaoke_finalise import KaraokeFinalise
from karaoke_gen.utils.gen_cli import async_main
from karaoke_gen.karaoke_finalise.karaoke_finalise import KaraokeFinalise
# Register the asyncio marker
pytest.mark.asyncio = pytest.mark.asyncio
@@ -16,6 +16,7 @@ pytest_configure = lambda config: config.addinivalue_line("markers", "asyncio: m
@pytest.mark.asyncio
@pytest.mark.integration
async def test_cli_edit_lyrics_integration(mocker): # Remove tmp_path
"""Tests the --edit-lyrics CLI workflow using high-level mocks."""
# --- 1. Define Test Variables ---
@@ -30,7 +31,7 @@ async def test_cli_edit_lyrics_integration(mocker): # Remove tmp_path
# Mock KaraokePrep methods
# Mock extract_artist_title_from_dir_name to avoid needing real directory
# mocker.patch(\'karaoke_prep.karaoke_prep.KaraokePrep.extract_artist_title_from_dir_name\', return_value=(artist, title)) # REMOVED - Logic is in gen_cli
# mocker.patch(\'karaoke_gen.karaoke_gen.KaraokePrep.extract_artist_title_from_dir_name\', return_value=(artist, title)) # REMOVED - Logic is in gen_cli
# Mock the process method entirely or spy on __init__ and process
prep_init_spy = mocker.spy(KaraokePrep, '__init__')
# Mock the process method to avoid its internal logic, return a dummy result
@@ -57,7 +58,7 @@ async def test_cli_edit_lyrics_integration(mocker): # Remove tmp_path
# Mock LyricsProcessor (part of KaraokePrep, but good to ensure it\'s called)
# Mock transcribe_lyrics to return dummy data needed by KaraokePrep mock result
# mock_transcribe = mocker.patch( # REMOVED - Not needed as KaraokePrep.process is mocked
# \'karaoke_prep.lyrics_processor.LyricsProcessor.transcribe_lyrics\',
# \'karaoke_gen.lyrics_processor.LyricsProcessor.transcribe_lyrics\',
# new_callable=AsyncMock, # Make it async
# return_value={
# \'corrected_lyrics_text\': \'Edited lyrics line 1\\nEdited lyrics line 2\',
@@ -70,7 +71,7 @@ async def test_cli_edit_lyrics_integration(mocker): # Remove tmp_path
# Mock KaraokeFinalise methods
# Mock detect_best_aac_codec called during __init__ to avoid os.popen
mocker.patch('karaoke_prep.karaoke_finalise.karaoke_finalise.KaraokeFinalise.detect_best_aac_codec', return_value='aac_at')
mocker.patch('karaoke_gen.karaoke_finalise.karaoke_finalise.KaraokeFinalise.detect_best_aac_codec', return_value='aac_at')
finalise_init_spy = mocker.spy(KaraokeFinalise, '__init__')
# Mock the process method to avoid its internal logic, provide a more complete return dict
mock_finalise_result = {
@@ -128,14 +129,14 @@ async def test_cli_edit_lyrics_integration(mocker): # Remove tmp_path
mocker.patch('googleapiclient.discovery.build', return_value=MagicMock())
mocker.patch('google_auth_oauthlib.flow.InstalledAppFlow.from_client_secrets_file', MagicMock())
# Mock specific finalise methods related to external APIs
mocker.patch('karaoke_prep.karaoke_finalise.karaoke_finalise.KaraokeFinalise.authenticate_youtube', return_value=MagicMock())
mocker.patch('karaoke_prep.karaoke_finalise.karaoke_finalise.KaraokeFinalise.check_if_video_title_exists_on_youtube_channel', return_value='existing_video_id') # Crucial for replace logic
mocker.patch('karaoke_prep.karaoke_finalise.karaoke_finalise.KaraokeFinalise.upload_final_mp4_to_youtube_with_title_thumbnail', MagicMock())
mocker.patch('karaoke_prep.karaoke_finalise.karaoke_finalise.KaraokeFinalise.authenticate_gmail', return_value=MagicMock())
mocker.patch('karaoke_prep.karaoke_finalise.karaoke_finalise.KaraokeFinalise.draft_completion_email', MagicMock())
mocker.patch('karaoke_prep.karaoke_finalise.karaoke_finalise.KaraokeFinalise.post_discord_notification', MagicMock())
mocker.patch('karaoke_prep.karaoke_finalise.karaoke_finalise.KaraokeFinalise.sync_public_share_dir_to_rclone_destination', MagicMock())
mocker.patch('karaoke_prep.karaoke_finalise.karaoke_finalise.KaraokeFinalise.generate_organised_folder_sharing_link', return_value="https://fake.sharing.link/mock_edit_folder")
mocker.patch('karaoke_gen.karaoke_finalise.karaoke_finalise.KaraokeFinalise.authenticate_youtube', return_value=MagicMock())
mocker.patch('karaoke_gen.karaoke_finalise.karaoke_finalise.KaraokeFinalise.check_if_video_title_exists_on_youtube_channel', return_value='existing_video_id') # Crucial for replace logic
mocker.patch('karaoke_gen.karaoke_finalise.karaoke_finalise.KaraokeFinalise.upload_final_mp4_to_youtube_with_title_thumbnail', MagicMock())
mocker.patch('karaoke_gen.karaoke_finalise.karaoke_finalise.KaraokeFinalise.authenticate_gmail', return_value=MagicMock())
mocker.patch('karaoke_gen.karaoke_finalise.karaoke_finalise.KaraokeFinalise.draft_completion_email', MagicMock())
mocker.patch('karaoke_gen.karaoke_finalise.karaoke_finalise.KaraokeFinalise.post_discord_notification', MagicMock())
mocker.patch('karaoke_gen.karaoke_finalise.karaoke_finalise.KaraokeFinalise.sync_public_share_dir_to_rclone_destination', MagicMock())
mocker.patch('karaoke_gen.karaoke_finalise.karaoke_finalise.KaraokeFinalise.generate_organised_folder_sharing_link', return_value="https://fake.sharing.link/mock_edit_folder")
# Mock pydub
mocker.patch('pydub.AudioSegment.from_file', return_value=MagicMock(duration_seconds=10)) # Need duration
@@ -5,13 +5,13 @@ import shutil
import subprocess
import sys
import json
from karaoke_prep.karaoke_prep import KaraokePrep
from karaoke_gen.karaoke_gen import KaraokePrep
from unittest.mock import MagicMock, call, patch, AsyncMock, ANY
from karaoke_prep.utils.gen_cli import async_main
from karaoke_gen.utils.gen_cli import async_main
import shlex
import asyncio
from googleapiclient.http import MediaFileUpload
from karaoke_prep.karaoke_finalise.karaoke_finalise import KaraokeFinalise
from karaoke_gen.karaoke_finalise.karaoke_finalise import KaraokeFinalise
# Register the asyncio marker
pytest.mark.asyncio = pytest.mark.asyncio
@@ -21,7 +21,8 @@ pytest_configure = lambda config: config.addinivalue_line("markers", "asyncio: m
@pytest.mark.asyncio
async def test_karaoke_prep_integration():
@pytest.mark.integration
async def test_karaoke_gen_integration():
# Create a temporary directory for test outputs
with tempfile.TemporaryDirectory() as temp_dir:
# Create a dummy input file (e.g., a small WAV file)
@@ -73,8 +74,8 @@ async def test_karaoke_prep_integration():
return None # Indicate failure
# Mock external dependencies and handler methods
with patch('karaoke_prep.metadata.extract_info_for_online_media') as mock_extract, \
patch('karaoke_prep.metadata.parse_track_metadata') as mock_parse, \
with patch('karaoke_gen.metadata.extract_info_for_online_media') as mock_extract, \
patch('karaoke_gen.metadata.parse_track_metadata') as mock_parse, \
patch.object(kp.file_handler, 'setup_output_paths', return_value=(os.path.join(temp_dir, "Test Artist - Test Title"), "Test Artist - Test Title")) as mock_setup_paths, \
patch.object(kp.file_handler, 'copy_input_media', return_value="copied.mp4") as mock_copy, \
patch.object(kp.file_handler, 'convert_to_wav', side_effect=create_dummy_wav) as mock_convert, \
@@ -149,6 +150,7 @@ async def test_karaoke_prep_integration():
@pytest.mark.asyncio
@pytest.mark.integration
@pytest.mark.slow
async def test_full_cli_integration(tmp_path, mocker):
"""Tests the full CLI workflow by calling async_main directly with mocked sys.argv."""
@@ -174,7 +176,32 @@ async def test_full_cli_integration(tmp_path, mocker):
input_audio = data_dir / os.path.basename(source_audio)
shutil.copy2(source_audio, input_audio)
# Copy real style params file instead of creating dummy
# Copy background images to /tmp directory (exists on both local and CI)
background_images = [
"karaoke-background-image-nomad-4k.png",
"karaoke-title-screen-background-nomad-4k.png",
"cdg-instrumental-background-nomad-notes.png",
"cdg-title-screen-background-nomad-simple.png"
]
for image_name in background_images:
source_image = f"tests/data/{image_name}"
if os.path.exists(source_image):
dest_image = f"/tmp/{image_name}"
shutil.copy2(source_image, dest_image)
print(f"Copied {source_image} to {dest_image}")
else:
print(f"Warning: Background image {source_image} not found, skipping")
# Copy font file to /tmp directory
font_source = "karaoke_gen/resources/AvenirNext-Bold.ttf"
font_dest = "/tmp/AvenirNext-Bold.ttf"
if os.path.exists(font_source):
shutil.copy2(font_source, font_dest)
print(f"Copied {font_source} to {font_dest}")
else:
print(f"Warning: Font file {font_source} not found, skipping")
# Copy styles.json file (which now has /tmp paths)
source_style_params = "tests/data/styles.json"
style_params_path = data_dir / os.path.basename(source_style_params)
shutil.copy2(source_style_params, style_params_path)
@@ -195,6 +222,11 @@ async def test_full_cli_integration(tmp_path, mocker):
with open(email_template_path, "w") as f:
f.write("Subject: Test Email\n\nYT: {youtube_url}\nDB: {dropbox_url}")
# --- Define test variables used later in assertions ---
expected_brand_code = "NOMAD-0001"
discord_webhook_url = "https://discord.com/api/webhooks/123/abc"
rclone_destination = "andrewdropboxfull:public_share"
# --- 2. Mock External Interactions ---
# Mock YouTube API
mock_youtube_service = MagicMock()
@@ -206,10 +238,10 @@ async def test_full_cli_integration(tmp_path, mocker):
# Mock YouTube credential flow and existing video check
mocker.patch('google_auth_oauthlib.flow.InstalledAppFlow.from_client_secrets_file')
mocker.patch('karaoke_prep.karaoke_finalise.karaoke_finalise.KaraokeFinalise.check_if_video_title_exists_on_youtube_channel', return_value=False)
mocker.patch('karaoke_gen.karaoke_finalise.karaoke_finalise.KaraokeFinalise.check_if_video_title_exists_on_youtube_channel', return_value=False)
# Mock the upload_final_mp4_to_youtube_with_title_thumbnail method to directly return mock_video_id to bypass YouTube API issues
mock_upload = mocker.patch('karaoke_prep.karaoke_finalise.karaoke_finalise.KaraokeFinalise.upload_final_mp4_to_youtube_with_title_thumbnail')
mock_upload = mocker.patch('karaoke_gen.karaoke_finalise.karaoke_finalise.KaraokeFinalise.upload_final_mp4_to_youtube_with_title_thumbnail')
# Set video_id and url attributes that would normally be set during upload
def side_effect(*args, **kwargs):
instance = args[0] # First arg is self
@@ -218,10 +250,10 @@ async def test_full_cli_integration(tmp_path, mocker):
mock_upload.side_effect = side_effect
# Keep the authenticate_youtube mock to return the service
mocker.patch('karaoke_prep.karaoke_finalise.karaoke_finalise.KaraokeFinalise.authenticate_youtube', return_value=mock_youtube_service)
mocker.patch('karaoke_gen.karaoke_finalise.karaoke_finalise.KaraokeFinalise.authenticate_youtube', return_value=mock_youtube_service)
# Mock Gmail API (reuse youtube mock for simplicity, just check call)
mocker.patch('karaoke_prep.karaoke_finalise.karaoke_finalise.KaraokeFinalise.authenticate_gmail', return_value=mock_youtube_service)
mocker.patch('karaoke_gen.karaoke_finalise.karaoke_finalise.KaraokeFinalise.authenticate_gmail', return_value=mock_youtube_service)
mock_draft_create = MagicMock()
mock_draft_create.execute.return_value = {'id': 'mock_draft_id'}
mock_youtube_service.users().drafts().create.return_value = mock_draft_create
@@ -257,6 +289,13 @@ async def test_full_cli_integration(tmp_path, mocker):
# This covers the os.system call for ffmpeg
if cmd_arg.strip().startswith("ffmpeg"):
should_execute = True
elif hasattr(cmd_arg, 'strip') and hasattr(cmd_arg, 'startswith'):
# Handle bytes objects that have strip and startswith methods
# Convert to string first for comparison
cmd_str_decoded = cmd_arg.decode('utf-8', errors='replace') if isinstance(cmd_arg, bytes) else cmd_arg
if any(cmd in cmd_str_decoded for cmd in execute_commands):
if cmd_str_decoded.strip().startswith("ffmpeg"):
should_execute = True
# Special handling for ffmpeg WAV conversion command - simulate creating WAV file instead of running actual ffmpeg
if isinstance(cmd_arg, list) and len(cmd_arg) > 3 and cmd_arg[0] == "ffmpeg" and any(".wav" in arg for arg in cmd_arg):
@@ -417,8 +456,7 @@ async def test_full_cli_integration(tmp_path, mocker):
# Mock os.chdir, os.getcwd, os.listdir, os.rename to simulate directory structure
final_track_output_dir = tmp_path / "ABBA - Waterloo" # Predict the output dir path
# Define base_name early so we can use it in the MediaFileUpload mock
artist = "ABBA"
title = "Waterloo"
artist, title = 'ABBA', 'Waterloo'
base_name = f"{artist} - {title}"
# Create a simple mock for MediaFileUpload since we're bypassing the upload method
@@ -436,112 +474,6 @@ async def test_full_cli_integration(tmp_path, mocker):
mock_current_dir_state.return_value = abs_path
# No actual chdir occurs
def listdir_side_effect(path="."):
# Get the *mocked* current directory
current_mocked_dir = mock_current_dir_state()
# Resolve the path relative to the mocked directory
abs_list_path = os.path.abspath(os.path.join(current_mocked_dir, path))
print(f"MOCK os.listdir: Requested list path='{path}', Resolved to abs='{abs_list_path}', Mocked CWD='{current_mocked_dir}'")
if abs_list_path == str(final_track_output_dir):
# Simulate the key file needed by KaraokeFinalise in the main track dir
print(f"MOCK os.listdir: Returning mocked content for {final_track_output_dir}")
# Include other files/dirs created by KaraokePrep phase if needed by later steps
# Create the lyrics directory if it doesn't exist yet
lyrics_dir = os.path.join(str(final_track_output_dir), "lyrics")
os.makedirs(lyrics_dir, exist_ok=True)
# Create a dummy LRC file needed for the test
lrc_file = os.path.join(str(final_track_output_dir), "ABBA - Waterloo (Karaoke).lrc")
if not os.path.exists(lrc_file):
with open(lrc_file, "w") as f:
f.write("[00:00.00]Waterloo - ABBA\n[00:05.00]My my\n[00:10.00]Waterloo")
return [
'ABBA - Waterloo (With Vocals).mkv',
'ABBA - Waterloo (Karaoke).lrc',
'ABBA - Waterloo (Title).mov',
'ABBA - Waterloo (End).mov',
'ABBA - Waterloo (Title).png',
'ABBA - Waterloo (End).png',
'ABBA - Waterloo (Title).jpg',
'ABBA - Waterloo (End).jpg',
'ABBA - Waterloo (Original).wav',
'ABBA - Waterloo (Original).flac', # Copied input
'ABBA - Waterloo (Instrumental model_bs_roformer_ep_317_sdr_12.9755.ckpt).flac',
'ABBA - Waterloo (Instrumental +BV mel_band_roformer_karaoke_aufr33_viperx_sdr_10.1956.ckpt).flac',
'stems', # Stems directory
'lyrics' # Lyrics directory (even though files moved out)
]
elif abs_list_path == str(final_track_output_dir / "lyrics"):
# Simulate contents of lyrics dir *before* files are moved out by KaraokePrep
# KaraokeFinalise doesn't look here, but good practice
print(f"MOCK os.listdir: Returning mocked content for {final_track_output_dir / 'lyrics'}")
# Create the necessary files in the lyrics directory
lyrics_dir = os.path.join(str(final_track_output_dir), "lyrics")
os.makedirs(lyrics_dir, exist_ok=True)
# Create a dummy CDG file
cdg_file = os.path.join(lyrics_dir, "ABBA - Waterloo (Karaoke).cdg")
if not os.path.exists(cdg_file):
with open(cdg_file, "wb") as f:
# Simple CDG header
f.write(b'\x00' * 96) # CDG command
# Create a dummy MP3 file
mp3_file = os.path.join(lyrics_dir, "ABBA - Waterloo (Karaoke).mp3")
if not os.path.exists(mp3_file):
with open(mp3_file, "wb") as f:
# Simple MP3 header
f.write(b'ID3\x03\x00\x00\x00\x00\x00\x00')
# Create a dummy With Vocals MKV file
mkv_file = os.path.join(lyrics_dir, "ABBA - Waterloo (With Vocals).mkv")
if not os.path.exists(mkv_file):
with open(mkv_file, "wb") as f:
# Simple MKV header
f.write(b'\x1A\x45\xDF\xA3')
return [
'ABBA - Waterloo (Karaoke).ass',
'ABBA - Waterloo (Karaoke).cdg',
'ABBA - Waterloo (Karaoke).lrc', # Original location
'ABBA - Waterloo (Karaoke).mp3',
'ABBA - Waterloo (Karaoke).toml',
'ABBA - Waterloo (Karaoke).zip',
'ABBA - Waterloo (Lyrics Corrected).txt',
'ABBA - Waterloo (Lyrics Corrections).json',
'ABBA - Waterloo (Lyrics Genius).txt',
'ABBA - Waterloo (Lyrics Uncorrected).txt',
'ABBA - Waterloo (With Vocals).mkv' # Original location
]
elif abs_list_path == str(final_track_output_dir / "stems"):
# Simulate contents of stems dir
print(f"MOCK os.listdir: Returning mocked content for {final_track_output_dir / 'stems'}")
return [
'ABBA - Waterloo (Audacity).lof',
'ABBA - Waterloo (Backing Vocals mel_band_roformer_karaoke_aufr33_viperx_sdr_10.1956.ckpt).flac',
'ABBA - Waterloo (Bass htdemucs_6s).flac',
'ABBA - Waterloo (Drums htdemucs_6s).flac',
'ABBA - Waterloo (Guitar htdemucs_6s).flac',
'ABBA - Waterloo (Lead Vocals mel_band_roformer_karaoke_aufr33_viperx_sdr_10.1956.ckpt).flac',
'ABBA - Waterloo (Other htdemucs_6s).flac',
'ABBA - Waterloo (Piano htdemucs_6s).flac',
'ABBA - Waterloo (Vocals htdemucs_6s).flac',
'ABBA - Waterloo (Vocals model_bs_roformer_ep_317_sdr_12.9755.ckpt).flac'
]
else:
# For any other path, try calling the original listdir relative to the *actual* CWD
actual_list_path = path if os.path.isabs(path) else os.path.join(original_os_getcwd(), path)
print(f"MOCK os.listdir: Calling original os.listdir for actual path '{actual_list_path}'")
try:
return original_os_listdir(actual_list_path)
except FileNotFoundError:
print(f"MOCK os.listdir: Original call failed (FileNotFound) for {actual_list_path}, returning empty list.")
return [] # Return empty if original fails
def rename_side_effect(src, dst):
# src is likely relative filename, dst is likely absolute path in temp dir
current_mocked_dir = mock_current_dir_state()
@@ -580,7 +512,10 @@ async def test_full_cli_integration(tmp_path, mocker):
mocker.patch('os.chdir', side_effect=chdir_side_effect)
# Patch getcwd to always return the value our mock state holder has
mocker.patch('os.getcwd', new=mock_current_dir_state)
mocker.patch('os.listdir', side_effect=listdir_side_effect)
# Temporarily commenting out the listdir mock to test if real files work
# mocker.patch('os.listdir', side_effect=listdir_side_effect)
# Also mock os.listdir specifically in the finalisation module
# mocker.patch('karaoke_gen.karaoke_finalise.karaoke_finalise.os.listdir', side_effect=listdir_side_effect)
mocker.patch('os.rename', side_effect=rename_side_effect)
# Mock os.path.isfile to use the mocked CWD
@@ -701,41 +636,305 @@ async def test_full_cli_integration(tmp_path, mocker):
return "unexpected_input_response" # Or raise an exception
mocker.patch('builtins.input', side_effect=mock_input_side_effect)
# Mock the transcribe_lyrics method to return consistent results between local and CI
def mock_transcribe_lyrics_side_effect(*args, **kwargs):
print("MOCK transcribe_lyrics: Bypassing real transcription, returning mock results")
# The method expects to return a dict with file paths
# Match the LRC file that the listdir_side_effect creates
track_output_dir = args[3] if len(args) > 3 else kwargs.get('track_output_dir')
artist = args[1] if len(args) > 1 else kwargs.get('artist', 'ABBA')
title = args[2] if len(args) > 2 else kwargs.get('title', 'Waterloo')
expected_lrc_path = os.path.join(track_output_dir, f"{artist} - {title} (Karaoke).lrc")
expected_video_path = os.path.join(track_output_dir, f"{artist} - {title} (With Vocals).mkv")
# Create LRC file with the same content as the listdir mock but ensure it's valid for CDG
with open(expected_lrc_path, "w") as f:
# Use the exact LRC format that the CDG parser expects (no metadata, 3-digit milliseconds)
lrc_content = """[00:01.000]This is a test song
[00:03.000]With some sample lyrics here
[00:07.000]For testing purposes only
[00:09.000]Generic placeholder content
[00:13.000]Test lyrics continue
[00:15.000]End of test content"""
f.write(lrc_content)
# Create a dummy video file to satisfy the expectations
with open(expected_video_path, "w") as f:
f.write("dummy mkv content for testing")
# Create additional files that the finalisation step expects to find
title_mov = os.path.join(track_output_dir, f"{artist} - {title} (Title).mov")
title_jpg = os.path.join(track_output_dir, f"{artist} - {title} (Title).jpg")
end_mov = os.path.join(track_output_dir, f"{artist} - {title} (End).mov")
end_jpg = os.path.join(track_output_dir, f"{artist} - {title} (End).jpg")
original_wav = os.path.join(track_output_dir, f"{artist} - {title} (Original).wav")
instrumental_flac = os.path.join(track_output_dir, f"{artist} - {title} (Instrumental model_bs_roformer_ep_317_sdr_12.9755.ckpt).flac")
# Create these files if they don't exist yet
for video_file in [title_mov, end_mov]:
if not os.path.exists(video_file):
print(f"MOCK transcribe_lyrics: Creating video file: {video_file}")
with open(video_file, "w") as f:
f.write("dummy video content for testing")
for image_file in [title_jpg, end_jpg]:
if not os.path.exists(image_file):
print(f"MOCK transcribe_lyrics: Creating image file: {image_file}")
with open(image_file, "w") as f:
f.write("dummy image content for testing")
if not os.path.exists(original_wav):
print(f"MOCK transcribe_lyrics: Creating WAV file: {original_wav}")
with open(original_wav, "w") as f:
f.write("dummy wav content for testing")
if not os.path.exists(instrumental_flac):
print(f"MOCK transcribe_lyrics: Creating instrumental file: {instrumental_flac}")
with open(instrumental_flac, "w") as f:
f.write("dummy flac content for testing")
print(f"MOCK transcribe_lyrics: Created all required files for finalisation in {track_output_dir}")
return {
"lrc_filepath": expected_lrc_path,
"ass_filepath": None, # Not needed for this test
"corrected_lyrics_text": "Mock corrected lyrics text",
}
mocker.patch('karaoke_gen.lyrics_processor.LyricsProcessor.transcribe_lyrics',
side_effect=mock_transcribe_lyrics_side_effect)
# Mock convert_to_wav to prevent failure on dummy audio files
def mock_convert_to_wav(input_filename, output_filename_no_extension):
"""Mock WAV conversion - just create dummy WAV file"""
output_wav_path = f"{output_filename_no_extension}.wav"
print(f"MOCK convert_to_wav: Creating dummy WAV file at {output_wav_path}")
# Create a dummy WAV file
with open(output_wav_path, "w") as f:
f.write("dummy wav content for testing")
return output_wav_path
mocker.patch('karaoke_gen.file_handler.FileHandler.convert_to_wav',
side_effect=mock_convert_to_wav)
# Mock audio separation to prevent FFmpeg dependency issues
def mock_process_audio_separation(audio_file, artist_title, track_output_dir):
"""Mock audio separation - just create dummy separated files"""
print(f"MOCK process_audio_separation: Creating dummy separated files for {artist_title}")
# Create dummy instrumental files (using a generic model name)
instrumental_file = os.path.join(track_output_dir, f"{artist_title} (Instrumental model_bs_roformer_ep_317_sdr_12.9755.ckpt).flac")
with open(instrumental_file, "w") as f:
f.write("dummy instrumental audio content")
return {
"instrumental_path": instrumental_file,
"vocals_path": None, # Not needed for this test
}
mocker.patch('karaoke_gen.audio_processor.AudioProcessor.process_audio_separation',
side_effect=mock_process_audio_separation)
# Mock CDG generation to prevent FFmpeg/ffprobe dependency issues
def mock_generate_cdg_from_lrc(*args, **kwargs):
"""Mock CDG generation - just create dummy CDG files"""
print("MOCK generate_cdg_from_lrc: Creating dummy CDG files")
# Extract directory from arguments to create files in the right place
# The generate_cdg_from_lrc method typically returns (cdg_file, mp3_file, zip_file)
current_dir = os.getcwd()
cdg_file = os.path.join(current_dir, "ABBA - Waterloo (Karaoke).cdg")
mp3_file = os.path.join(current_dir, "ABBA - Waterloo (Karaoke).mp3")
zip_file = os.path.join(current_dir, "ABBA - Waterloo (Final Karaoke CDG).zip")
# Create dummy files
with open(cdg_file, "w") as f:
f.write("dummy CDG content")
with open(mp3_file, "w") as f:
f.write("dummy MP3 content")
# Create a proper ZIP file containing the dummy files
import zipfile
with zipfile.ZipFile(zip_file, 'w') as zf:
zf.write(cdg_file, os.path.basename(cdg_file))
zf.write(mp3_file, os.path.basename(mp3_file))
return cdg_file, mp3_file, zip_file
mocker.patch('lyrics_transcriber.output.cdg.CDGGenerator.generate_cdg_from_lrc',
side_effect=mock_generate_cdg_from_lrc)
# Mock all FFmpeg command execution in finalisation to prevent system dependencies
execute_command_calls = [] # Track calls for testing
def mock_execute_command(command, description):
"""Mock execute_command to prevent actual FFmpeg execution and create dummy output files"""
print(f"MOCK execute_command: {description}")
print(f"MOCK execute_command: Would run: {command[:100]}...") # Show first 100 chars
# Track this call for testing
execute_command_calls.append((command, description))
# Create dummy output files that the finalisation process expects
if "Creating MP4 version with PCM audio" in description:
output_file = "ABBA - Waterloo (Final Karaoke Lossless 4k).mp4"
with open(output_file, "w") as f:
f.write("dummy lossless mp4 content")
print(f"MOCK execute_command: Created {output_file}")
elif "Creating MP4 version with AAC audio" in description:
output_file = "ABBA - Waterloo (Final Karaoke Lossy 4k).mp4"
with open(output_file, "w") as f:
f.write("dummy lossy mp4 content")
print(f"MOCK execute_command: Created {output_file}")
elif "Creating MKV version with FLAC audio" in description:
output_file = "ABBA - Waterloo (Final Karaoke Lossless 4k).mkv"
with open(output_file, "w") as f:
f.write("dummy mkv content")
print(f"MOCK execute_command: Created {output_file}")
elif "Encoding 720p version" in description:
output_file = "ABBA - Waterloo (Final Karaoke Lossy 720p).mp4"
with open(output_file, "w") as f:
f.write("dummy 720p mp4 content")
print(f"MOCK execute_command: Created {output_file}")
return # Just return without executing
mocker.patch('karaoke_gen.karaoke_finalise.karaoke_finalise.KaraokeFinalise.execute_command',
side_effect=mock_execute_command)
# Mock convert_file for lyrics format conversion
def mock_convert_file(*args, **kwargs):
"""Mock TXT conversion - return simple text content"""
print("MOCK convert_file: Creating dummy TXT conversion")
return "This is a test song\nWith some sample lyrics here\nFor testing purposes only\nGeneric placeholder content\nTest lyrics continue\nEnd of test content"
mocker.patch('lyrics_converter.LyricsConverter.convert_file',
side_effect=mock_convert_file)
# Mock find_with_vocals_file to simply return the With Vocals file we know exists
def mock_find_with_vocals_file(self):
print("MOCK find_with_vocals_file: Returning the known With Vocals file")
current_dir = os.getcwd()
print(f"MOCK find_with_vocals_file: Current working directory: {current_dir}")
# List files for debugging
try:
files_in_dir = os.listdir(".")
print(f"MOCK find_with_vocals_file: Files found by os.listdir('.'): {files_in_dir}")
except Exception as e:
print(f"MOCK find_with_vocals_file: Error calling os.listdir('.'): {e}")
# Return the With Vocals file we know exists
with_vocals_file = "ABBA - Waterloo (With Vocals).mkv"
print(f"MOCK find_with_vocals_file: Returning: {with_vocals_file}")
return with_vocals_file
from karaoke_gen.karaoke_finalise.karaoke_finalise import KaraokeFinalise
mocker.patch.object(KaraokeFinalise, 'find_with_vocals_file', mock_find_with_vocals_file)
# Mock choose_instrumental_audio_file to return the instrumental file we know exists
def mock_choose_instrumental_audio_file(self, base_name):
print("MOCK choose_instrumental_audio_file: Returning the known instrumental file")
instrumental_file = "ABBA - Waterloo (Instrumental model_bs_roformer_ep_317_sdr_12.9755.ckpt).flac"
print(f"MOCK choose_instrumental_audio_file: Returning: {instrumental_file}")
return instrumental_file
mocker.patch.object(KaraokeFinalise, 'choose_instrumental_audio_file', mock_choose_instrumental_audio_file)
# Mock create_cdg_zip_file to create the CDG ZIP and its components
def mock_create_cdg_zip_file(self, input_files, output_files, artist, title):
import zipfile
print("MOCK create_cdg_zip_file: Creating CDG ZIP and component files")
# Create the component files that would be in the ZIP
cdg_file = f"{artist} - {title} (Karaoke).cdg"
mp3_file = f"{artist} - {title} (Karaoke).mp3"
zip_file = f"{artist} - {title} (Final Karaoke CDG).zip"
# Create dummy component files
with open(cdg_file, "w") as f:
f.write("dummy CDG content")
with open(mp3_file, "w") as f:
f.write("dummy MP3 content")
# Create a proper ZIP file containing the dummy files
with zipfile.ZipFile(zip_file, 'w') as zf:
zf.write(cdg_file, os.path.basename(cdg_file))
zf.write(mp3_file, os.path.basename(mp3_file))
# Update output_files dictionary to include the new files
output_files['karaoke_cdg'] = cdg_file
output_files['karaoke_mp3'] = mp3_file
output_files['final_karaoke_cdg_zip'] = zip_file
print(f"MOCK create_cdg_zip_file: Created {zip_file} with components {cdg_file}, {mp3_file}")
mocker.patch.object(KaraokeFinalise, 'create_cdg_zip_file', mock_create_cdg_zip_file)
# Mock create_txt_zip_file to create the TXT ZIP and its components
def mock_create_txt_zip_file(self, input_files, output_files):
import zipfile
print("MOCK create_txt_zip_file: Creating TXT ZIP and component files")
# Extract artist and title from existing files
# We can derive this from the with_vocals_mp4 path if available
base_name = "ABBA - Waterloo" # fallback, could be more dynamic
txt_file = f"{base_name} (Karaoke).txt"
zip_file = f"{base_name} (Final Karaoke TXT).zip"
# Create dummy TXT file
with open(txt_file, "w") as f:
f.write("This is a test song\nWith some sample lyrics here\nFor testing purposes only\nGeneric placeholder content\nTest lyrics continue\nEnd of test content")
# Create a proper ZIP file containing the TXT file
with zipfile.ZipFile(zip_file, 'w') as zf:
zf.write(txt_file, os.path.basename(txt_file))
# Update output_files dictionary to include the new files
output_files['karaoke_txt'] = txt_file
output_files['final_karaoke_txt_zip'] = zip_file
print(f"MOCK create_txt_zip_file: Created {zip_file} with component {txt_file}")
mocker.patch.object(KaraokeFinalise, 'create_txt_zip_file', mock_create_txt_zip_file)
# --- 3. Construct Args and Call async_main ---
# Reusing artist and title variables defined earlier
brand_prefix = "NOMAD"
expected_brand_code = f"{brand_prefix}-0001"
discord_webhook_url = "https://discord.com/api/webhooks/FAKE/URL"
rclone_destination = "googledrive:TestNomadKaraoke"
artist, title = 'ABBA', 'Waterloo'
# Simulate sys.argv (note: first element is script name, irrelevant here)
test_argv = [
"gen_cli.py", # Script name placeholder
"--style_params_json", str(style_params_path),
"--enable_cdg",
"--enable_txt",
"--output_dir", str(tmp_path), # Set output base to tmp_path
"--organised_dir", str(organised_dir),
"--organised_dir_rclone_root", f"andrewdropboxfull:{organised_dir.name}",
"--public_share_dir", str(public_share_dir),
"--brand_prefix", brand_prefix,
"--youtube_client_secrets_file", str(yt_secrets_path),
"--rclone_destination", rclone_destination,
"--youtube_description_file", str(yt_desc_path),
"--discord_webhook_url", discord_webhook_url,
"--email_template_file", str(email_template_path),
"-y", # Non-interactive
str(input_audio),
artist,
title,
# Override sys.argv to simulate CLI invocation with the proper argument format
sys.argv = [
'karaoke-gen', # program name
str(input_audio), # Positional: input media file
artist, # Positional: artist name
title, # Positional: title
'--style_params_json', str(style_params_path), # Named: style params path
'--organised_dir', str(organised_dir), # Named: organised directory
'--organised_dir_rclone_root', 'andrewdropboxfull:organised', # Named: organised directory rclone root
'--public_share_dir', str(public_share_dir), # Named: public share directory
'--rclone_destination', rclone_destination, # Named: rclone destination
'--brand_prefix', expected_brand_code.split('-')[0], # Named: brand prefix (NOMAD)
'--discord_webhook_url', discord_webhook_url, # Named: discord webhook
'--youtube_client_secrets_file', str(yt_secrets_path), # Named: YouTube secrets
'--youtube_description_file', str(yt_desc_path), # Named: YouTube description
'--email_template_file', str(email_template_path), # Named: email template
'--enable_cdg', # Named: enable CDG creation
'--enable_txt', # Named: enable TXT creation
'-y', # Named: auto-confirm (bypass user confirmation)
'--log_level', 'DEBUG' # Named: log level
]
# Patch sys.argv and run the main function
mocker.patch.object(sys, 'argv', test_argv)
print("--- Calling async_main ---")
await async_main() # Call the imported function
print("--- async_main finished ---")
# Now run the actual karaoke generation pipeline
original_argv = sys.argv
try:
# Call the imported function
await async_main()
finally:
sys.argv = original_argv
# --- 4. Assert Local File Outputs ---
final_branded_dir_name = f"{expected_brand_code} - {artist} - {title}"
@@ -783,8 +982,19 @@ async def test_full_cli_integration(tmp_path, mocker):
mock_requests_post.assert_called_once_with(discord_webhook_url, json=mocker.ANY)
assert 'https://www.youtube.com/watch?v=manual_mock_video_id' in mock_requests_post.call_args[1]['json']['content']
# Rclone Sync and Link (using os.system mock)
assert any(f"rclone sync -v \'{str(public_share_dir)}\' \'{rclone_destination}\'" in call_args[0][0] for call_args in mock_os_system.call_args_list), "rclone sync not called"
# Rclone Sync - check if execute_command was called with rclone sync
# The rclone sync is executed through the mocked execute_command method
rclone_sync_called = any(
'rclone sync' in command and str(public_share_dir) in command and rclone_destination in command
for command, description in execute_command_calls
)
if not rclone_sync_called:
print(f"\n--- DEBUG: All execute_command calls ---")
for i, (command, description) in enumerate(execute_command_calls):
print(f"Call {i}: command='{command}' description='{description}'")
assert rclone_sync_called, "rclone sync not called through execute_command"
# Debug all os.system calls
print("\n--- Debug: ALL mock_os_system calls ---")
+6 -6
View File
@@ -3,7 +3,7 @@ import pytest
import tempfile
import logging
from unittest.mock import MagicMock
from karaoke_prep.karaoke_prep import KaraokePrep
from karaoke_gen.karaoke_gen import KaraokePrep
import inspect
@pytest.fixture
@@ -23,19 +23,19 @@ def temp_dir():
yield temp_dir
@pytest.fixture
def basic_karaoke_prep(mock_logger, mock_ffmpeg):
def basic_karaoke_gen(mock_logger, mock_ffmpeg):
"""Return a basic KaraokePrep instance for testing."""
with MagicMock() as mock_os_system:
# Create a KaraokePrep instance with a mock logger
karaoke_prep = KaraokePrep(logger=mock_logger)
karaoke_gen = KaraokePrep(logger=mock_logger)
# Replace the ffmpeg_base_command with a mock
karaoke_prep.ffmpeg_base_command = "mock_ffmpeg"
karaoke_gen.ffmpeg_base_command = "mock_ffmpeg"
# Mock os.system to avoid executing commands
karaoke_prep._os_system = mock_os_system
karaoke_gen._os_system = mock_os_system
yield karaoke_prep
yield karaoke_gen
def pytest_collection_modifyitems(items):
"""Mark async tests with asyncio marker."""
+1 -1
View File
@@ -10,7 +10,7 @@ if __name__ == "__main__":
# Run pytest with coverage
sys.exit(pytest.main([
"--cov=karaoke_prep",
"--cov=karaoke_gen",
"--cov-report=term",
"-v",
os.path.dirname(__file__)
+137 -137
View File
@@ -4,30 +4,30 @@ import asyncio
import signal
import sys
from unittest.mock import MagicMock, patch, AsyncMock, ANY
from karaoke_prep.karaoke_prep import KaraokePrep
from karaoke_gen.karaoke_gen import KaraokePrep
class TestAsync:
@pytest.mark.asyncio
async def test_prep_single_track(self, basic_karaoke_prep, temp_dir):
async def test_prep_single_track(self, basic_karaoke_gen, temp_dir):
"""Test the main prep_single_track workflow."""
# Mock dependencies for file handling
# Patch the handler methods
with patch.object(basic_karaoke_prep.file_handler, 'setup_output_paths', return_value=(temp_dir, "Test Artist - Test Title")) as mock_setup_paths, \
patch.object(basic_karaoke_prep.file_handler, 'copy_input_media', return_value=os.path.join(temp_dir, "copied.mp4")) as mock_copy, \
patch.object(basic_karaoke_prep.file_handler, 'convert_to_wav', return_value=os.path.join(temp_dir, "converted.wav")) as mock_convert, \
patch.object(basic_karaoke_prep.file_handler, '_file_exists', return_value=False) as mock_file_exists, \
patch.object(basic_karaoke_prep.lyrics_processor, 'transcribe_lyrics', AsyncMock(return_value={'lrc_filepath': 'lyrics.lrc'})) as mock_transcribe, \
patch.object(basic_karaoke_prep.audio_processor, 'process_audio_separation', AsyncMock(return_value={'instrumental': 'inst.flac'})) as mock_separate, \
patch.object(basic_karaoke_prep.video_generator, 'create_title_video', MagicMock()) as mock_create_title, \
patch.object(basic_karaoke_prep.video_generator, 'create_end_video', MagicMock()) as mock_create_end:
with patch.object(basic_karaoke_gen.file_handler, 'setup_output_paths', return_value=(temp_dir, "Test Artist - Test Title")) as mock_setup_paths, \
patch.object(basic_karaoke_gen.file_handler, 'copy_input_media', return_value=os.path.join(temp_dir, "copied.mp4")) as mock_copy, \
patch.object(basic_karaoke_gen.file_handler, 'convert_to_wav', return_value=os.path.join(temp_dir, "converted.wav")) as mock_convert, \
patch.object(basic_karaoke_gen.file_handler, '_file_exists', return_value=False) as mock_file_exists, \
patch.object(basic_karaoke_gen.lyrics_processor, 'transcribe_lyrics', AsyncMock(return_value={'lrc_filepath': 'lyrics.lrc'})) as mock_transcribe, \
patch.object(basic_karaoke_gen.audio_processor, 'process_audio_separation', AsyncMock(return_value={'instrumental': 'inst.flac'})) as mock_separate, \
patch.object(basic_karaoke_gen.video_generator, 'create_title_video', MagicMock()) as mock_create_title, \
patch.object(basic_karaoke_gen.video_generator, 'create_end_video', MagicMock()) as mock_create_end:
basic_karaoke_prep.input_media = os.path.join(temp_dir, "input.mp4")
basic_karaoke_prep.artist = "Test Artist"
basic_karaoke_prep.title = "Test Title"
basic_karaoke_prep.output_dir = temp_dir
basic_karaoke_gen.input_media = os.path.join(temp_dir, "input.mp4")
basic_karaoke_gen.artist = "Test Artist"
basic_karaoke_gen.title = "Test Title"
basic_karaoke_gen.output_dir = temp_dir
# Create mock input file
with open(basic_karaoke_prep.input_media, "w") as f:
with open(basic_karaoke_gen.input_media, "w") as f:
f.write("mock video content")
# Configure mock asyncio.gather to return mock results
@@ -63,7 +63,7 @@ class TestAsync:
# No need to mock future.result, the function returns the dict directly
# Call the method
result = await basic_karaoke_prep.prep_single_track()
result = await basic_karaoke_gen.prep_single_track()
# Verify the result structure
assert result is not None
@@ -83,28 +83,28 @@ class TestAsync:
assert mock_separate.call_count >= 1
@pytest.mark.asyncio
async def test_prep_single_track_with_url(self, basic_karaoke_prep):
async def test_prep_single_track_with_url(self, basic_karaoke_gen):
"""Test preparing a single track with a URL."""
# Setup
basic_karaoke_prep.input_media = "https://example.com/video"
basic_karaoke_prep.artist = "Test Artist"
basic_karaoke_prep.title = "Test Title"
basic_karaoke_prep.url = "https://example.com/video" # Explicitly set URL
basic_karaoke_prep.extractor = "youtube" # Explicitly set extractor
basic_karaoke_prep.media_id = "12345" # Explicitly set media_id
basic_karaoke_gen.input_media = "https://example.com/video"
basic_karaoke_gen.artist = "Test Artist"
basic_karaoke_gen.title = "Test Title"
basic_karaoke_gen.url = "https://example.com/video" # Explicitly set URL
basic_karaoke_gen.extractor = "youtube" # Explicitly set extractor
basic_karaoke_gen.media_id = "12345" # Explicitly set media_id
# Mock dependencies
with patch('karaoke_prep.metadata.extract_info_for_online_media') as mock_extract, \
patch('karaoke_prep.metadata.parse_track_metadata') as mock_parse, \
patch.object(basic_karaoke_prep.file_handler, 'setup_output_paths', return_value=("output_dir", "Test Artist - Test Title")) as mock_setup_paths, \
patch.object(basic_karaoke_prep.file_handler, 'download_video', return_value="downloaded_file.mp4") as mock_download, \
patch.object(basic_karaoke_prep.file_handler, 'extract_still_image_from_video', return_value="still_image.png") as mock_extract_image, \
patch.object(basic_karaoke_prep.file_handler, 'convert_to_wav', return_value="output.wav") as mock_convert, \
patch.object(basic_karaoke_prep.file_handler, '_file_exists', return_value=False) as mock_file_exists, \
patch.object(basic_karaoke_prep.lyrics_processor, 'transcribe_lyrics', AsyncMock(return_value={'lrc_filepath': 'lyrics.lrc'})) as mock_transcribe, \
patch.object(basic_karaoke_prep.audio_processor, 'process_audio_separation', AsyncMock(return_value={'instrumental': 'inst.flac'})) as mock_separate, \
patch.object(basic_karaoke_prep.video_generator, 'create_title_video', MagicMock()) as mock_create_title, \
patch.object(basic_karaoke_prep.video_generator, 'create_end_video', MagicMock()) as mock_create_end:
with patch('karaoke_gen.metadata.extract_info_for_online_media') as mock_extract, \
patch('karaoke_gen.metadata.parse_track_metadata') as mock_parse, \
patch.object(basic_karaoke_gen.file_handler, 'setup_output_paths', return_value=("output_dir", "Test Artist - Test Title")) as mock_setup_paths, \
patch.object(basic_karaoke_gen.file_handler, 'download_video', return_value="downloaded_file.mp4") as mock_download, \
patch.object(basic_karaoke_gen.file_handler, 'extract_still_image_from_video', return_value="still_image.png") as mock_extract_image, \
patch.object(basic_karaoke_gen.file_handler, 'convert_to_wav', return_value="output.wav") as mock_convert, \
patch.object(basic_karaoke_gen.file_handler, '_file_exists', return_value=False) as mock_file_exists, \
patch.object(basic_karaoke_gen.lyrics_processor, 'transcribe_lyrics', AsyncMock(return_value={'lrc_filepath': 'lyrics.lrc'})) as mock_transcribe, \
patch.object(basic_karaoke_gen.audio_processor, 'process_audio_separation', AsyncMock(return_value={'instrumental': 'inst.flac'})) as mock_separate, \
patch.object(basic_karaoke_gen.video_generator, 'create_title_video', MagicMock()) as mock_create_title, \
patch.object(basic_karaoke_gen.video_generator, 'create_end_video', MagicMock()) as mock_create_end:
# Configure mock asyncio.gather to return mock results
mock_separate.return_value = {}
@@ -140,7 +140,7 @@ class TestAsync:
# No need to mock future.result, the function returns the dict directly
# Call the method
result = await basic_karaoke_prep.prep_single_track()
result = await basic_karaoke_gen.prep_single_track()
# Verify the result structure
assert result is not None
@@ -156,35 +156,35 @@ class TestAsync:
# assert result["extractor"].lower() == mock_future.return_value["extractor"].lower() # Case-insensitive compare
@pytest.mark.asyncio
async def test_prep_single_track_with_existing_files(self, basic_karaoke_prep, temp_dir):
async def test_prep_single_track_with_existing_files(self, basic_karaoke_gen, temp_dir):
"""Test preparing a single track when files already exist."""
# Setup
basic_karaoke_prep.artist = "Test Artist"
basic_karaoke_prep.title = "Test Title"
basic_karaoke_prep.output_dir = temp_dir
basic_karaoke_prep.extractor = "ExistingExtractor" # Explicitly set extractor for existing files case
basic_karaoke_gen.artist = "Test Artist"
basic_karaoke_gen.title = "Test Title"
basic_karaoke_gen.output_dir = temp_dir
basic_karaoke_gen.extractor = "ExistingExtractor" # Explicitly set extractor for existing files case
# Mock dependencies
# Define side effect for glob.glob
def glob_side_effect(pattern):
artist_title = f"{basic_karaoke_prep.artist} - {basic_karaoke_prep.title}"
expected_base = os.path.join(temp_dir, f"{artist_title} ({basic_karaoke_prep.extractor}*)")
artist_title = f"{basic_karaoke_gen.artist} - {basic_karaoke_gen.title}"
expected_base = os.path.join(temp_dir, f"{artist_title} ({basic_karaoke_gen.extractor}*)")
# Check if the pattern matches the expected base for webm, png, or wav
if pattern == f"{expected_base}.*webm" or pattern == f"{expected_base}.*mp4":
# Return a filename that matches the extractor pattern conceptually
return [os.path.join(temp_dir, f"{artist_title} ({basic_karaoke_prep.extractor} MockID).webm")]
return [os.path.join(temp_dir, f"{artist_title} ({basic_karaoke_gen.extractor} MockID).webm")]
elif pattern == f"{expected_base}.png":
return [os.path.join(temp_dir, f"{artist_title} ({basic_karaoke_prep.extractor} MockID).png")]
return [os.path.join(temp_dir, f"{artist_title} ({basic_karaoke_gen.extractor} MockID).png")]
elif pattern == f"{expected_base}.wav":
return [os.path.join(temp_dir, f"{artist_title} ({basic_karaoke_prep.extractor} MockID).wav")]
return [os.path.join(temp_dir, f"{artist_title} ({basic_karaoke_gen.extractor} MockID).wav")]
return []
with patch.object(basic_karaoke_prep.file_handler, 'setup_output_paths', return_value=(temp_dir, "Test Artist - Test Title")) as mock_setup_paths, \
with patch.object(basic_karaoke_gen.file_handler, 'setup_output_paths', return_value=(temp_dir, "Test Artist - Test Title")) as mock_setup_paths, \
patch('glob.glob', side_effect=glob_side_effect), \
patch.object(basic_karaoke_prep.lyrics_processor, 'transcribe_lyrics', AsyncMock(return_value={'lrc_filepath': 'lyrics.lrc'})) as mock_transcribe, \
patch.object(basic_karaoke_prep.audio_processor, 'process_audio_separation', AsyncMock(return_value={'instrumental': 'inst.flac'})) as mock_separate, \
patch.object(basic_karaoke_prep.video_generator, 'create_title_video', MagicMock()) as mock_create_title, \
patch.object(basic_karaoke_prep.video_generator, 'create_end_video', MagicMock()) as mock_create_end:
patch.object(basic_karaoke_gen.lyrics_processor, 'transcribe_lyrics', AsyncMock(return_value={'lrc_filepath': 'lyrics.lrc'})) as mock_transcribe, \
patch.object(basic_karaoke_gen.audio_processor, 'process_audio_separation', AsyncMock(return_value={'instrumental': 'inst.flac'})) as mock_separate, \
patch.object(basic_karaoke_gen.video_generator, 'create_title_video', MagicMock()) as mock_create_title, \
patch.object(basic_karaoke_gen.video_generator, 'create_end_video', MagicMock()) as mock_create_end:
# Configure mock asyncio.gather to return mock results
mock_separate.return_value = {}
@@ -215,7 +215,7 @@ class TestAsync:
# No need to mock future.result, the function returns the dict directly
# Call the method
result = await basic_karaoke_prep.prep_single_track()
result = await basic_karaoke_gen.prep_single_track()
# Verify the result structure
assert result is not None
@@ -223,41 +223,41 @@ class TestAsync:
assert result["title"] == mock_future.return_value["title"]
# Construct the expected filenames based on the mock logic
artist_title = f"{basic_karaoke_prep.artist} - {basic_karaoke_prep.title}"
expected_media_path = os.path.join(temp_dir, f"{artist_title} ({basic_karaoke_prep.extractor} MockID).webm")
expected_image_path = os.path.join(temp_dir, f"{artist_title} ({basic_karaoke_prep.extractor} MockID).png")
expected_wav_path = os.path.join(temp_dir, f"{artist_title} ({basic_karaoke_prep.extractor} MockID).wav")
artist_title = f"{basic_karaoke_gen.artist} - {basic_karaoke_gen.title}"
expected_media_path = os.path.join(temp_dir, f"{artist_title} ({basic_karaoke_gen.extractor} MockID).webm")
expected_image_path = os.path.join(temp_dir, f"{artist_title} ({basic_karaoke_gen.extractor} MockID).png")
expected_wav_path = os.path.join(temp_dir, f"{artist_title} ({basic_karaoke_gen.extractor} MockID).wav")
assert result["input_media"] == expected_media_path
assert result["input_still_image"] == expected_image_path
assert result["input_audio_wav"] == expected_wav_path
if not isinstance(result["separated_audio"], asyncio.futures.Future) and not asyncio.iscoroutine(result["separated_audio"]):
assert result["separated_audio"] == mock_future.return_value["separated_audio"]
assert result["extractor"] == basic_karaoke_prep.extractor # Should match the one we set
assert result["extractor"] == basic_karaoke_gen.extractor # Should match the one we set
@pytest.mark.asyncio
async def test_prep_single_track_skip_lyrics(self, basic_karaoke_prep, temp_dir):
async def test_prep_single_track_skip_lyrics(self, basic_karaoke_gen, temp_dir):
"""Test preparing a single track with skip_lyrics=True."""
# Setup
basic_karaoke_prep.input_media = os.path.join(temp_dir, "input.mp4")
basic_karaoke_prep.artist = "Test Artist"
basic_karaoke_prep.title = "Test Title"
basic_karaoke_prep.output_dir = temp_dir
basic_karaoke_prep.skip_lyrics = True
basic_karaoke_gen.input_media = os.path.join(temp_dir, "input.mp4")
basic_karaoke_gen.artist = "Test Artist"
basic_karaoke_gen.title = "Test Title"
basic_karaoke_gen.output_dir = temp_dir
basic_karaoke_gen.skip_lyrics = True
# Create mock input file
with open(basic_karaoke_prep.input_media, "w") as f:
with open(basic_karaoke_gen.input_media, "w") as f:
f.write("mock video content")
# Mock dependencies
with patch.object(basic_karaoke_prep.file_handler, 'setup_output_paths', return_value=(temp_dir, "Test Artist - Test Title")) as mock_setup_paths, \
patch.object(basic_karaoke_prep.file_handler, 'copy_input_media', return_value=os.path.join(temp_dir, "copied.mp4")) as mock_copy, \
patch.object(basic_karaoke_prep.file_handler, 'convert_to_wav', return_value=os.path.join(temp_dir, "converted.wav")) as mock_convert, \
patch.object(basic_karaoke_prep.file_handler, '_file_exists', return_value=False) as mock_file_exists, \
patch.object(basic_karaoke_prep.lyrics_processor, 'transcribe_lyrics', AsyncMock(return_value={'lrc_filepath': 'lyrics.lrc'})) as mock_transcribe, \
patch.object(basic_karaoke_prep.audio_processor, 'process_audio_separation', AsyncMock(return_value={'instrumental': 'inst.flac'})) as mock_separate, \
patch.object(basic_karaoke_prep.video_generator, 'create_title_video', MagicMock()) as mock_create_title, \
patch.object(basic_karaoke_prep.video_generator, 'create_end_video', MagicMock()) as mock_create_end:
with patch.object(basic_karaoke_gen.file_handler, 'setup_output_paths', return_value=(temp_dir, "Test Artist - Test Title")) as mock_setup_paths, \
patch.object(basic_karaoke_gen.file_handler, 'copy_input_media', return_value=os.path.join(temp_dir, "copied.mp4")) as mock_copy, \
patch.object(basic_karaoke_gen.file_handler, 'convert_to_wav', return_value=os.path.join(temp_dir, "converted.wav")) as mock_convert, \
patch.object(basic_karaoke_gen.file_handler, '_file_exists', return_value=False) as mock_file_exists, \
patch.object(basic_karaoke_gen.lyrics_processor, 'transcribe_lyrics', AsyncMock(return_value={'lrc_filepath': 'lyrics.lrc'})) as mock_transcribe, \
patch.object(basic_karaoke_gen.audio_processor, 'process_audio_separation', AsyncMock(return_value={'instrumental': 'inst.flac'})) as mock_separate, \
patch.object(basic_karaoke_gen.video_generator, 'create_title_video', MagicMock()) as mock_create_title, \
patch.object(basic_karaoke_gen.video_generator, 'create_end_video', MagicMock()) as mock_create_end:
# Mock the return value of prep_single_track
expected_result = {
@@ -281,7 +281,7 @@ class TestAsync:
}
# Call the method
result = await basic_karaoke_prep.prep_single_track()
result = await basic_karaoke_gen.prep_single_track()
# Verify the result structure
assert result is not None
@@ -296,27 +296,27 @@ class TestAsync:
mock_transcribe.assert_not_called() # Verify lyrics was skipped
@pytest.mark.asyncio
async def test_prep_single_track_skip_separation(self, basic_karaoke_prep, temp_dir):
async def test_prep_single_track_skip_separation(self, basic_karaoke_gen, temp_dir):
"""Test preparing a single track with skip_separation=True."""
# Setup
basic_karaoke_prep.input_media = os.path.join(temp_dir, "input.mp4")
basic_karaoke_prep.artist = "Test Artist"
basic_karaoke_prep.title = "Test Title"
basic_karaoke_prep.output_dir = temp_dir
basic_karaoke_prep.skip_separation = True
basic_karaoke_gen.input_media = os.path.join(temp_dir, "input.mp4")
basic_karaoke_gen.artist = "Test Artist"
basic_karaoke_gen.title = "Test Title"
basic_karaoke_gen.output_dir = temp_dir
basic_karaoke_gen.skip_separation = True
# Create mock input file
with open(basic_karaoke_prep.input_media, "w") as f:
with open(basic_karaoke_gen.input_media, "w") as f:
f.write("mock video content")
# Mock dependencies
with patch.object(basic_karaoke_prep.file_handler, 'setup_output_paths', return_value=(temp_dir, "Test Artist - Test Title")) as mock_setup_paths, \
patch.object(basic_karaoke_prep.file_handler, 'copy_input_media', return_value=os.path.join(temp_dir, "copied.mp4")) as mock_copy, \
patch.object(basic_karaoke_prep.file_handler, 'convert_to_wav', return_value=os.path.join(temp_dir, "converted.wav")) as mock_convert, \
patch.object(basic_karaoke_prep.file_handler, '_file_exists', return_value=False) as mock_file_exists, \
patch.object(basic_karaoke_prep.lyrics_processor, 'transcribe_lyrics', AsyncMock(return_value={'lrc_filepath': 'lyrics.lrc'})) as mock_transcribe, \
patch.object(basic_karaoke_prep.video_generator, 'create_title_video', MagicMock()) as mock_create_title, \
patch.object(basic_karaoke_prep.video_generator, 'create_end_video', MagicMock()) as mock_create_end:
with patch.object(basic_karaoke_gen.file_handler, 'setup_output_paths', return_value=(temp_dir, "Test Artist - Test Title")) as mock_setup_paths, \
patch.object(basic_karaoke_gen.file_handler, 'copy_input_media', return_value=os.path.join(temp_dir, "copied.mp4")) as mock_copy, \
patch.object(basic_karaoke_gen.file_handler, 'convert_to_wav', return_value=os.path.join(temp_dir, "converted.wav")) as mock_convert, \
patch.object(basic_karaoke_gen.file_handler, '_file_exists', return_value=False) as mock_file_exists, \
patch.object(basic_karaoke_gen.lyrics_processor, 'transcribe_lyrics', AsyncMock(return_value={'lrc_filepath': 'lyrics.lrc'})) as mock_transcribe, \
patch.object(basic_karaoke_gen.video_generator, 'create_title_video', MagicMock()) as mock_create_title, \
patch.object(basic_karaoke_gen.video_generator, 'create_end_video', MagicMock()) as mock_create_end:
# Conditionally patch separation only if we expect it to run (it's skipped here)
# We will assert on the actual method instance later
@@ -354,7 +354,7 @@ class TestAsync:
}
# Call the method
result = await basic_karaoke_prep.prep_single_track()
result = await basic_karaoke_gen.prep_single_track()
# Verify the result structure
assert result is not None
@@ -365,7 +365,7 @@ class TestAsync:
assert result["separated_audio"] == expected_result["separated_audio"]
# Assert that the actual separation method was NOT called
# To do this, we need to spy on the actual method without replacing it
with patch.object(basic_karaoke_prep.audio_processor, 'process_audio_separation', wraps=basic_karaoke_prep.audio_processor.process_audio_separation) as spy_separate:
with patch.object(basic_karaoke_gen.audio_processor, 'process_audio_separation', wraps=basic_karaoke_gen.audio_processor.process_audio_separation) as spy_separate:
# Re-run the call within the spy context if necessary, or check previous state
# For simplicity, let's assume the state check is sufficient if the previous run didn't error
spy_separate.assert_not_called()
@@ -374,7 +374,7 @@ class TestAsync:
assert mock_transcribe.call_count > 0
@pytest.mark.asyncio
async def test_shutdown(self, basic_karaoke_prep):
async def test_shutdown(self, basic_karaoke_gen):
"""Test the shutdown signal handler."""
# Mock signal
mock_signal = MagicMock()
@@ -394,36 +394,36 @@ class TestAsync:
patch('sys.exit') as mock_exit:
# Mock the shutdown method to do nothing
with patch.object(basic_karaoke_prep, 'shutdown') as mock_shutdown:
with patch.object(basic_karaoke_gen, 'shutdown') as mock_shutdown:
# Call the method
await basic_karaoke_prep.shutdown(mock_signal)
await basic_karaoke_gen.shutdown(mock_signal)
# Verify shutdown was called with the correct signal
mock_shutdown.assert_called_once_with(mock_signal)
@pytest.mark.asyncio
async def test_process_playlist(self, basic_karaoke_prep):
async def test_process_playlist(self, basic_karaoke_gen):
"""Test processing a playlist."""
# Setup
basic_karaoke_prep.artist = "Test Artist"
basic_karaoke_prep.title = "Test Title"
basic_karaoke_prep.extracted_info = {
basic_karaoke_gen.artist = "Test Artist"
basic_karaoke_gen.title = "Test Title"
basic_karaoke_gen.extracted_info = {
"entries": [
{"title": "Track 1"},
{"title": "Track 2"}
]
}
basic_karaoke_prep.persistent_artist = "Test Artist"
basic_karaoke_gen.persistent_artist = "Test Artist"
# Mock prep_single_track
with patch.object(basic_karaoke_prep, 'prep_single_track', new_callable=AsyncMock) as mock_prep_single_track:
with patch.object(basic_karaoke_gen, 'prep_single_track', new_callable=AsyncMock) as mock_prep_single_track:
mock_prep_single_track.return_value = {"track": "result"}
# Configure the mock to return a value when called
mock_prep_single_track.return_value = {"track": "result"}
# Call the method directly instead of awaiting it
basic_karaoke_prep.extracted_info = {
basic_karaoke_gen.extracted_info = {
"entries": [
{"title": "Track 1"},
{"title": "Track 2"}
@@ -434,7 +434,7 @@ class TestAsync:
expected_result = [{"track": "result1"}, {"track": "result2"}]
# Call the method
result = await basic_karaoke_prep.process_playlist()
result = await basic_karaoke_gen.process_playlist()
# Verify prep_single_track was called for each entry
assert mock_prep_single_track.call_count == 2
@@ -445,24 +445,24 @@ class TestAsync:
assert result[1] == {"track": "result"}
@pytest.mark.asyncio
async def test_process_playlist_error(self, basic_karaoke_prep):
async def test_process_playlist_error(self, basic_karaoke_gen):
"""Test processing a playlist with an error."""
# Setup
basic_karaoke_prep.artist = "Test Artist"
basic_karaoke_prep.title = "Test Title"
basic_karaoke_prep.extracted_info = {} # Missing entries
basic_karaoke_gen.artist = "Test Artist"
basic_karaoke_gen.title = "Test Title"
basic_karaoke_gen.extracted_info = {} # Missing entries
# Test
with pytest.raises(Exception, match="Failed to find 'entries' in playlist, cannot process"):
await basic_karaoke_prep.process_playlist()
await basic_karaoke_gen.process_playlist()
@pytest.mark.asyncio
async def test_process_folder(self, basic_karaoke_prep, temp_dir):
async def test_process_folder(self, basic_karaoke_gen, temp_dir):
"""Test processing a folder."""
# Setup
basic_karaoke_prep.input_media = temp_dir
basic_karaoke_prep.artist = "Test Artist"
basic_karaoke_prep.filename_pattern = r"(?P<index>\d+)_(?P<title>.+)\.mp3"
basic_karaoke_gen.input_media = temp_dir
basic_karaoke_gen.artist = "Test Artist"
basic_karaoke_gen.filename_pattern = r"(?P<index>\d+)_(?P<title>.+)\.mp3"
# Create mock files
os.makedirs(temp_dir, exist_ok=True)
@@ -472,7 +472,7 @@ class TestAsync:
f.write("mock audio content")
# Mock dependencies
with patch.object(basic_karaoke_prep, 'prep_single_track', new_callable=AsyncMock) as mock_prep_single_track, \
with patch.object(basic_karaoke_gen, 'prep_single_track', new_callable=AsyncMock) as mock_prep_single_track, \
patch('os.makedirs'), \
patch('shutil.move'):
@@ -486,7 +486,7 @@ class TestAsync:
]
# Call the method
result = await basic_karaoke_prep.process_folder()
result = await basic_karaoke_gen.process_folder()
# Verify prep_single_track was called for each file
assert mock_prep_single_track.call_count == 2
@@ -495,34 +495,34 @@ class TestAsync:
assert len(result) == 2
@pytest.mark.asyncio
async def test_process_folder_error(self, basic_karaoke_prep):
async def test_process_folder_error(self, basic_karaoke_gen):
"""Test processing a folder with an error."""
# Setup
basic_karaoke_prep.input_media = "folder"
basic_karaoke_prep.artist = None # Missing artist
basic_karaoke_prep.filename_pattern = r"pattern"
basic_karaoke_gen.input_media = "folder"
basic_karaoke_gen.artist = None # Missing artist
basic_karaoke_gen.filename_pattern = r"pattern"
# Test
with pytest.raises(Exception, match="Error: Filename pattern and artist are required for processing a folder"):
await basic_karaoke_prep.process_folder()
await basic_karaoke_gen.process_folder()
@pytest.mark.asyncio
async def test_process_local_file(self, basic_karaoke_prep, temp_dir):
async def test_process_local_file(self, basic_karaoke_gen, temp_dir):
"""Test processing a local file."""
# Setup
input_file = os.path.join(temp_dir, "input.mp3")
with open(input_file, "w") as f:
f.write("mock audio content")
basic_karaoke_prep.input_media = input_file
basic_karaoke_prep.artist = "Test Artist"
basic_karaoke_prep.title = "Test Title"
basic_karaoke_gen.input_media = input_file
basic_karaoke_gen.artist = "Test Artist"
basic_karaoke_gen.title = "Test Title"
# Mock dependencies
with patch.object(basic_karaoke_prep, 'prep_single_track', new_callable=AsyncMock) as mock_prep_single_track:
with patch.object(basic_karaoke_gen, 'prep_single_track', new_callable=AsyncMock) as mock_prep_single_track:
mock_prep_single_track.return_value = {"track": "result"}
result = await basic_karaoke_prep.process()
result = await basic_karaoke_gen.process()
# Verify prep_single_track was called
mock_prep_single_track.assert_called_once()
@@ -532,16 +532,16 @@ class TestAsync:
assert result[0] == {"track": "result"}
@pytest.mark.asyncio
async def test_process_online_media(self, basic_karaoke_prep):
async def test_process_online_media(self, basic_karaoke_gen):
"""Test processing online media."""
# Setup
basic_karaoke_prep.input_media = "https://example.com/video"
basic_karaoke_prep.artist = "Test Artist"
basic_karaoke_prep.title = "Test Title"
basic_karaoke_gen.input_media = "https://example.com/video"
basic_karaoke_gen.artist = "Test Artist"
basic_karaoke_gen.title = "Test Title"
# Mock dependencies
with patch('karaoke_prep.metadata.ydl') as mock_ydl, \
patch.object(basic_karaoke_prep, 'prep_single_track', new_callable=AsyncMock) as mock_prep_single_track:
with patch('karaoke_gen.metadata.ydl') as mock_ydl, \
patch.object(basic_karaoke_gen, 'prep_single_track', new_callable=AsyncMock) as mock_prep_single_track:
# Configure the mock ydl context manager
mock_ydl_instance = MagicMock()
@@ -553,10 +553,10 @@ class TestAsync:
}
mock_ydl.return_value.__enter__.return_value = mock_ydl_instance
basic_karaoke_prep.extracted_info = {} # Not a playlist
basic_karaoke_gen.extracted_info = {} # Not a playlist
mock_prep_single_track.return_value = {"track": "result"}
result = await basic_karaoke_prep.process()
result = await basic_karaoke_gen.process()
# Verify prep_single_track was called
mock_prep_single_track.assert_called_once()
@@ -566,26 +566,26 @@ class TestAsync:
assert result[0] == {"track": "result"}
@pytest.mark.asyncio
async def test_process_online_playlist(self, basic_karaoke_prep):
async def test_process_online_playlist(self, basic_karaoke_gen):
"""Test processing an online playlist."""
# Setup
basic_karaoke_prep.input_media = "https://example.com/playlist"
basic_karaoke_prep.artist = "Test Artist"
basic_karaoke_prep.title = "Test Title"
basic_karaoke_gen.input_media = "https://example.com/playlist"
basic_karaoke_gen.artist = "Test Artist"
basic_karaoke_gen.title = "Test Title"
# Mock dependencies
with patch('karaoke_prep.metadata.ydl') as mock_ydl, \
patch.object(basic_karaoke_prep, 'process_playlist', new_callable=AsyncMock) as mock_process_playlist:
with patch('karaoke_gen.metadata.ydl') as mock_ydl, \
patch.object(basic_karaoke_gen, 'process_playlist', new_callable=AsyncMock) as mock_process_playlist:
# Configure the mock ydl context manager
mock_ydl_instance = MagicMock()
mock_ydl_instance.extract_info.return_value = {"playlist_count": 2}
mock_ydl.return_value.__enter__.return_value = mock_ydl_instance
basic_karaoke_prep.extracted_info = {"playlist_count": 2} # Is a playlist
basic_karaoke_gen.extracted_info = {"playlist_count": 2} # Is a playlist
mock_process_playlist.return_value = [{"track": "result1"}, {"track": "result2"}]
result = await basic_karaoke_prep.process()
result = await basic_karaoke_gen.process()
# Verify process_playlist was called
mock_process_playlist.assert_called_once()
+29 -27
View File
@@ -7,11 +7,11 @@ from unittest.mock import MagicMock, patch, call, mock_open
import datetime as dt # Use alias to avoid conflict
import fcntl
from pydub import AudioSegment
from karaoke_prep.karaoke_prep import KaraokePrep
from karaoke_gen.karaoke_gen import KaraokePrep
from audio_separator.separator import Separator # Keep for patching target
class TestAudio:
def test_separate_audio(self, basic_karaoke_prep, temp_dir):
def test_separate_audio(self, basic_karaoke_gen, temp_dir):
"""Test separating audio into instrumental and vocals."""
# Setup
audio_file = os.path.join(temp_dir, "input.wav")
@@ -38,7 +38,7 @@ class TestAudio:
patch('os.rename') as mock_rename:
# Call the method
basic_karaoke_prep.audio_processor.separate_audio(
basic_karaoke_gen.audio_processor.separate_audio(
audio_file=audio_file,
model_name=model_name,
artist_title=artist_title,
@@ -64,10 +64,10 @@ class TestAudio:
instrumental_path
)
def test_separate_audio_invalid_audio_file(self, basic_karaoke_prep):
def test_separate_audio_invalid_audio_file(self, basic_karaoke_gen):
"""Test separating audio with an invalid audio file."""
with pytest.raises(Exception, match="Error: Invalid audio source provided."):
basic_karaoke_prep.audio_processor.separate_audio(
basic_karaoke_gen.audio_processor.separate_audio(
audio_file=None,
model_name="test_model.ckpt",
artist_title="Test Artist - Test Title",
@@ -76,7 +76,7 @@ class TestAudio:
vocals_path="vocals.flac"
)
def test_process_audio_separation(self, basic_karaoke_prep, temp_dir):
def test_process_audio_separation(self, basic_karaoke_gen, temp_dir):
"""Test the process_audio_separation method."""
# Setup
audio_file = os.path.join(temp_dir, "input.wav")
@@ -103,23 +103,23 @@ class TestAudio:
# The input path for backing vocal separation is the output vocals from the clean separation
clean_vocals_output_path = os.path.join(stems_dir, f"{artist_title} (Vocals {clean_model}).flac")
# audio-separator appends _(Vocals) or _(Instrumental) to the *input* filename stem (without extension), relative to the input file's directory
clean_vocals_input_stem = clean_vocals_output_path[:-len(basic_karaoke_prep.lossless_output_format)-1] # Remove .flac
intermediate_bv_vocals = f"{clean_vocals_input_stem}_(Vocals).{basic_karaoke_prep.lossless_output_format}"
intermediate_bv_instrumental = f"{clean_vocals_input_stem}_(Instrumental).{basic_karaoke_prep.lossless_output_format}"
clean_vocals_input_stem = clean_vocals_output_path[:-len(basic_karaoke_gen.lossless_output_format)-1] # Remove .flac
intermediate_bv_vocals = f"{clean_vocals_input_stem}_(Vocals).{basic_karaoke_gen.lossless_output_format}"
intermediate_bv_instrumental = f"{clean_vocals_input_stem}_(Instrumental).{basic_karaoke_gen.lossless_output_format}"
mock_separator.separate.side_effect = [
# 1. Clean instrumental model outputs (called by _separate_clean_instrumental)
# These are output relative to the *input* audio file's directory (temp_dir)
[
# These names need the model name appended by the separator convention
os.path.join(temp_dir, f"{artist_title}_(Vocals)_{clean_model}.{basic_karaoke_prep.lossless_output_format}"),
os.path.join(temp_dir, f"{artist_title}_(Instrumental)_{clean_model}.{basic_karaoke_prep.lossless_output_format}")
os.path.join(temp_dir, f"{artist_title}_(Vocals)_{clean_model}.{basic_karaoke_gen.lossless_output_format}"),
os.path.join(temp_dir, f"{artist_title}_(Instrumental)_{clean_model}.{basic_karaoke_gen.lossless_output_format}")
],
# 2. Other stems model outputs (called by _separate_other_stems)
# These are also output relative to the *input* audio file's directory (temp_dir)
[
os.path.join(temp_dir, f"{artist_title}_(Piano)_{other_model}.{basic_karaoke_prep.lossless_output_format}"),
os.path.join(temp_dir, f"{artist_title}_(Guitar)_{other_model}.{basic_karaoke_prep.lossless_output_format}")
os.path.join(temp_dir, f"{artist_title}_(Piano)_{other_model}.{basic_karaoke_gen.lossless_output_format}"),
os.path.join(temp_dir, f"{artist_title}_(Guitar)_{other_model}.{basic_karaoke_gen.lossless_output_format}")
],
# 3. Backing vocals model outputs (called by _separate_backing_vocals)
# These are output relative to the *vocals input* file's directory (stems_dir)
@@ -134,14 +134,15 @@ class TestAudio:
patch('os.rename') as mock_rename, \
patch('os.path.exists', return_value=True), \
patch('os.getpid', return_value=12345), \
patch('psutil.pid_exists', return_value=False), \
patch('datetime.datetime') as mock_datetime, \
patch('json.dump'), \
patch('fcntl.flock'), \
patch('os.remove'), \
patch('os.system'), \
patch('builtins.open', mock_open(read_data='{"pid": 123, "start_time": "2023-01-01T11:00:00", "track": "Old Track"}')) as mock_file_open, \
patch.object(basic_karaoke_prep.audio_processor, '_normalize_audio_files') as mock_normalize_files, \
patch.object(basic_karaoke_prep.file_handler, '_file_exists') as mock_file_exists:
patch.object(basic_karaoke_gen.audio_processor, '_normalize_audio_files') as mock_normalize_files, \
patch.object(basic_karaoke_gen.file_handler, '_file_exists') as mock_file_exists:
# Configure _file_exists side effect: False initially, then True for normalization checks
# Needs to return False for:
@@ -166,7 +167,7 @@ class TestAudio:
mock_datetime.fromisoformat.side_effect = lambda *args, **kwargs: dt.datetime.fromisoformat(*args, **kwargs)
# Call the method
result = basic_karaoke_prep.audio_processor.process_audio_separation(
result = basic_karaoke_gen.audio_processor.process_audio_separation(
audio_file=audio_file,
artist_title=artist_title,
track_output_dir=track_output_dir
@@ -187,8 +188,8 @@ class TestAudio:
# Verify _normalize_audio_files was called once
assert mock_normalize_files.call_count == 1
def test_process_audio_separation_with_skip_env_var(self, basic_karaoke_prep, temp_dir):
"""Test process_audio_separation with KARAOKE_PREP_SKIP_AUDIO_SEPARATION environment variable."""
def test_process_audio_separation_with_skip_env_var(self, basic_karaoke_gen, temp_dir):
"""Test process_audio_separation with KARAOKE_GEN_SKIP_AUDIO_SEPARATION environment variable."""
# Setup
audio_file = os.path.join(temp_dir, "input.wav")
with open(audio_file, "w") as f:
@@ -198,12 +199,13 @@ class TestAudio:
track_output_dir = temp_dir
# Mock environment variable
with patch.dict('os.environ', {'KARAOKE_PREP_SKIP_AUDIO_SEPARATION': '1'}), \
with patch.dict('os.environ', {'KARAOKE_GEN_SKIP_AUDIO_SEPARATION': '1'}), \
patch('fcntl.flock'), \
patch('psutil.pid_exists', return_value=False), \
patch('builtins.open', mock_open()) as mock_file_open:
# Call the method
result = basic_karaoke_prep.audio_processor.process_audio_separation(
result = basic_karaoke_gen.audio_processor.process_audio_separation(
audio_file=audio_file,
artist_title=artist_title,
track_output_dir=track_output_dir
@@ -221,7 +223,7 @@ class TestAudio:
assert result["backing_vocals"] == {}
assert result["combined_instrumentals"] == {}
def test_normalize_audio(self, basic_karaoke_prep, temp_dir):
def test_normalize_audio(self, basic_karaoke_gen, temp_dir):
"""Test normalizing audio."""
# Setup
input_path = os.path.join(temp_dir, "input.flac")
@@ -236,7 +238,7 @@ class TestAudio:
# Mock dependencies
with patch('pydub.AudioSegment.from_file', return_value=mock_audio):
# Call the method
basic_karaoke_prep.audio_processor._normalize_audio(input_path, output_path)
basic_karaoke_gen.audio_processor._normalize_audio(input_path, output_path)
# Verify AudioSegment.from_file was called with correct arguments
AudioSegment.from_file.assert_called_once_with(input_path, format="flac")
@@ -247,7 +249,7 @@ class TestAudio:
# Verify export was called with correct arguments
mock_audio.export.assert_called_once_with(output_path, format="flac")
def test_normalize_audio_silent_result(self, basic_karaoke_prep, temp_dir):
def test_normalize_audio_silent_result(self, basic_karaoke_gen, temp_dir):
"""Test normalizing audio when the result would be silent."""
# Setup
input_path = os.path.join(temp_dir, "input.flac")
@@ -266,7 +268,7 @@ class TestAudio:
# Mock dependencies
with patch('pydub.AudioSegment.from_file', return_value=mock_audio):
# Call the method
basic_karaoke_prep.audio_processor._normalize_audio(input_path, output_path)
basic_karaoke_gen.audio_processor._normalize_audio(input_path, output_path)
# Verify AudioSegment.from_file was called with correct arguments
AudioSegment.from_file.assert_called_once_with(input_path, format="flac")
@@ -277,12 +279,12 @@ class TestAudio:
# Verify export was called with the original audio (not the silent one)
mock_audio.export.assert_called_once_with(output_path, format="flac")
def test_file_exists(self, basic_karaoke_prep):
def test_file_exists(self, basic_karaoke_gen):
"""Test the _file_exists helper method."""
# Test with existing file
with patch('os.path.isfile', return_value=True):
assert basic_karaoke_prep.file_handler._file_exists("existing_file.txt") is True
assert basic_karaoke_gen.file_handler._file_exists("existing_file.txt") is True
# Test with non-existing file
with patch('os.path.isfile', return_value=False):
assert basic_karaoke_prep.file_handler._file_exists("non_existing_file.txt") is False
assert basic_karaoke_gen.file_handler._file_exists("non_existing_file.txt") is False
+70 -70
View File
@@ -8,28 +8,28 @@ import json
from unittest.mock import patch, MagicMock, AsyncMock, mock_open, call
# Import the module/functions to test
from karaoke_prep.utils import bulk_cli
from karaoke_gen.utils import bulk_cli
# Define module paths to mock consistently across tests
mock_module_paths = {
"KaraokePrep": "karaoke_prep.utils.bulk_cli.KaraokePrep",
"KaraokeFinalise": "karaoke_prep.utils.bulk_cli.KaraokeFinalise",
"os_path_isfile": "karaoke_prep.utils.bulk_cli.os.path.isfile",
"os_path_exists": "karaoke_prep.utils.bulk_cli.os.path.exists",
"os_chdir": "karaoke_prep.utils.bulk_cli.os.chdir",
"os_getcwd": "karaoke_prep.utils.bulk_cli.os.getcwd",
"KaraokePrep": "karaoke_gen.utils.bulk_cli.KaraokePrep",
"KaraokeFinalise": "karaoke_gen.utils.bulk_cli.KaraokeFinalise",
"os_path_isfile": "karaoke_gen.utils.bulk_cli.os.path.isfile",
"os_path_exists": "karaoke_gen.utils.bulk_cli.os.path.exists",
"os_chdir": "karaoke_gen.utils.bulk_cli.os.chdir",
"os_getcwd": "karaoke_gen.utils.bulk_cli.os.getcwd",
"open_func": "builtins.open",
"csv_DictReader": "karaoke_prep.utils.bulk_cli.csv.DictReader",
"csv_DictWriter": "karaoke_prep.utils.bulk_cli.csv.DictWriter",
"update_csv_status": "karaoke_prep.utils.bulk_cli.update_csv_status",
"ArgumentParser": "karaoke_prep.utils.bulk_cli.argparse.ArgumentParser",
"os_path_abspath": "karaoke_prep.utils.bulk_cli.os.path.abspath",
"sys_exit": "karaoke_prep.utils.bulk_cli.sys.exit",
"asyncio_run": "karaoke_prep.utils.bulk_cli.asyncio.run",
"logger": "karaoke_prep.utils.bulk_cli.logger",
"getattr_func": "karaoke_prep.utils.bulk_cli.getattr",
"StreamHandler": "karaoke_prep.utils.bulk_cli.logging.StreamHandler",
"Formatter": "karaoke_prep.utils.bulk_cli.logging.Formatter"
"csv_DictReader": "karaoke_gen.utils.bulk_cli.csv.DictReader",
"csv_DictWriter": "karaoke_gen.utils.bulk_cli.csv.DictWriter",
"update_csv_status": "karaoke_gen.utils.bulk_cli.update_csv_status",
"ArgumentParser": "karaoke_gen.utils.bulk_cli.argparse.ArgumentParser",
"os_path_abspath": "karaoke_gen.utils.bulk_cli.os.path.abspath",
"sys_exit": "karaoke_gen.utils.bulk_cli.sys.exit",
"asyncio_run": "karaoke_gen.utils.bulk_cli.asyncio.run",
"logger": "karaoke_gen.utils.bulk_cli.logger",
"getattr_func": "karaoke_gen.utils.bulk_cli.getattr",
"StreamHandler": "karaoke_gen.utils.bulk_cli.logging.StreamHandler",
"Formatter": "karaoke_gen.utils.bulk_cli.logging.Formatter"
}
# Instead of the global pytestmark, we'll explicitly mark async tests where needed
@@ -85,11 +85,11 @@ def mock_log_formatter():
return MagicMock(spec=logging.Formatter)
# Add mocks for the new helper functions and process_csv_rows
@patch("karaoke_prep.utils.bulk_cli.process_csv_rows", new_callable=AsyncMock)
@patch("karaoke_prep.utils.bulk_cli._read_csv_file")
@patch("karaoke_prep.utils.bulk_cli._parse_and_validate_args")
@patch("karaoke_prep.utils.bulk_cli.setup_logging") # Mock logging setup as well
@patch("karaoke_prep.utils.bulk_cli.logger") # Mock the module-level logger directly
@patch("karaoke_gen.utils.bulk_cli.process_csv_rows", new_callable=AsyncMock)
@patch("karaoke_gen.utils.bulk_cli._read_csv_file")
@patch("karaoke_gen.utils.bulk_cli._parse_and_validate_args")
@patch("karaoke_gen.utils.bulk_cli.setup_logging") # Mock logging setup as well
@patch("karaoke_gen.utils.bulk_cli.logger") # Mock the module-level logger directly
@pytest.mark.asyncio # Explicitly mark as async test
async def test_async_main_flow(
mock_bulk_cli_logger, mock_setup_logging, mock_parse_args, mock_read_csv, mock_process_rows, # Added mock_bulk_cli_logger back
@@ -144,9 +144,9 @@ async def test_async_main_flow(
assert result == {"summary": "results"}
@patch("karaoke_prep.utils.bulk_cli.KaraokePrep")
@patch("karaoke_prep.utils.bulk_cli.os.chdir")
@patch("karaoke_prep.utils.bulk_cli.os.getcwd", return_value="/fake/original/dir")
@patch("karaoke_gen.utils.bulk_cli.KaraokePrep")
@patch("karaoke_gen.utils.bulk_cli.os.chdir")
@patch("karaoke_gen.utils.bulk_cli.os.getcwd", return_value="/fake/original/dir")
@pytest.mark.asyncio # Explicitly mark as async test
async def test_process_track_prep_success(mock_getcwd, mock_chdir, mock_kprep, mock_args, mock_logger, mock_log_formatter):
"""Test process_track_prep successfully calls KaraokePrep."""
@@ -174,9 +174,9 @@ async def test_process_track_prep_success(mock_getcwd, mock_chdir, mock_kprep, m
mock_chdir.assert_called_once_with("/fake/original/dir") # Changed back at the end
@patch("karaoke_prep.utils.bulk_cli.KaraokePrep")
@patch("karaoke_prep.utils.bulk_cli.os.chdir")
@patch("karaoke_prep.utils.bulk_cli.os.getcwd", return_value="/fake/original/dir")
@patch("karaoke_gen.utils.bulk_cli.KaraokePrep")
@patch("karaoke_gen.utils.bulk_cli.os.chdir")
@patch("karaoke_gen.utils.bulk_cli.os.getcwd", return_value="/fake/original/dir")
@pytest.mark.asyncio # Explicitly mark as async test
async def test_process_track_prep_failure(mock_getcwd, mock_chdir, mock_kprep, mock_args, mock_logger, mock_log_formatter):
"""Test process_track_prep handles exceptions from KaraokePrep."""
@@ -192,11 +192,11 @@ async def test_process_track_prep_failure(mock_getcwd, mock_chdir, mock_kprep, m
mock_chdir.assert_called_once_with("/fake/original/dir") # Should still change back
@patch("karaoke_prep.utils.bulk_cli.KaraokePrep")
@patch("karaoke_prep.utils.bulk_cli.KaraokeFinalise")
@patch("karaoke_prep.utils.bulk_cli.os.path.exists", return_value=True) # Assume track dir exists
@patch("karaoke_prep.utils.bulk_cli.os.chdir")
@patch("karaoke_prep.utils.bulk_cli.os.getcwd", return_value="/fake/original/dir")
@patch("karaoke_gen.utils.bulk_cli.KaraokePrep")
@patch("karaoke_gen.utils.bulk_cli.KaraokeFinalise")
@patch("karaoke_gen.utils.bulk_cli.os.path.exists", return_value=True) # Assume track dir exists
@patch("karaoke_gen.utils.bulk_cli.os.chdir")
@patch("karaoke_gen.utils.bulk_cli.os.getcwd", return_value="/fake/original/dir")
@patch("builtins.open", new_callable=mock_open, read_data=SAMPLE_STYLE_JSON) # For reading style JSON if CDG enabled
@pytest.mark.asyncio # Explicitly mark as async test
async def test_process_track_render_success(
@@ -253,11 +253,11 @@ async def test_process_track_render_success(
mock_chdir.assert_called_with("/fake/original/dir")
@patch("karaoke_prep.utils.bulk_cli.KaraokePrep")
@patch("karaoke_prep.utils.bulk_cli.KaraokeFinalise")
@patch("karaoke_prep.utils.bulk_cli.os.path.exists", return_value=True)
@patch("karaoke_prep.utils.bulk_cli.os.chdir")
@patch("karaoke_prep.utils.bulk_cli.os.getcwd", return_value="/fake/original/dir")
@patch("karaoke_gen.utils.bulk_cli.KaraokePrep")
@patch("karaoke_gen.utils.bulk_cli.KaraokeFinalise")
@patch("karaoke_gen.utils.bulk_cli.os.path.exists", return_value=True)
@patch("karaoke_gen.utils.bulk_cli.os.chdir")
@patch("karaoke_gen.utils.bulk_cli.os.getcwd", return_value="/fake/original/dir")
@patch("builtins.open", new_callable=mock_open, read_data=SAMPLE_STYLE_JSON)
@pytest.mark.asyncio # Explicitly mark as async test
async def test_process_track_render_finalise_failure(
@@ -438,11 +438,11 @@ def test_parse_and_validate_args_csv_not_found(mock_logger, mock_run, mock_isfil
mock_isfile.assert_called_once_with("/abs/nonexistent.csv")
@patch("karaoke_prep.utils.bulk_cli.KaraokePrep")
@patch("karaoke_prep.utils.bulk_cli.KaraokeFinalise")
@patch("karaoke_prep.utils.bulk_cli.os.path.exists", return_value=True) # Track dir exists
@patch("karaoke_prep.utils.bulk_cli.os.chdir")
@patch("karaoke_prep.utils.bulk_cli.os.getcwd", return_value="/fake/original/dir")
@patch("karaoke_gen.utils.bulk_cli.KaraokePrep")
@patch("karaoke_gen.utils.bulk_cli.KaraokeFinalise")
@patch("karaoke_gen.utils.bulk_cli.os.path.exists", return_value=True) # Track dir exists
@patch("karaoke_gen.utils.bulk_cli.os.chdir")
@patch("karaoke_gen.utils.bulk_cli.os.getcwd", return_value="/fake/original/dir")
@patch("builtins.open", side_effect=FileNotFoundError("Styles not found")) # Simulate style file not found
@pytest.mark.asyncio # Explicitly mark as async test
async def test_process_track_render_style_json_not_found_cdg(
@@ -466,11 +466,11 @@ async def test_process_track_render_style_json_not_found_cdg(
mock_kfinalise.assert_not_called()
@patch("karaoke_prep.utils.bulk_cli.KaraokePrep")
@patch("karaoke_prep.utils.bulk_cli.KaraokeFinalise")
@patch("karaoke_prep.utils.bulk_cli.os.path.exists", return_value=True) # Track dir exists
@patch("karaoke_prep.utils.bulk_cli.os.chdir")
@patch("karaoke_prep.utils.bulk_cli.os.getcwd", return_value="/fake/original/dir")
@patch("karaoke_gen.utils.bulk_cli.KaraokePrep")
@patch("karaoke_gen.utils.bulk_cli.KaraokeFinalise")
@patch("karaoke_gen.utils.bulk_cli.os.path.exists", return_value=True) # Track dir exists
@patch("karaoke_gen.utils.bulk_cli.os.chdir")
@patch("karaoke_gen.utils.bulk_cli.os.getcwd", return_value="/fake/original/dir")
@patch("builtins.open", new_callable=mock_open, read_data="invalid json") # Simulate invalid JSON
@pytest.mark.asyncio # Explicitly mark as async test
async def test_process_track_render_style_json_invalid_cdg(
@@ -494,11 +494,11 @@ async def test_process_track_render_style_json_invalid_cdg(
mock_kfinalise.assert_not_called()
@patch("karaoke_prep.utils.bulk_cli.KaraokePrep")
@patch("karaoke_prep.utils.bulk_cli.KaraokeFinalise")
@patch("karaoke_prep.utils.bulk_cli.os.path.exists", return_value=False) # Simulate track dir NOT found
@patch("karaoke_prep.utils.bulk_cli.os.chdir")
@patch("karaoke_prep.utils.bulk_cli.os.getcwd", return_value="/fake/original/dir")
@patch("karaoke_gen.utils.bulk_cli.KaraokePrep")
@patch("karaoke_gen.utils.bulk_cli.KaraokeFinalise")
@patch("karaoke_gen.utils.bulk_cli.os.path.exists", return_value=False) # Simulate track dir NOT found
@patch("karaoke_gen.utils.bulk_cli.os.chdir")
@patch("karaoke_gen.utils.bulk_cli.os.getcwd", return_value="/fake/original/dir")
@pytest.mark.asyncio # Explicitly mark as async test
async def test_process_track_render_track_dir_not_found(
mock_getcwd, mock_chdir, mock_exists, mock_kfinalise, mock_kprep,
@@ -527,11 +527,11 @@ async def test_process_track_render_track_dir_not_found(
# Add mocks for the new helper functions and process_csv_rows
@patch("karaoke_prep.utils.bulk_cli.process_csv_rows", new_callable=AsyncMock)
@patch("karaoke_prep.utils.bulk_cli._read_csv_file")
@patch("karaoke_prep.utils.bulk_cli._parse_and_validate_args")
@patch("karaoke_prep.utils.bulk_cli.setup_logging") # Mock logging setup
@patch("karaoke_prep.utils.bulk_cli.logger") # Mock the module-level logger directly
@patch("karaoke_gen.utils.bulk_cli.process_csv_rows", new_callable=AsyncMock)
@patch("karaoke_gen.utils.bulk_cli._read_csv_file")
@patch("karaoke_gen.utils.bulk_cli._parse_and_validate_args")
@patch("karaoke_gen.utils.bulk_cli.setup_logging") # Mock logging setup
@patch("karaoke_gen.utils.bulk_cli.logger") # Mock the module-level logger directly
@pytest.mark.asyncio # Explicitly mark as async test
async def test_async_main_dry_run(
mock_bulk_cli_logger, mock_setup_logging, mock_parse_args, mock_read_csv, mock_process_rows, # Added mock_bulk_cli_logger back
@@ -597,11 +597,11 @@ async def test_async_main_dry_run(
# This test focuses on async_main passing the flag correctly.
@patch("karaoke_prep.utils.bulk_cli.KaraokePrep")
@patch("karaoke_prep.utils.bulk_cli.KaraokeFinalise")
@patch("karaoke_prep.utils.bulk_cli.os.path.exists", return_value=True) # Assume track dir exists
@patch("karaoke_prep.utils.bulk_cli.os.chdir")
@patch("karaoke_prep.utils.bulk_cli.os.getcwd", return_value="/fake/original/dir")
@patch("karaoke_gen.utils.bulk_cli.KaraokePrep")
@patch("karaoke_gen.utils.bulk_cli.KaraokeFinalise")
@patch("karaoke_gen.utils.bulk_cli.os.path.exists", return_value=True) # Assume track dir exists
@patch("karaoke_gen.utils.bulk_cli.os.chdir")
@patch("karaoke_gen.utils.bulk_cli.os.getcwd", return_value="/fake/original/dir")
@patch("builtins.open", new_callable=mock_open, read_data=SAMPLE_STYLE_JSON) # For reading style JSON
@pytest.mark.asyncio # Explicitly mark as async test
async def test_process_track_render_cdg_enabled(
@@ -674,9 +674,9 @@ def test_setup_logging(mock_logger, mock_formatter, mock_handler):
@pytest.mark.asyncio
@patch("karaoke_prep.utils.bulk_cli.update_csv_status")
@patch("karaoke_prep.utils.bulk_cli.process_track_render", new_callable=AsyncMock)
@patch("karaoke_prep.utils.bulk_cli.process_track_prep", new_callable=AsyncMock)
@patch("karaoke_gen.utils.bulk_cli.update_csv_status")
@patch("karaoke_gen.utils.bulk_cli.process_track_render", new_callable=AsyncMock)
@patch("karaoke_gen.utils.bulk_cli.process_track_prep", new_callable=AsyncMock)
@pytest.mark.asyncio # Explicitly mark as async test
async def test_process_csv_rows(mock_process_prep, mock_process_render, mock_update_csv, mock_args, mock_logger, mock_log_formatter):
"""Test the process_csv_rows function processes CSV rows correctly."""
@@ -724,9 +724,9 @@ async def test_process_csv_rows(mock_process_prep, mock_process_render, mock_upd
@pytest.mark.asyncio
@patch("karaoke_prep.utils.bulk_cli.update_csv_status")
@patch("karaoke_prep.utils.bulk_cli.process_track_render", new_callable=AsyncMock)
@patch("karaoke_prep.utils.bulk_cli.process_track_prep", new_callable=AsyncMock)
@patch("karaoke_gen.utils.bulk_cli.update_csv_status")
@patch("karaoke_gen.utils.bulk_cli.process_track_render", new_callable=AsyncMock)
@patch("karaoke_gen.utils.bulk_cli.process_track_prep", new_callable=AsyncMock)
@pytest.mark.asyncio # Explicitly mark as async test
async def test_process_csv_rows_dry_run(mock_process_prep, mock_process_render, mock_update_csv, mock_args, mock_logger, mock_log_formatter):
"""Test the process_csv_rows function in dry run mode."""
+34 -34
View File
@@ -3,12 +3,12 @@ import pytest
import glob
import shutil
from unittest.mock import MagicMock, patch, mock_open, call, DEFAULT
from karaoke_prep.karaoke_prep import KaraokePrep
from karaoke_gen.karaoke_gen import KaraokePrep
import yt_dlp # Keep import for patching target
from karaoke_prep.utils import sanitize_filename # Import utility
from karaoke_gen.utils import sanitize_filename # Import utility
class TestFileOperations:
def test_copy_input_media(self, basic_karaoke_prep, temp_dir):
def test_copy_input_media(self, basic_karaoke_gen, temp_dir):
"""Test copying input media to a new location."""
# Setup
source_file = os.path.join(temp_dir, "source.mp4")
@@ -19,7 +19,7 @@ class TestFileOperations:
# Test with mocked shutil.copy2
with patch('shutil.copy2') as mock_copy:
result = basic_karaoke_prep.file_handler.copy_input_media(source_file, output_filename)
result = basic_karaoke_gen.file_handler.copy_input_media(source_file, output_filename)
# Verify the correct file path was returned
assert result == output_filename + ".mp4"
@@ -27,7 +27,7 @@ class TestFileOperations:
# Verify shutil.copy2 was called with correct arguments
mock_copy.assert_called_once_with(source_file, output_filename + ".mp4")
def test_copy_input_media_same_file(self, basic_karaoke_prep, temp_dir):
def test_copy_input_media_same_file(self, basic_karaoke_gen, temp_dir):
"""Test copying input media when source and destination are the same."""
# Setup
file_path = os.path.join(temp_dir, "file.mp4")
@@ -36,12 +36,12 @@ class TestFileOperations:
# Test with mocked os.path.abspath to simulate same file
with patch('os.path.abspath', side_effect=lambda x: x):
result = basic_karaoke_prep.file_handler.copy_input_media(file_path, file_path[:-4])
result = basic_karaoke_gen.file_handler.copy_input_media(file_path, file_path[:-4])
# Verify the correct file path was returned
assert result == file_path
def test_download_video(self, basic_karaoke_prep, temp_dir):
def test_download_video(self, basic_karaoke_gen, temp_dir):
"""Test downloading a video from a URL."""
url = "https://example.com/video"
output_filename = os.path.join(temp_dir, "output")
@@ -58,7 +58,7 @@ class TestFileOperations:
mock_glob_result = [downloaded_file]
# Patch the 'ydl' class used in file_handler.py and glob.glob
with patch('karaoke_prep.file_handler.ydl') as mock_ydl_context, \
with patch('karaoke_gen.file_handler.ydl') as mock_ydl_context, \
patch('glob.glob', return_value=mock_glob_result):
# Configure the context manager to return our mock instance
@@ -70,7 +70,7 @@ class TestFileOperations:
f.write("test video content")
# Call the method
result = basic_karaoke_prep.file_handler.download_video(url, output_filename)
result = basic_karaoke_gen.file_handler.download_video(url, output_filename)
# Verify the correct file path was returned
assert result == downloaded_file
@@ -90,7 +90,7 @@ class TestFileOperations:
# Verify glob was called
glob.glob.assert_called_once_with(f"{output_filename}.*")
def test_download_video_no_files_found(self, basic_karaoke_prep):
def test_download_video_no_files_found(self, basic_karaoke_gen):
"""Test downloading a video when no files are found after download."""
url = "https://example.com/video"
output_filename = "output"
@@ -103,14 +103,14 @@ class TestFileOperations:
mock_ydl_instance.download = MagicMock(return_value=None)
# Mock glob.glob to return empty list (no files found)
with patch('karaoke_prep.file_handler.ydl') as mock_ydl_context, \
with patch('karaoke_gen.file_handler.ydl') as mock_ydl_context, \
patch('glob.glob', return_value=[]):
# Configure the context manager to return our mock instance
mock_ydl_context.return_value.__enter__.return_value = mock_ydl_instance
# Call the method
result = basic_karaoke_prep.file_handler.download_video(url, output_filename)
result = basic_karaoke_gen.file_handler.download_video(url, output_filename)
# Verify None was returned
assert result is None
@@ -124,23 +124,23 @@ class TestFileOperations:
# Verify glob was called
glob.glob.assert_called_once_with(f"{output_filename}.*")
def test_extract_still_image_from_video(self, basic_karaoke_prep):
def test_extract_still_image_from_video(self, basic_karaoke_gen):
"""Test extracting a still image from a video."""
input_filename = "input.mp4"
output_filename = "output"
# Patch os.system directly within this test
with patch('os.system') as mock_os_system:
result = basic_karaoke_prep.file_handler.extract_still_image_from_video(input_filename, output_filename)
result = basic_karaoke_gen.file_handler.extract_still_image_from_video(input_filename, output_filename)
# Verify the correct file path was returned
assert result == output_filename + ".png"
# Verify os.system was called with correct arguments
expected_command = f'{basic_karaoke_prep.file_handler.ffmpeg_base_command} -i "{input_filename}" -ss 00:00:30 -vframes 1 "{output_filename}.png"'
expected_command = f'{basic_karaoke_gen.file_handler.ffmpeg_base_command} -i "{input_filename}" -ss 00:00:30 -vframes 1 "{output_filename}.png"'
mock_os_system.assert_called_once_with(expected_command)
def test_convert_to_wav_success(self, basic_karaoke_prep, temp_dir):
def test_convert_to_wav_success(self, basic_karaoke_gen, temp_dir):
"""Test converting input audio to WAV format successfully."""
# Create a test input file
input_filename = os.path.join(temp_dir, "input.mp3")
@@ -159,7 +159,7 @@ class TestFileOperations:
# Patch os.system directly
with patch('os.system') as mock_os_system:
result = basic_karaoke_prep.file_handler.convert_to_wav(input_filename, output_filename)
result = basic_karaoke_gen.file_handler.convert_to_wav(input_filename, output_filename)
# Verify the correct file path was returned
assert result == output_filename + ".wav"
@@ -167,7 +167,7 @@ class TestFileOperations:
# Verify os.system was called
mock_os_system.assert_called_once()
def test_convert_to_wav_file_not_found(self, basic_karaoke_prep):
def test_convert_to_wav_file_not_found(self, basic_karaoke_gen):
"""Test converting input audio when the file is not found."""
input_filename = "nonexistent.mp3"
output_filename = "output"
@@ -175,9 +175,9 @@ class TestFileOperations:
# Mock os.path.isfile to return False
with patch('os.path.isfile', return_value=False):
with pytest.raises(Exception, match=f"Input audio file not found: {input_filename}"):
basic_karaoke_prep.file_handler.convert_to_wav(input_filename, output_filename)
basic_karaoke_gen.file_handler.convert_to_wav(input_filename, output_filename)
def test_convert_to_wav_empty_file(self, basic_karaoke_prep):
def test_convert_to_wav_empty_file(self, basic_karaoke_gen):
"""Test converting input audio when the file is empty."""
input_filename = "empty.mp3"
output_filename = "output"
@@ -186,9 +186,9 @@ class TestFileOperations:
with patch('os.path.isfile', return_value=True), \
patch('os.path.getsize', return_value=0):
with pytest.raises(Exception, match=f"Input audio file is empty: {input_filename}"):
basic_karaoke_prep.file_handler.convert_to_wav(input_filename, output_filename)
basic_karaoke_gen.file_handler.convert_to_wav(input_filename, output_filename)
def test_convert_to_wav_no_audio_stream(self, basic_karaoke_prep):
def test_convert_to_wav_no_audio_stream(self, basic_karaoke_gen):
"""Test converting input audio when no audio stream is found."""
input_filename = "no_audio.mp4"
output_filename = "output"
@@ -202,9 +202,9 @@ class TestFileOperations:
mock_popen.return_value.read.return_value = "codec_type=video"
with pytest.raises(Exception, match=f"No valid audio stream found in file: {input_filename}"):
basic_karaoke_prep.file_handler.convert_to_wav(input_filename, output_filename)
basic_karaoke_gen.file_handler.convert_to_wav(input_filename, output_filename)
def test_sanitize_filename(self, basic_karaoke_prep):
def test_sanitize_filename(self, basic_karaoke_gen):
"""Test sanitizing filenames."""
# Test with various problematic characters
assert sanitize_filename('file/with\\chars:*?"<>|') == 'file_with_chars_'
@@ -215,34 +215,34 @@ class TestFileOperations:
assert sanitize_filename("valid_filename_123") == "valid_filename_123"
assert sanitize_filename("file_with__multiple___underscores") == "file_with_multiple_underscores"
def test_setup_output_paths(self, basic_karaoke_prep, temp_dir):
def test_setup_output_paths(self, basic_karaoke_gen, temp_dir):
"""Test setting up output paths."""
# Test with both artist and title
with patch('os.makedirs') as mock_makedirs:
basic_karaoke_prep.file_handler.output_dir = temp_dir
track_output_dir, artist_title = basic_karaoke_prep.file_handler.setup_output_paths(temp_dir, "Test Artist", "Test Title")
basic_karaoke_gen.file_handler.output_dir = temp_dir
track_output_dir, artist_title = basic_karaoke_gen.file_handler.setup_output_paths(temp_dir, "Test Artist", "Test Title")
assert artist_title == "Test Artist - Test Title"
assert track_output_dir == temp_dir
# Test with create_track_subfolders=True
basic_karaoke_prep.file_handler.create_track_subfolders = True
track_output_dir, artist_title = basic_karaoke_prep.file_handler.setup_output_paths(temp_dir, "Test Artist", "Test Title")
basic_karaoke_gen.file_handler.create_track_subfolders = True
track_output_dir, artist_title = basic_karaoke_gen.file_handler.setup_output_paths(temp_dir, "Test Artist", "Test Title")
expected_dir = os.path.join(temp_dir, "Test Artist - Test Title")
assert track_output_dir == expected_dir
mock_makedirs.assert_called_with(expected_dir)
def test_setup_output_paths_title_only(self, basic_karaoke_prep, temp_dir):
def test_setup_output_paths_title_only(self, basic_karaoke_gen, temp_dir):
"""Test setting up output paths with only title."""
with patch('os.makedirs'):
basic_karaoke_prep.file_handler.output_dir = temp_dir
track_output_dir, artist_title = basic_karaoke_prep.file_handler.setup_output_paths(temp_dir, None, "Test Title")
basic_karaoke_gen.file_handler.output_dir = temp_dir
track_output_dir, artist_title = basic_karaoke_gen.file_handler.setup_output_paths(temp_dir, None, "Test Title")
assert artist_title == "Test Title"
assert track_output_dir == temp_dir
def test_setup_output_paths_no_inputs(self, basic_karaoke_prep):
def test_setup_output_paths_no_inputs(self, basic_karaoke_gen):
"""Test setting up output paths with no inputs."""
with pytest.raises(ValueError, match="Error: At least title or artist must be provided"):
basic_karaoke_prep.file_handler.setup_output_paths(basic_karaoke_prep.output_dir, None, None)
basic_karaoke_gen.file_handler.setup_output_paths(basic_karaoke_gen.output_dir, None, None)
+99 -99
View File
@@ -7,7 +7,7 @@ import sys
from unittest.mock import patch, MagicMock, AsyncMock, mock_open, call
# Import the module/functions to test
from karaoke_prep.utils import gen_cli
from karaoke_gen.utils import gen_cli
# Mark all tests in this module as asyncio
pytestmark = pytest.mark.asyncio
@@ -112,20 +112,20 @@ def mock_logger():
@pytest.fixture(autouse=True)
def mock_pyperclip():
"""Automatically mock pyperclip."""
with patch("karaoke_prep.utils.gen_cli.pyperclip", MagicMock()) as mock_clip:
with patch("karaoke_gen.utils.gen_cli.pyperclip", MagicMock()) as mock_clip:
yield mock_clip
@pytest.fixture(autouse=True)
def mock_sleep():
"""Automatically mock time.sleep."""
with patch("karaoke_prep.utils.gen_cli.time.sleep", MagicMock()) as mock_sl:
with patch("karaoke_gen.utils.gen_cli.time.sleep", MagicMock()) as mock_sl:
yield mock_sl
# --- Test Argument Parsing Logic ---
@patch("karaoke_prep.utils.gen_cli.is_url", return_value=True)
@patch("karaoke_prep.utils.gen_cli.is_file", return_value=False)
@patch("karaoke_prep.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
@patch("karaoke_gen.utils.gen_cli.is_url", return_value=True)
@patch("karaoke_gen.utils.gen_cli.is_file", return_value=False)
@patch("karaoke_gen.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
async def test_arg_parsing_url_only(mock_kprep_class, mock_isfile, mock_isurl, mock_base_args, mock_logger, caplog):
"""Test URL-only argument parsing."""
mock_base_args.args = ["https://example.com/song.mp3"]
@@ -133,7 +133,7 @@ async def test_arg_parsing_url_only(mock_kprep_class, mock_isfile, mock_isurl, m
mock_kprep_class.return_value = mock_kprep_instance
mock_kprep_instance.process = AsyncMock(return_value=[MOCK_PREP_TRACK])
with patch("karaoke_prep.utils.gen_cli.argparse.ArgumentParser") as mock_parser:
with patch("karaoke_gen.utils.gen_cli.argparse.ArgumentParser") as mock_parser:
mock_parser.return_value.parse_args.return_value = mock_base_args
await gen_cli.async_main()
@@ -144,9 +144,9 @@ async def test_arg_parsing_url_only(mock_kprep_class, mock_isfile, mock_isurl, m
# Verify warning in log
assert "Input media provided without Artist and Title" in caplog.text
@patch("karaoke_prep.utils.gen_cli.is_url", return_value=True)
@patch("karaoke_prep.utils.gen_cli.is_file", return_value=False)
@patch("karaoke_prep.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
@patch("karaoke_gen.utils.gen_cli.is_url", return_value=True)
@patch("karaoke_gen.utils.gen_cli.is_file", return_value=False)
@patch("karaoke_gen.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
async def test_arg_parsing_url_artist_title(mock_kprep_class, mock_isfile, mock_isurl, mock_base_args, mock_logger):
"""Test parsing: URL, Artist, Title."""
mock_base_args.args = ["http://example.com/video.mp4", "URL Artist", "URL Title"]
@@ -154,7 +154,7 @@ async def test_arg_parsing_url_artist_title(mock_kprep_class, mock_isfile, mock_
mock_kprep_class.return_value = mock_kprep_instance
mock_kprep_instance.process = AsyncMock(return_value=[MOCK_PREP_TRACK])
with patch("karaoke_prep.utils.gen_cli.argparse.ArgumentParser") as mock_parser:
with patch("karaoke_gen.utils.gen_cli.argparse.ArgumentParser") as mock_parser:
mock_parser.return_value.parse_args.return_value = mock_base_args
await gen_cli.async_main()
@@ -165,9 +165,9 @@ async def test_arg_parsing_url_artist_title(mock_kprep_class, mock_isfile, mock_
mock_kprep_instance.process.assert_awaited_once()
assert call_kwargs["title"] == "URL Title"
@patch("karaoke_prep.utils.gen_cli.is_url", return_value=False)
@patch("karaoke_prep.utils.gen_cli.is_file", return_value=True)
@patch("karaoke_prep.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
@patch("karaoke_gen.utils.gen_cli.is_url", return_value=False)
@patch("karaoke_gen.utils.gen_cli.is_file", return_value=True)
@patch("karaoke_gen.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
async def test_arg_parsing_file_artist_title(mock_kprep_class, mock_isfile, mock_isurl, mock_base_args, mock_logger):
"""Test parsing: Local File, Artist, Title."""
mock_base_args.args = ["/path/to/song.mp3", "File Artist", "File Title"]
@@ -175,7 +175,7 @@ async def test_arg_parsing_file_artist_title(mock_kprep_class, mock_isfile, mock
mock_kprep_class.return_value = mock_kprep_instance
mock_kprep_instance.process = AsyncMock(return_value=[MOCK_PREP_TRACK])
with patch("karaoke_prep.utils.gen_cli.argparse.ArgumentParser") as mock_parser:
with patch("karaoke_gen.utils.gen_cli.argparse.ArgumentParser") as mock_parser:
mock_parser.return_value.parse_args.return_value = mock_base_args
await gen_cli.async_main()
@@ -186,10 +186,10 @@ async def test_arg_parsing_file_artist_title(mock_kprep_class, mock_isfile, mock
mock_kprep_instance.process.assert_awaited_once()
assert call_kwargs["title"] == "File Title"
@patch("karaoke_prep.utils.gen_cli.is_url", return_value=False)
@patch("karaoke_prep.utils.gen_cli.is_file", return_value=False)
@patch("karaoke_prep.utils.gen_cli.os.path.isdir", return_value=False)
@patch("karaoke_prep.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
@patch("karaoke_gen.utils.gen_cli.is_url", return_value=False)
@patch("karaoke_gen.utils.gen_cli.is_file", return_value=False)
@patch("karaoke_gen.utils.gen_cli.os.path.isdir", return_value=False)
@patch("karaoke_gen.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
async def test_arg_parsing_artist_title_only(mock_kprep_class, mock_isdir, mock_isfile, mock_isurl, mock_base_args, mock_logger, caplog):
"""Test Artist and Title only argument parsing."""
mock_base_args.args = ["Test Artist", "Test Title"]
@@ -197,7 +197,7 @@ async def test_arg_parsing_artist_title_only(mock_kprep_class, mock_isdir, mock_
mock_kprep_class.return_value = mock_kprep_instance
mock_kprep_instance.process = AsyncMock(return_value=[MOCK_PREP_TRACK])
with patch("karaoke_prep.utils.gen_cli.argparse.ArgumentParser") as mock_parser:
with patch("karaoke_gen.utils.gen_cli.argparse.ArgumentParser") as mock_parser:
mock_parser.return_value.parse_args.return_value = mock_base_args
await gen_cli.async_main()
@@ -210,10 +210,10 @@ async def test_arg_parsing_artist_title_only(mock_kprep_class, mock_isdir, mock_
# Verify warning about YouTube search is shown
assert "No input media provided, the top YouTube search result for" in caplog.text
@patch("karaoke_prep.utils.gen_cli.is_url", return_value=False)
@patch("karaoke_prep.utils.gen_cli.is_file", return_value=False)
@patch("karaoke_prep.utils.gen_cli.os.path.isdir", return_value=True)
@patch("karaoke_prep.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
@patch("karaoke_gen.utils.gen_cli.is_url", return_value=False)
@patch("karaoke_gen.utils.gen_cli.is_file", return_value=False)
@patch("karaoke_gen.utils.gen_cli.os.path.isdir", return_value=True)
@patch("karaoke_gen.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
async def test_arg_parsing_folder_artist_pattern(mock_kprep_class, mock_isdir, mock_isfile, mock_isurl, mock_base_args, mock_logger):
"""Test parsing: Folder, Artist, Pattern."""
mock_base_args.args = ["/path/to/folder", "Folder Artist"]
@@ -222,7 +222,7 @@ async def test_arg_parsing_folder_artist_pattern(mock_kprep_class, mock_isdir, m
mock_kprep_class.return_value = mock_kprep_instance
mock_kprep_instance.process = AsyncMock(return_value=[MOCK_PREP_TRACK])
with patch("karaoke_prep.utils.gen_cli.argparse.ArgumentParser") as mock_parser:
with patch("karaoke_gen.utils.gen_cli.argparse.ArgumentParser") as mock_parser:
mock_parser.return_value.parse_args.return_value = mock_base_args
await gen_cli.async_main()
@@ -233,16 +233,16 @@ async def test_arg_parsing_folder_artist_pattern(mock_kprep_class, mock_isdir, m
mock_kprep_instance.process.assert_awaited_once()
assert call_kwargs["filename_pattern"] == r"(?P<index>\d+) - (?P<title>.+)\.mp3"
@patch("karaoke_prep.utils.gen_cli.is_url", return_value=False)
@patch("karaoke_prep.utils.gen_cli.is_file", return_value=False)
@patch("karaoke_prep.utils.gen_cli.os.path.isdir", return_value=True)
@patch("karaoke_prep.utils.gen_cli.sys.exit")
@patch("karaoke_gen.utils.gen_cli.is_url", return_value=False)
@patch("karaoke_gen.utils.gen_cli.is_file", return_value=False)
@patch("karaoke_gen.utils.gen_cli.os.path.isdir", return_value=True)
@patch("karaoke_gen.utils.gen_cli.sys.exit")
async def test_arg_parsing_folder_missing_pattern(mock_exit, mock_isdir, mock_isfile, mock_isurl, mock_base_args, mock_logger):
"""Test parsing exits if folder provided without filename_pattern."""
mock_base_args.args = ["/path/to/folder", "Folder Artist"]
mock_base_args.filename_pattern = None # Missing pattern
with patch("karaoke_prep.utils.gen_cli.argparse.ArgumentParser") as mock_parser, \
patch("karaoke_prep.utils.gen_cli.logging.getLogger", return_value=mock_logger):
with patch("karaoke_gen.utils.gen_cli.argparse.ArgumentParser") as mock_parser, \
patch("karaoke_gen.utils.gen_cli.logging.getLogger", return_value=mock_logger):
mock_parser.return_value.parse_args.return_value = mock_base_args
await gen_cli.async_main()
@@ -252,8 +252,8 @@ async def test_arg_parsing_folder_missing_pattern(mock_exit, mock_isdir, mock_is
# --- Test Workflow Modes ---
@patch("karaoke_prep.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
@patch("karaoke_prep.utils.gen_cli.KaraokeFinalise") # Should not be called
@patch("karaoke_gen.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
@patch("karaoke_gen.utils.gen_cli.KaraokeFinalise") # Should not be called
async def test_workflow_prep_only(mock_kfinalise, mock_kprep_class, mock_base_args, mock_logger):
"""Test --prep-only workflow."""
mock_base_args.args = ["Artist", "Title"]
@@ -262,8 +262,8 @@ async def test_workflow_prep_only(mock_kfinalise, mock_kprep_class, mock_base_ar
mock_kprep_class.return_value = mock_kprep_instance
mock_kprep_instance.process = AsyncMock(return_value=[MOCK_PREP_TRACK]) # Simulate prep output
with patch("karaoke_prep.utils.gen_cli.argparse.ArgumentParser") as mock_parser, \
patch("karaoke_prep.utils.gen_cli.logging.getLogger", return_value=mock_logger):
with patch("karaoke_gen.utils.gen_cli.argparse.ArgumentParser") as mock_parser, \
patch("karaoke_gen.utils.gen_cli.logging.getLogger", return_value=mock_logger):
mock_parser.return_value.parse_args.return_value = mock_base_args
await gen_cli.async_main()
@@ -274,8 +274,8 @@ async def test_workflow_prep_only(mock_kfinalise, mock_kprep_class, mock_base_ar
assert mock_logger.info.called
@patch("karaoke_prep.utils.gen_cli.KaraokePrep") # Should not be called
@patch("karaoke_prep.utils.gen_cli.KaraokeFinalise")
@patch("karaoke_gen.utils.gen_cli.KaraokePrep") # Should not be called
@patch("karaoke_gen.utils.gen_cli.KaraokeFinalise")
@patch("builtins.open", new_callable=mock_open) # Mock open for style JSON if CDG enabled
async def test_workflow_finalise_only(mock_open, mock_kfinalise, mock_kprep, mock_base_args, mock_logger):
"""Test --finalise-only workflow."""
@@ -283,8 +283,8 @@ async def test_workflow_finalise_only(mock_open, mock_kfinalise, mock_kprep, moc
mock_kfinalise_instance = mock_kfinalise.return_value
mock_kfinalise_instance.process = MagicMock(return_value=MOCK_FINAL_TRACK)
with patch("karaoke_prep.utils.gen_cli.argparse.ArgumentParser") as mock_parser, \
patch("karaoke_prep.utils.gen_cli.logging.getLogger", return_value=mock_logger):
with patch("karaoke_gen.utils.gen_cli.argparse.ArgumentParser") as mock_parser, \
patch("karaoke_gen.utils.gen_cli.logging.getLogger", return_value=mock_logger):
mock_parser.return_value.parse_args.return_value = mock_base_args
await gen_cli.async_main()
@@ -295,10 +295,10 @@ async def test_workflow_finalise_only(mock_open, mock_kfinalise, mock_kprep, moc
assert mock_logger.info.called
@patch("karaoke_prep.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
@patch("karaoke_prep.utils.gen_cli.KaraokeFinalise")
@patch("karaoke_prep.utils.gen_cli.os.path.basename", return_value="Edit Artist - Edit Title")
@patch("karaoke_prep.utils.gen_cli.os.getcwd", return_value="/fake/path/Edit Artist - Edit Title")
@patch("karaoke_gen.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
@patch("karaoke_gen.utils.gen_cli.KaraokeFinalise")
@patch("karaoke_gen.utils.gen_cli.os.path.basename", return_value="Edit Artist - Edit Title")
@patch("karaoke_gen.utils.gen_cli.os.getcwd", return_value="/fake/path/Edit Artist - Edit Title")
@patch("builtins.open", new_callable=mock_open) # Mock open for style JSON if CDG enabled
async def test_workflow_edit_lyrics(mock_open, mock_getcwd, mock_basename, mock_kfinalise, mock_kprep_class, mock_base_args, mock_logger):
"""Test --edit-lyrics workflow."""
@@ -317,7 +317,7 @@ async def test_workflow_edit_lyrics(mock_open, mock_getcwd, mock_basename, mock_
mock_kfinalise_instance = mock_kfinalise.return_value
mock_kfinalise_instance.process = MagicMock(return_value=MOCK_FINAL_TRACK)
with patch("karaoke_prep.utils.gen_cli.argparse.ArgumentParser") as mock_parser:
with patch("karaoke_gen.utils.gen_cli.argparse.ArgumentParser") as mock_parser:
mock_parser.return_value.parse_args.return_value = mock_base_args
await gen_cli.async_main()
@@ -345,15 +345,15 @@ async def test_workflow_edit_lyrics(mock_open, mock_getcwd, mock_basename, mock_
mock_kfinalise_instance.process.assert_called_once_with(replace_existing=True) # Should replace
@patch("karaoke_prep.utils.gen_cli.KaraokeFinalise")
@patch("karaoke_gen.utils.gen_cli.KaraokeFinalise")
async def test_workflow_test_email_template(mock_kfinalise, mock_base_args, mock_logger):
"""Test --test_email_template workflow."""
mock_base_args.test_email_template = True
mock_base_args.email_template_file = "template.txt"
mock_kfinalise_instance = mock_kfinalise.return_value
with patch("karaoke_prep.utils.gen_cli.argparse.ArgumentParser") as mock_parser, \
patch("karaoke_prep.utils.gen_cli.logging.getLogger", return_value=mock_logger):
with patch("karaoke_gen.utils.gen_cli.argparse.ArgumentParser") as mock_parser, \
patch("karaoke_gen.utils.gen_cli.logging.getLogger", return_value=mock_logger):
mock_parser.return_value.parse_args.return_value = mock_base_args
await gen_cli.async_main()
@@ -364,8 +364,8 @@ async def test_workflow_test_email_template(mock_kfinalise, mock_base_args, mock
assert mock_logger.info.called
@patch("karaoke_prep.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
@patch("karaoke_prep.utils.gen_cli.KaraokeFinalise")
@patch("karaoke_gen.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
@patch("karaoke_gen.utils.gen_cli.KaraokeFinalise")
async def test_workflow_lyrics_only(mock_kfinalise, mock_kprep_class, mock_base_args, mock_logger):
"""Test --lyrics-only workflow sets environment variables and skips."""
mock_base_args.args = ["Artist", "Title"]
@@ -376,13 +376,13 @@ async def test_workflow_lyrics_only(mock_kfinalise, mock_kprep_class, mock_base_
mock_kfinalise_instance = mock_kfinalise.return_value
mock_kfinalise_instance.process = MagicMock(return_value=MOCK_FINAL_TRACK)
with patch("karaoke_prep.utils.gen_cli.argparse.ArgumentParser") as mock_parser, \
patch("karaoke_prep.utils.gen_cli.logging.getLogger", return_value=mock_logger), \
patch.dict("karaoke_prep.utils.gen_cli.os.environ", {}, clear=True), \
patch("karaoke_prep.utils.gen_cli.os.environ.get") as mock_environ_get:
with patch("karaoke_gen.utils.gen_cli.argparse.ArgumentParser") as mock_parser, \
patch("karaoke_gen.utils.gen_cli.logging.getLogger", return_value=mock_logger), \
patch.dict("karaoke_gen.utils.gen_cli.os.environ", {}, clear=True), \
patch("karaoke_gen.utils.gen_cli.os.environ.get") as mock_environ_get:
mock_parser.return_value.parse_args.return_value = mock_base_args
# Set up the mock to return "1" for our environment variables
mock_environ_get.side_effect = lambda key, default=None: "1" if key in ["KARAOKE_PREP_SKIP_AUDIO_SEPARATION", "KARAOKE_PREP_SKIP_TITLE_END_SCREENS"] else default
mock_environ_get.side_effect = lambda key, default=None: "1" if key in ["KARAOKE_GEN_SKIP_AUDIO_SEPARATION", "KARAOKE_GEN_SKIP_TITLE_END_SCREENS"] else default
await gen_cli.async_main()
# Since we can't reliably test the os.environ, check that skip_separation was set
@@ -395,11 +395,11 @@ async def test_workflow_lyrics_only(mock_kfinalise, mock_kprep_class, mock_base_
# --- Test Finalise CDG Style Loading ---
@patch("karaoke_prep.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
@patch("karaoke_prep.utils.gen_cli.KaraokeFinalise")
@patch("karaoke_gen.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
@patch("karaoke_gen.utils.gen_cli.KaraokeFinalise")
@patch("builtins.open", new_callable=mock_open, read_data=SAMPLE_STYLE_JSON)
@patch("karaoke_prep.utils.gen_cli.os.chdir") # Mock chdir
@patch("karaoke_prep.utils.gen_cli.os.path.exists", return_value=True) # Assume track dir exists
@patch("karaoke_gen.utils.gen_cli.os.chdir") # Mock chdir
@patch("karaoke_gen.utils.gen_cli.os.path.exists", return_value=True) # Assume track dir exists
async def test_finalise_cdg_style_loading(mock_exists, mock_chdir, mock_open, mock_kfinalise, mock_kprep_class, mock_base_args):
"""Test that CDG styles are loaded correctly when --enable_cdg is used."""
mock_base_args.args = ["Artist", "Title"]
@@ -412,7 +412,7 @@ async def test_finalise_cdg_style_loading(mock_exists, mock_chdir, mock_open, mo
mock_kprep_instance.process = AsyncMock(return_value=[MOCK_PREP_TRACK])
mock_kfinalise.return_value.process = MagicMock(return_value=MOCK_FINAL_TRACK)
with patch("karaoke_prep.utils.gen_cli.argparse.ArgumentParser") as mock_parser:
with patch("karaoke_gen.utils.gen_cli.argparse.ArgumentParser") as mock_parser:
mock_parser.return_value.parse_args.return_value = mock_base_args
await gen_cli.async_main()
@@ -427,12 +427,12 @@ async def test_finalise_cdg_style_loading(mock_exists, mock_chdir, mock_open, mo
assert finalise_call_kwargs["cdg_styles"] == expected_cdg_styles
@patch("karaoke_prep.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
@patch("karaoke_prep.utils.gen_cli.KaraokeFinalise")
@patch("karaoke_gen.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
@patch("karaoke_gen.utils.gen_cli.KaraokeFinalise")
@patch("builtins.open", side_effect=FileNotFoundError)
@patch("karaoke_prep.utils.gen_cli.os.chdir")
@patch("karaoke_prep.utils.gen_cli.os.path.exists", return_value=True)
@patch("karaoke_prep.utils.gen_cli.sys.exit")
@patch("karaoke_gen.utils.gen_cli.os.chdir")
@patch("karaoke_gen.utils.gen_cli.os.path.exists", return_value=True)
@patch("karaoke_gen.utils.gen_cli.sys.exit")
async def test_finalise_cdg_style_file_not_found(mock_exit, mock_exists, mock_chdir, mock_open, mock_kfinalise, mock_kprep_class, mock_base_args, mock_logger):
"""Test exit if CDG enabled but style file not found."""
mock_base_args.args = ["Artist", "Title"]
@@ -443,8 +443,8 @@ async def test_finalise_cdg_style_file_not_found(mock_exit, mock_exists, mock_ch
mock_kprep_class.return_value = mock_kprep_instance
mock_kprep_instance.process = AsyncMock(return_value=[MOCK_PREP_TRACK])
with patch("karaoke_prep.utils.gen_cli.argparse.ArgumentParser") as mock_parser, \
patch("karaoke_prep.utils.gen_cli.logging.getLogger", return_value=mock_logger):
with patch("karaoke_gen.utils.gen_cli.argparse.ArgumentParser") as mock_parser, \
patch("karaoke_gen.utils.gen_cli.logging.getLogger", return_value=mock_logger):
mock_parser.return_value.parse_args.return_value = mock_base_args
await gen_cli.async_main()
@@ -455,12 +455,12 @@ async def test_finalise_cdg_style_file_not_found(mock_exit, mock_exists, mock_ch
mock_kfinalise.assert_not_called()
@patch("karaoke_prep.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
@patch("karaoke_prep.utils.gen_cli.KaraokeFinalise")
@patch("karaoke_gen.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
@patch("karaoke_gen.utils.gen_cli.KaraokeFinalise")
@patch("builtins.open", new_callable=mock_open, read_data="invalid json") # Invalid JSON
@patch("karaoke_prep.utils.gen_cli.os.chdir")
@patch("karaoke_prep.utils.gen_cli.os.path.exists", return_value=True)
@patch("karaoke_prep.utils.gen_cli.sys.exit")
@patch("karaoke_gen.utils.gen_cli.os.chdir")
@patch("karaoke_gen.utils.gen_cli.os.path.exists", return_value=True)
@patch("karaoke_gen.utils.gen_cli.sys.exit")
async def test_finalise_cdg_style_invalid_json(mock_exit, mock_exists, mock_chdir, mock_open, mock_kfinalise, mock_kprep_class, mock_base_args, mock_logger):
"""Test exit if CDG enabled but style file has invalid JSON."""
mock_base_args.args = ["Artist", "Title"]
@@ -471,8 +471,8 @@ async def test_finalise_cdg_style_invalid_json(mock_exit, mock_exists, mock_chdi
mock_kprep_class.return_value = mock_kprep_instance
mock_kprep_instance.process = AsyncMock(return_value=[MOCK_PREP_TRACK])
with patch("karaoke_prep.utils.gen_cli.argparse.ArgumentParser") as mock_parser, \
patch("karaoke_prep.utils.gen_cli.logging.getLogger", return_value=mock_logger):
with patch("karaoke_gen.utils.gen_cli.argparse.ArgumentParser") as mock_parser, \
patch("karaoke_gen.utils.gen_cli.logging.getLogger", return_value=mock_logger):
mock_parser.return_value.parse_args.return_value = mock_base_args
await gen_cli.async_main()
@@ -484,8 +484,8 @@ async def test_finalise_cdg_style_invalid_json(mock_exit, mock_exists, mock_chdi
mock_kfinalise.assert_not_called()
@patch("karaoke_prep.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
@patch("karaoke_prep.utils.gen_cli.KaraokeFinalise")
@patch("karaoke_gen.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
@patch("karaoke_gen.utils.gen_cli.KaraokeFinalise")
async def test_error_handling_kprep_failure(mock_kfinalise, mock_kprep_class, mock_base_args, mock_logger, caplog):
"""Test error handling if KaraokePrep.process fails."""
mock_base_args.args = ["Artist", "Title"]
@@ -493,7 +493,7 @@ async def test_error_handling_kprep_failure(mock_kfinalise, mock_kprep_class, mo
mock_kprep_class.return_value = mock_kprep_instance
mock_kprep_instance.process = AsyncMock(side_effect=Exception("KPrep Failed!"))
with patch("karaoke_prep.utils.gen_cli.argparse.ArgumentParser") as mock_parser:
with patch("karaoke_gen.utils.gen_cli.argparse.ArgumentParser") as mock_parser:
mock_parser.return_value.parse_args.return_value = mock_base_args
# Expect the exception to propagate
with pytest.raises(Exception, match="KPrep Failed!"):
@@ -504,10 +504,10 @@ async def test_error_handling_kprep_failure(mock_kfinalise, mock_kprep_class, mo
mock_kfinalise.assert_not_called() # Should not reach finalise
@patch("karaoke_prep.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
@patch("karaoke_prep.utils.gen_cli.KaraokeFinalise")
@patch("karaoke_prep.utils.gen_cli.os.chdir")
@patch("karaoke_prep.utils.gen_cli.os.path.exists", return_value=True)
@patch("karaoke_gen.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
@patch("karaoke_gen.utils.gen_cli.KaraokeFinalise")
@patch("karaoke_gen.utils.gen_cli.os.chdir")
@patch("karaoke_gen.utils.gen_cli.os.path.exists", return_value=True)
async def test_error_handling_kfinalise_failure(mock_exists, mock_chdir, mock_kfinalise, mock_kprep_class, mock_base_args, mock_logger, caplog):
"""Test error handling if KaraokeFinalise.process fails."""
mock_base_args.args = ["Artist", "Title"]
@@ -517,7 +517,7 @@ async def test_error_handling_kfinalise_failure(mock_exists, mock_chdir, mock_kf
mock_kfinalise_instance = mock_kfinalise.return_value
mock_kfinalise_instance.process.side_effect = Exception("KFinalise Failed!")
with patch("karaoke_prep.utils.gen_cli.argparse.ArgumentParser") as mock_parser:
with patch("karaoke_gen.utils.gen_cli.argparse.ArgumentParser") as mock_parser:
mock_parser.return_value.parse_args.return_value = mock_base_args
# Expect the exception to propagate
with pytest.raises(Exception, match="KFinalise Failed!"):
@@ -530,11 +530,11 @@ async def test_error_handling_kfinalise_failure(mock_exists, mock_chdir, mock_kf
mock_kfinalise_instance.process.assert_called_once() # Process is called
# Check the error message in log
assert "Error during finalisation: KFinalise Failed!" in caplog.text
assert "An error occurred during finalisation, see stack trace below: KFinalise Failed!" in caplog.text
@patch("karaoke_prep.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
@patch("karaoke_prep.utils.gen_cli.KaraokeFinalise")
@patch("karaoke_gen.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
@patch("karaoke_gen.utils.gen_cli.KaraokeFinalise")
async def test_argument_passthrough(mock_kfinalise, mock_kprep_class, mock_base_args):
"""Test that various arguments are passed correctly to KaraokePrep/Finalise."""
mock_base_args.args = ["Artist", "Title"]
@@ -557,9 +557,9 @@ async def test_argument_passthrough(mock_kfinalise, mock_kprep_class, mock_base_
mock_kprep_instance.process = AsyncMock(return_value=[MOCK_PREP_TRACK])
mock_kfinalise.return_value.process = MagicMock(return_value=MOCK_FINAL_TRACK)
with patch("karaoke_prep.utils.gen_cli.argparse.ArgumentParser") as mock_parser, \
patch("karaoke_prep.utils.gen_cli.os.chdir"), \
patch("karaoke_prep.utils.gen_cli.os.path.exists", return_value=True):
with patch("karaoke_gen.utils.gen_cli.argparse.ArgumentParser") as mock_parser, \
patch("karaoke_gen.utils.gen_cli.os.chdir"), \
patch("karaoke_gen.utils.gen_cli.os.path.exists", return_value=True):
mock_parser.return_value.parse_args.return_value = mock_base_args
await gen_cli.async_main()
@@ -586,11 +586,11 @@ async def test_argument_passthrough(mock_kfinalise, mock_kprep_class, mock_base_
assert finalise_kwargs["non_interactive"] is True
@patch("karaoke_prep.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
@patch("karaoke_prep.utils.gen_cli.KaraokeFinalise")
@patch("karaoke_prep.utils.gen_cli.os.chdir")
@patch("karaoke_prep.utils.gen_cli.os.path.exists", return_value=True)
@patch("karaoke_prep.utils.gen_cli.pyperclip.copy")
@patch("karaoke_gen.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
@patch("karaoke_gen.utils.gen_cli.KaraokeFinalise")
@patch("karaoke_gen.utils.gen_cli.os.chdir")
@patch("karaoke_gen.utils.gen_cli.os.path.exists", return_value=True)
@patch("karaoke_gen.utils.gen_cli.pyperclip.copy")
async def test_clipboard_copy_success(mock_copy, mock_exists, mock_chdir, mock_kfinalise, mock_kprep_class, mock_base_args, mock_logger, caplog):
"""Test logging when clipboard copy succeeds."""
mock_base_args.args = ["Artist", "Title"]
@@ -606,7 +606,7 @@ async def test_clipboard_copy_success(mock_copy, mock_exists, mock_chdir, mock_k
mock_final_track_with_urls["brand_code_dir_sharing_link"] = "http://share.link/fake"
mock_kfinalise.return_value.process = MagicMock(return_value=mock_final_track_with_urls)
with patch("karaoke_prep.utils.gen_cli.argparse.ArgumentParser") as mock_parser:
with patch("karaoke_gen.utils.gen_cli.argparse.ArgumentParser") as mock_parser:
mock_parser.return_value.parse_args.return_value = mock_base_args
await gen_cli.async_main()
@@ -621,11 +621,11 @@ async def test_clipboard_copy_success(mock_copy, mock_exists, mock_chdir, mock_k
], any_order=True)
@patch("karaoke_prep.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
@patch("karaoke_prep.utils.gen_cli.KaraokeFinalise")
@patch("karaoke_prep.utils.gen_cli.os.chdir")
@patch("karaoke_prep.utils.gen_cli.os.path.exists", return_value=True)
@patch("karaoke_prep.utils.gen_cli.pyperclip.copy", side_effect=Exception("Clipboard Error"))
@patch("karaoke_gen.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
@patch("karaoke_gen.utils.gen_cli.KaraokeFinalise")
@patch("karaoke_gen.utils.gen_cli.os.chdir")
@patch("karaoke_gen.utils.gen_cli.os.path.exists", return_value=True)
@patch("karaoke_gen.utils.gen_cli.pyperclip.copy", side_effect=Exception("Clipboard Error"))
async def test_clipboard_copy_failure(mock_copy, mock_exists, mock_chdir, mock_kfinalise, mock_kprep_class, mock_base_args, mock_logger, caplog):
"""Test logging when clipboard copy fails."""
mock_base_args.args = ["Artist", "Title"]
@@ -641,7 +641,7 @@ async def test_clipboard_copy_failure(mock_copy, mock_exists, mock_chdir, mock_k
mock_final_track_with_urls["brand_code_dir_sharing_link"] = "http://share.link/fake"
mock_kfinalise.return_value.process = MagicMock(return_value=mock_final_track_with_urls)
with patch("karaoke_prep.utils.gen_cli.argparse.ArgumentParser") as mock_parser:
with patch("karaoke_gen.utils.gen_cli.argparse.ArgumentParser") as mock_parser:
mock_parser.return_value.parse_args.return_value = mock_base_args
await gen_cli.async_main()
+25 -25
View File
@@ -3,27 +3,27 @@ import pytest
from unittest.mock import MagicMock, patch
import json
import logging
from karaoke_prep.karaoke_prep import KaraokePrep
from karaoke_gen.karaoke_gen import KaraokePrep
import tempfile
class TestInitialization:
def test_init_with_defaults(self, mock_logger):
"""Test initialization with default parameters."""
karaoke_prep = KaraokePrep(logger=mock_logger)
karaoke_gen = KaraokePrep(logger=mock_logger)
assert karaoke_prep.input_media is None
assert karaoke_prep.artist is None
assert karaoke_prep.title is None
assert karaoke_prep.dry_run is False
assert karaoke_prep.logger is mock_logger
assert karaoke_prep.output_dir == "."
assert karaoke_prep.lossless_output_format == "flac"
assert karaoke_prep.create_track_subfolders is False
assert karaoke_gen.input_media is None
assert karaoke_gen.artist is None
assert karaoke_gen.title is None
assert karaoke_gen.dry_run is False
assert karaoke_gen.logger is mock_logger
assert karaoke_gen.output_dir == "."
assert karaoke_gen.lossless_output_format == "flac"
assert karaoke_gen.create_track_subfolders is False
def test_init_with_custom_params(self, mock_logger):
"""Test initialization with custom parameters."""
with patch('os.makedirs'):
karaoke_prep = KaraokePrep(
karaoke_gen = KaraokePrep(
input_media="test_media.mp4",
artist="Test Artist",
title="Test Title",
@@ -34,21 +34,21 @@ class TestInitialization:
create_track_subfolders=True
)
assert karaoke_prep.input_media == "test_media.mp4"
assert karaoke_prep.artist == "Test Artist"
assert karaoke_prep.title == "Test Title"
assert karaoke_prep.dry_run is True
assert karaoke_prep.logger is mock_logger
assert karaoke_prep.output_dir == "test_output"
assert karaoke_prep.lossless_output_format == "wav"
assert karaoke_prep.create_track_subfolders is True
assert karaoke_gen.input_media == "test_media.mp4"
assert karaoke_gen.artist == "Test Artist"
assert karaoke_gen.title == "Test Title"
assert karaoke_gen.dry_run is True
assert karaoke_gen.logger is mock_logger
assert karaoke_gen.output_dir == "test_output"
assert karaoke_gen.lossless_output_format == "wav"
assert karaoke_gen.create_track_subfolders is True
def test_init_creates_output_dir(self, mock_logger, temp_dir):
"""Test that initialization creates the output directory if it doesn't exist."""
output_dir = os.path.join(temp_dir, "new_dir")
with patch('os.makedirs') as mock_makedirs:
karaoke_prep = KaraokePrep(
karaoke_gen = KaraokePrep(
logger=mock_logger,
output_dir=output_dir
)
@@ -97,15 +97,15 @@ class TestInitialization:
with open(style_params_path, "w") as f:
json.dump(style_params, f)
karaoke_prep = KaraokePrep(
karaoke_gen = KaraokePrep(
logger=mock_logger,
style_params_json=style_params_path
)
assert karaoke_prep.intro_video_duration == 10
assert karaoke_prep.end_video_duration == 8
assert karaoke_prep.title_format["background_color"] == "#FF0000"
assert karaoke_prep.end_format["background_color"] == "#0000FF"
assert karaoke_gen.intro_video_duration == 10
assert karaoke_gen.end_video_duration == 8
assert karaoke_gen.title_format["background_color"] == "#FF0000"
assert karaoke_gen.end_format["background_color"] == "#0000FF"
def test_init_with_invalid_style_params_file(self, mock_logger):
"""Test initialization with an invalid style params file path."""
@@ -4,7 +4,7 @@ import shlex
from unittest.mock import patch, MagicMock, call
# Adjust the import path
from karaoke_prep.karaoke_finalise.karaoke_finalise import KaraokeFinalise
from karaoke_gen.karaoke_finalise.karaoke_finalise import KaraokeFinalise
from .test_initialization import mock_logger, basic_finaliser, MINIMAL_CONFIG # Reuse fixtures
from .test_file_input_validation import BASE_NAME, TITLE_MOV, END_MOV, WITH_VOCALS_MOV, INSTRUMENTAL_FLAC # Reuse constants
@@ -4,7 +4,7 @@ import json
from unittest.mock import patch, MagicMock, mock_open, call
# Adjust the import path
from karaoke_prep.karaoke_finalise.karaoke_finalise import KaraokeFinalise
from karaoke_gen.karaoke_finalise.karaoke_finalise import KaraokeFinalise
from .test_initialization import mock_logger, basic_finaliser, MINIMAL_CONFIG # Reuse fixtures
BASE_NAME = "Artist - Title"
@@ -6,7 +6,7 @@ import time
from unittest.mock import patch, MagicMock, call, ANY
# Adjust the import path
from karaoke_prep.karaoke_finalise.karaoke_finalise import KaraokeFinalise
from karaoke_gen.karaoke_finalise.karaoke_finalise import KaraokeFinalise
from .test_initialization import mock_logger, basic_finaliser, MINIMAL_CONFIG # Reuse fixtures
from .test_file_input_validation import BASE_NAME, ARTIST, TITLE # Reuse constants
from .test_ffmpeg_commands import OUTPUT_FILES as FFMPEG_OUTPUT_FILES # Reuse constants
@@ -6,7 +6,7 @@ from unittest.mock import patch, MagicMock, mock_open
# Adjust the import path based on your project structure
# Assuming tests are run from the project root
from karaoke_prep.karaoke_finalise.karaoke_finalise import KaraokeFinalise
from karaoke_gen.karaoke_finalise.karaoke_finalise import KaraokeFinalise
# Basic configuration for tests
MINIMAL_CONFIG = {
@@ -79,7 +79,7 @@ def test_init_custom_logger_setup():
finaliser = KaraokeFinalise(log_level=logging.INFO, **MINIMAL_CONFIG)
mock_get_logger.assert_called_once_with('karaoke_prep.karaoke_finalise.karaoke_finalise')
mock_get_logger.assert_called_once_with('karaoke_gen.karaoke_finalise.karaoke_finalise')
mock_logger_instance.setLevel.assert_called_once_with(logging.INFO)
mock_stream_handler.assert_called_once()
mock_formatter.assert_called_once_with("%(asctime)s - %(levelname)s - %(module)s - %(message)s")
@@ -7,7 +7,7 @@ from unittest.mock import patch, MagicMock, mock_open, call, ANY
import requests # For requests.exceptions.RequestException
# Adjust the import path
from karaoke_prep.karaoke_finalise.karaoke_finalise import KaraokeFinalise
from karaoke_gen.karaoke_finalise.karaoke_finalise import KaraokeFinalise
from .test_initialization import mock_logger, basic_finaliser, MINIMAL_CONFIG # Reuse fixtures
from .test_file_input_validation import ARTIST, TITLE # Reuse constants
from .test_youtube_integration import mock_google_auth # Reuse Gmail auth mocks structure
@@ -112,7 +112,7 @@ def test_post_discord_notification_dry_run(mock_post_msg, finaliser_for_notify):
# Patch open for token write.
# Patch the from_client_secrets_file method to control the flow instance.
@patch('karaoke_prep.karaoke_finalise.karaoke_finalise.InstalledAppFlow.from_client_secrets_file')
@patch('karaoke_gen.karaoke_finalise.karaoke_finalise.InstalledAppFlow.from_client_secrets_file')
@patch("builtins.open")
def test_authenticate_gmail_new_token(mock_open, mock_from_secrets, finaliser_for_notify, mock_google_auth, mock_gmail_service):
"""Test Gmail authentication flow when no token file exists."""
@@ -233,7 +233,7 @@ def test_authenticate_gmail_refresh_token(finaliser_for_notify, mock_google_auth
@patch('builtins.open', new_callable=mock_open, read_data="YT: {youtube_url}\nDB: {dropbox_url}")
@patch.object(KaraokeFinalise, 'authenticate_gmail')
# Patch MIMEText where it's used inside the karaoke_finalise module
@patch('karaoke_prep.karaoke_finalise.karaoke_finalise.MIMEText', return_value=MagicMock(spec=MIMEText))
@patch('karaoke_gen.karaoke_finalise.karaoke_finalise.MIMEText', return_value=MagicMock(spec=MIMEText))
@patch('base64.urlsafe_b64encode')
def test_draft_completion_email_success(mock_b64encode, mock_mime_text_cls, mock_auth_gmail, mock_open_template, finaliser_for_notify, mock_gmail_service):
"""Test successful email draft creation."""
@@ -3,7 +3,7 @@ import os
from unittest.mock import patch, MagicMock, call, ANY
# Adjust the import path
from karaoke_prep.karaoke_finalise.karaoke_finalise import KaraokeFinalise
from karaoke_gen.karaoke_finalise.karaoke_finalise import KaraokeFinalise
from .test_initialization import mock_logger, basic_finaliser, MINIMAL_CONFIG # Reuse fixtures
from .test_file_input_validation import BASE_NAME, ARTIST, TITLE, WITH_VOCALS_MOV, INSTRUMENTAL_FLAC # Reuse constants
from .test_ffmpeg_commands import OUTPUT_FILES as FFMPEG_OUTPUT_FILES # Reuse constants
@@ -2,7 +2,7 @@ import pytest
from unittest.mock import patch, MagicMock
# Adjust the import path
from karaoke_prep.karaoke_finalise.karaoke_finalise import KaraokeFinalise
from karaoke_gen.karaoke_finalise.karaoke_finalise import KaraokeFinalise
from .test_initialization import mock_logger, basic_finaliser, MINIMAL_CONFIG # Reuse fixtures
PROMPT_MSG = "Do you want to proceed?"
@@ -4,7 +4,7 @@ import pickle
from unittest.mock import patch, MagicMock, mock_open, call, ANY
# Adjust the import path
from karaoke_prep.karaoke_finalise.karaoke_finalise import KaraokeFinalise
from karaoke_gen.karaoke_finalise.karaoke_finalise import KaraokeFinalise
from .test_initialization import mock_logger, basic_finaliser, MINIMAL_CONFIG # Reuse fixtures
from .test_file_input_validation import BASE_NAME, ARTIST, TITLE, TITLE_JPG # Reuse constants
from .test_ffmpeg_commands import OUTPUT_FILES as FFMPEG_OUTPUT_FILES # Reuse constants
@@ -51,7 +51,7 @@ def mock_youtube_service():
def mock_google_auth():
"""Fixture to mock Google auth dependencies."""
# Patch build, pickle, os.path, and Request. Flow is patched in specific tests.
with patch('karaoke_prep.karaoke_finalise.karaoke_finalise.build') as mock_build, \
with patch('karaoke_gen.karaoke_finalise.karaoke_finalise.build') as mock_build, \
patch('pickle.dump') as mock_pickle_dump, \
patch('pickle.load') as mock_pickle_load, \
patch('os.path.exists') as mock_path_exists, \
@@ -102,7 +102,7 @@ def test_truncate_to_nearest_word(basic_finaliser):
# Patch open for token write.
# Patch the from_client_secrets_file method to control the flow instance.
@patch('karaoke_prep.karaoke_finalise.karaoke_finalise.InstalledAppFlow.from_client_secrets_file')
@patch('karaoke_gen.karaoke_finalise.karaoke_finalise.InstalledAppFlow.from_client_secrets_file')
@patch("builtins.open")
def test_authenticate_youtube_new_token(mock_open, mock_from_secrets, finaliser_for_yt, mock_google_auth, mock_youtube_service):
"""Test authentication flow when no token file exists."""
@@ -374,7 +374,7 @@ def test_delete_youtube_video_dry_run(mock_auth, finaliser_for_yt, mock_youtube_
@patch('builtins.open', new_callable=mock_open, read_data="Custom description from file")
# Patch the MediaFileUpload class where it's imported in the module under test
@patch('karaoke_prep.karaoke_finalise.karaoke_finalise.MediaFileUpload')
@patch('karaoke_gen.karaoke_finalise.karaoke_finalise.MediaFileUpload')
@patch.object(KaraokeFinalise, 'authenticate_youtube')
@patch.object(KaraokeFinalise, 'check_if_video_title_exists_on_youtube_channel', return_value=False) # Assume not exists
@patch.object(KaraokeFinalise, 'truncate_to_nearest_word', side_effect=lambda t, l: t) # Passthrough truncate
@@ -425,7 +425,7 @@ def test_upload_youtube_success(mock_truncate, mock_check_exists, mock_auth, moc
assert finaliser_for_yt.youtube_url == f"https://www.youtube.com/watch?v=new_video_id"
@patch('karaoke_prep.karaoke_finalise.karaoke_finalise.MediaFileUpload')
@patch('karaoke_gen.karaoke_finalise.karaoke_finalise.MediaFileUpload')
@patch.object(KaraokeFinalise, 'authenticate_youtube')
@patch.object(KaraokeFinalise, 'check_if_video_title_exists_on_youtube_channel', return_value=True) # Assume exists
@patch.object(KaraokeFinalise, 'delete_youtube_video')
@@ -445,7 +445,7 @@ def test_upload_youtube_exists_skip(mock_delete, mock_check_exists, mock_auth, m
@patch('builtins.open', new_callable=mock_open, read_data="Desc") # Mock open for description file
@patch('karaoke_prep.karaoke_finalise.karaoke_finalise.MediaFileUpload')
@patch('karaoke_gen.karaoke_finalise.karaoke_finalise.MediaFileUpload')
@patch.object(KaraokeFinalise, 'authenticate_youtube')
@patch.object(KaraokeFinalise, 'check_if_video_title_exists_on_youtube_channel', return_value=True) # Assume exists
@patch.object(KaraokeFinalise, 'delete_youtube_video', return_value=True) # Delete succeeds
@@ -469,7 +469,7 @@ def test_upload_youtube_exists_replace_success(mock_delete, mock_check_exists, m
mock_open_desc.assert_called_once_with(YOUTUBE_DESC_FILE, "r") # Check desc file read
@patch('karaoke_prep.karaoke_finalise.karaoke_finalise.MediaFileUpload')
@patch('karaoke_gen.karaoke_finalise.karaoke_finalise.MediaFileUpload')
@patch.object(KaraokeFinalise, 'authenticate_youtube')
@patch.object(KaraokeFinalise, 'check_if_video_title_exists_on_youtube_channel', return_value=True) # Assume exists
@patch.object(KaraokeFinalise, 'delete_youtube_video', return_value=False) # Delete fails
@@ -5,7 +5,7 @@ import tomllib # Keep import for patching
from unittest.mock import patch, MagicMock, mock_open, call
# Adjust the import path
from karaoke_prep.karaoke_finalise.karaoke_finalise import KaraokeFinalise
from karaoke_gen.karaoke_finalise.karaoke_finalise import KaraokeFinalise
from .test_initialization import mock_logger, basic_finaliser, MINIMAL_CONFIG # Reuse fixtures
from .test_file_input_validation import BASE_NAME, KARAOKE_LRC, INSTRUMENTAL_FLAC # Reuse constants
@@ -234,7 +234,7 @@ def test_create_cdg_zip_generation_fails_to_create_zip(mock_prompt, mock_cdg_gen
@patch('os.path.isfile')
@patch('zipfile.ZipFile')
# Patch the converter where it's imported in the target module
@patch('karaoke_prep.karaoke_finalise.karaoke_finalise.LyricsConverter')
@patch('karaoke_gen.karaoke_finalise.karaoke_finalise.LyricsConverter')
@patch('builtins.open', new_callable=mock_open) # For the TXT write
@patch.object(KaraokeFinalise, 'prompt_user_bool', return_value=True) # Confirm overwrite
def test_create_txt_zip_generate_new(mock_prompt, mock_open_txt_write, mock_lyrics_converter_cls, mock_zipfile, mock_isfile, basic_finaliser):
@@ -281,7 +281,7 @@ def test_create_txt_zip_skip_overwrite(mock_prompt, mock_open_file, mock_lyrics_
@patch('os.path.isfile')
@patch('zipfile.ZipFile', side_effect=Exception("Zip creation failed")) # Simulate zip error
@patch('karaoke_prep.karaoke_finalise.karaoke_finalise.LyricsConverter')
@patch('karaoke_gen.karaoke_finalise.karaoke_finalise.LyricsConverter')
@patch('builtins.open', new_callable=mock_open) # For the TXT write
@patch.object(KaraokeFinalise, 'prompt_user_bool', return_value=True)
def test_create_txt_zip_creation_fails(mock_prompt, mock_open_txt_write, mock_lyrics_converter_cls, mock_zipfile, mock_isfile, basic_finaliser):
+33 -33
View File
@@ -2,76 +2,76 @@ import os
import pytest
from unittest.mock import MagicMock, patch, call, DEFAULT
import shutil
from karaoke_prep.karaoke_prep import KaraokePrep
from karaoke_prep.utils import sanitize_filename
from karaoke_gen.karaoke_gen import KaraokePrep
from karaoke_gen.utils import sanitize_filename
class TestLyrics:
def test_find_best_split_point_with_comma(self, basic_karaoke_prep):
def test_find_best_split_point_with_comma(self, basic_karaoke_gen):
"""Test finding the best split point with a comma near the middle."""
line = "This is a test line, with a comma near the middle of the sentence"
split_point = basic_karaoke_prep.lyrics_processor.find_best_split_point(line)
split_point = basic_karaoke_gen.lyrics_processor.find_best_split_point(line)
# The split should be after the comma
assert line[:split_point].strip() == "This is a test line,"
assert line[split_point:].strip() == "with a comma near the middle of the sentence"
def test_find_best_split_point_with_and(self, basic_karaoke_prep):
def test_find_best_split_point_with_and(self, basic_karaoke_gen):
"""Test finding the best split point with 'and' near the middle."""
line = "This is a test line and this is the second part of the sentence"
split_point = basic_karaoke_prep.lyrics_processor.find_best_split_point(line)
split_point = basic_karaoke_gen.lyrics_processor.find_best_split_point(line)
# The split should be after 'and'
assert line[:split_point].strip() == "This is a test line and"
assert line[split_point:].strip() == "this is the second part of the sentence"
def test_find_best_split_point_at_middle_word(self, basic_karaoke_prep):
def test_find_best_split_point_at_middle_word(self, basic_karaoke_gen):
"""Test finding the best split point at the middle word."""
line = "This is a test line without any good split points"
split_point = basic_karaoke_prep.lyrics_processor.find_best_split_point(line)
split_point = basic_karaoke_gen.lyrics_processor.find_best_split_point(line)
# The split should be at the middle word
assert line[:split_point].strip() == "This is a test line"
assert line[split_point:].strip() == "without any good split points"
def test_find_best_split_point_forced_split(self, basic_karaoke_prep):
def test_find_best_split_point_forced_split(self, basic_karaoke_gen):
"""Test finding the best split point with forced split at max length."""
# Create a very long line without good split points
line = "Thisisaverylonglinewithoutanyspacesorpunctuationthatexceedsthemaximumlengthallowedforasingleline"
split_point = basic_karaoke_prep.lyrics_processor.find_best_split_point(line)
split_point = basic_karaoke_gen.lyrics_processor.find_best_split_point(line)
# The split should be at the maximum length (36)
assert split_point == 36
assert len(line[:split_point]) == 36
def test_process_line_short(self, basic_karaoke_prep):
def test_process_line_short(self, basic_karaoke_gen):
"""Test processing a line that's already short enough."""
line = "This is a short line"
processed = basic_karaoke_prep.lyrics_processor.process_line(line)
processed = basic_karaoke_gen.lyrics_processor.process_line(line)
assert processed == [line]
def test_process_line_with_parentheses(self, basic_karaoke_prep):
def test_process_line_with_parentheses(self, basic_karaoke_gen):
"""Test processing a line with parentheses."""
line = "This is a line with (some parenthetical text) that should be split"
processed = basic_karaoke_prep.lyrics_processor.process_line(line)
processed = basic_karaoke_gen.lyrics_processor.process_line(line)
assert processed[0] == "This is a line with"
assert processed[1] == "(some parenthetical text)"
assert processed[2] == "that should be split"
def test_process_line_with_parentheses_and_comma(self, basic_karaoke_prep):
def test_process_line_with_parentheses_and_comma(self, basic_karaoke_gen):
"""Test processing a line with parentheses followed by a comma."""
line = "This is a line with (some parenthetical text), that should be split"
processed = basic_karaoke_prep.lyrics_processor.process_line(line)
processed = basic_karaoke_gen.lyrics_processor.process_line(line)
assert processed[0] == "This is a line with"
assert processed[1] == "(some parenthetical text),"
assert processed[2] == "that should be split"
def test_process_line_long(self, basic_karaoke_prep):
def test_process_line_long(self, basic_karaoke_gen):
"""Test processing a long line that needs multiple splits."""
line = "This is a very long line that needs to be split into multiple lines because it exceeds the maximum length allowed for a single line"
processed = basic_karaoke_prep.lyrics_processor.process_line(line)
processed = basic_karaoke_gen.lyrics_processor.process_line(line)
# Should be split into multiple lines
assert len(processed) > 1
@@ -79,7 +79,7 @@ class TestLyrics:
for p in processed:
assert len(p) <= 36
def test_transcribe_lyrics_existing_files_parent_dir(self, basic_karaoke_prep, temp_dir):
def test_transcribe_lyrics_existing_files_parent_dir(self, basic_karaoke_gen, temp_dir):
"""Test transcribing lyrics when files already exist in parent directory."""
# Setup
track_output_dir = os.path.join(temp_dir, "track")
@@ -103,13 +103,13 @@ class TestLyrics:
# Test with mocked os.path.exists
with patch('os.path.exists', return_value=True):
# Call the method on the lyrics_processor
result = basic_karaoke_prep.lyrics_processor.transcribe_lyrics(None, artist, title, track_output_dir)
result = basic_karaoke_gen.lyrics_processor.transcribe_lyrics(None, artist, title, track_output_dir)
# Verify
assert result["lrc_filepath"] == parent_lrc_path
assert result["ass_filepath"] == parent_video_path
def test_transcribe_lyrics_existing_files_lyrics_dir(self, basic_karaoke_prep, temp_dir):
def test_transcribe_lyrics_existing_files_lyrics_dir(self, basic_karaoke_gen, temp_dir):
"""Test transcribing lyrics when files already exist in lyrics directory."""
# Setup
track_output_dir = os.path.join(temp_dir, "track")
@@ -138,7 +138,7 @@ class TestLyrics:
with patch('os.path.exists', side_effect=lambda path: path in [lyrics_video_path, lyrics_lrc_path]), \
patch('shutil.copy2') as mock_copy2:
# Call the method on the lyrics_processor
result = basic_karaoke_prep.lyrics_processor.transcribe_lyrics(None, artist, title, track_output_dir)
result = basic_karaoke_gen.lyrics_processor.transcribe_lyrics(None, artist, title, track_output_dir)
# Verify copy2 was called with correct arguments
mock_copy2.assert_any_call(lyrics_video_path, parent_video_path)
@@ -148,7 +148,7 @@ class TestLyrics:
assert result["lrc_filepath"] == parent_lrc_path
assert result["ass_filepath"] == parent_video_path
def test_transcribe_lyrics_new_transcription(self, basic_karaoke_prep, temp_dir):
def test_transcribe_lyrics_new_transcription(self, basic_karaoke_gen, temp_dir):
"""Test transcribing lyrics with a new transcription."""
# Setup
track_output_dir = os.path.join(temp_dir, "track")
@@ -191,15 +191,15 @@ class TestLyrics:
}
# Test with mocked dependencies
with patch('karaoke_prep.lyrics_processor.LyricsTranscriber', mock_transcriber), \
with patch('karaoke_gen.lyrics_processor.LyricsTranscriber', mock_transcriber), \
patch('os.makedirs'), \
patch('os.path.exists', return_value=False), \
patch('shutil.copy2') as mock_copy2, \
patch('os.getenv', side_effect=lambda key: mock_env.get(key)), \
patch('karaoke_prep.lyrics_processor.load_dotenv'):
patch('karaoke_gen.lyrics_processor.load_dotenv'):
# Call the method on the lyrics_processor
result = basic_karaoke_prep.lyrics_processor.transcribe_lyrics(input_audio_wav, artist, title, track_output_dir)
result = basic_karaoke_gen.lyrics_processor.transcribe_lyrics(input_audio_wav, artist, title, track_output_dir)
# Verify LyricsTranscriber was initialized with correct arguments
mock_transcriber.assert_called_once()
@@ -217,7 +217,7 @@ class TestLyrics:
assert result["corrected_lyrics_text"] == "Line 1\nLine 2"
assert result["corrected_lyrics_text_filepath"] == mock_results.corrected_txt
def test_backup_existing_outputs(self, basic_karaoke_prep, temp_dir):
def test_backup_existing_outputs(self, basic_karaoke_gen, temp_dir):
"""Test backing up existing outputs."""
# Setup
track_output_dir = os.path.join(temp_dir, "track")
@@ -248,7 +248,7 @@ class TestLyrics:
patch('shutil.copytree') as mock_copytree, \
patch('shutil.rmtree') as mock_rmtree:
result = basic_karaoke_prep.file_handler.backup_existing_outputs(track_output_dir, artist, title)
result = basic_karaoke_gen.file_handler.backup_existing_outputs(track_output_dir, artist, title)
# Verify the correct input audio file was returned
assert result == input_audio_wav
@@ -257,7 +257,7 @@ class TestLyrics:
version_dir = os.path.join(track_output_dir, "version-1")
# Verify files were moved to version directory
if not basic_karaoke_prep.dry_run:
if not basic_karaoke_gen.dry_run:
mock_move.assert_any_call(with_vocals_file, os.path.join(version_dir, os.path.basename(with_vocals_file)))
mock_move.assert_any_call(karaoke_file, os.path.join(version_dir, os.path.basename(karaoke_file)))
mock_move.assert_any_call(final_karaoke_file, os.path.join(version_dir, os.path.basename(final_karaoke_file)))
@@ -266,7 +266,7 @@ class TestLyrics:
mock_copytree.assert_called_once_with(lyrics_dir, os.path.join(version_dir, "lyrics"))
mock_rmtree.assert_called_once_with(lyrics_dir)
def test_backup_existing_outputs_no_input_audio(self, basic_karaoke_prep, temp_dir):
def test_backup_existing_outputs_no_input_audio(self, basic_karaoke_gen, temp_dir):
"""Test backing up existing outputs when input audio file is not found."""
# Setup
track_output_dir = os.path.join(temp_dir, "track")
@@ -287,12 +287,12 @@ class TestLyrics:
patch('shutil.rmtree'), \
patch('os.path.exists', return_value=False):
result = basic_karaoke_prep.file_handler.backup_existing_outputs(track_output_dir, artist, title)
result = basic_karaoke_gen.file_handler.backup_existing_outputs(track_output_dir, artist, title)
# Verify the alternative WAV file was returned
assert result == alt_wav_file
def test_backup_existing_outputs_no_wav_files(self, basic_karaoke_prep, temp_dir):
def test_backup_existing_outputs_no_wav_files(self, basic_karaoke_gen, temp_dir):
"""Test backing up existing outputs when no WAV files are found."""
# Setup
track_output_dir = os.path.join(temp_dir, "track")
@@ -306,4 +306,4 @@ class TestLyrics:
patch('os.path.exists', return_value=False):
with pytest.raises(Exception, match=f"No input audio file found in {track_output_dir}"):
basic_karaoke_prep.file_handler.backup_existing_outputs(track_output_dir, artist, title)
basic_karaoke_gen.file_handler.backup_existing_outputs(track_output_dir, artist, title)
+58 -58
View File
@@ -2,10 +2,10 @@ import pytest
from unittest.mock import MagicMock, patch, call
# Import the specific class for patching is not needed if we patch the target correctly
# from yt_dlp import YoutubeDL
from karaoke_prep.karaoke_prep import KaraokePrep
from karaoke_gen.karaoke_gen import KaraokePrep
class TestMetadata:
def test_extract_info_for_online_media_with_url(self, basic_karaoke_prep):
def test_extract_info_for_online_media_with_url(self, basic_karaoke_gen):
"""Test extracting info from online media with a URL."""
url = "https://example.com/video"
mock_info = {
@@ -22,12 +22,12 @@ class TestMetadata:
mock_ydl_instance.extract_info.return_value = mock_info
# Patch the 'ydl' alias used in metadata.py
with patch('karaoke_prep.metadata.ydl') as mock_ydl_context:
with patch('karaoke_gen.metadata.ydl') as mock_ydl_context:
# Configure the context manager mock
mock_ydl_context.return_value.__enter__.return_value = mock_ydl_instance
# Call the method
basic_karaoke_prep.extract_info_for_online_media(input_url=url)
basic_karaoke_gen.extract_info_for_online_media(input_url=url)
# Verify ydl was instantiated (implicitly checks context manager usage)
mock_ydl_context.assert_called_once_with({"quiet": True})
@@ -36,9 +36,9 @@ class TestMetadata:
mock_ydl_instance.extract_info.assert_called_once_with(url, download=False)
# Verify the extracted_info was set correctly
assert basic_karaoke_prep.extracted_info == mock_info
assert basic_karaoke_gen.extracted_info == mock_info
def test_extract_info_for_online_media_with_search(self, basic_karaoke_prep):
def test_extract_info_for_online_media_with_search(self, basic_karaoke_gen):
"""Test extracting info from online media with artist and title search."""
artist = "Test Artist"
title = "Test Title"
@@ -60,12 +60,12 @@ class TestMetadata:
mock_ydl_instance.extract_info.return_value = mock_search_result
# Patch the 'ydl' alias used in metadata.py
with patch('karaoke_prep.metadata.ydl') as mock_ydl_context:
with patch('karaoke_gen.metadata.ydl') as mock_ydl_context:
# Configure the context manager mock
mock_ydl_context.return_value.__enter__.return_value = mock_ydl_instance
# Call the method
basic_karaoke_prep.extract_info_for_online_media(input_artist=artist, input_title=title)
basic_karaoke_gen.extract_info_for_online_media(input_artist=artist, input_title=title)
# Verify ydl was instantiated with correct options
expected_ydl_opts = {"quiet": "True", "format": "bestaudio", "noplaylist": "True", "extract_flat": True}
@@ -76,9 +76,9 @@ class TestMetadata:
mock_ydl_instance.extract_info.assert_called_once_with(expected_query, download=False)
# Verify the extracted_info was set correctly
assert basic_karaoke_prep.extracted_info == mock_search_result["entries"][0]
assert basic_karaoke_gen.extracted_info == mock_search_result["entries"][0]
def test_extract_info_for_online_media_no_results(self, basic_karaoke_prep):
def test_extract_info_for_online_media_no_results(self, basic_karaoke_gen):
"""Test extracting info from online media with no search results."""
artist = "Test Artist"
title = "Test Title"
@@ -91,13 +91,13 @@ class TestMetadata:
mock_ydl_instance.extract_info.return_value = mock_search_result
# Patch the 'ydl' alias used in metadata.py
with patch('karaoke_prep.metadata.ydl') as mock_ydl_context:
with patch('karaoke_gen.metadata.ydl') as mock_ydl_context:
# Configure the context manager mock
mock_ydl_context.return_value.__enter__.return_value = mock_ydl_instance
# Assert that calling the method with no results raises an IndexError
with pytest.raises(IndexError):
basic_karaoke_prep.extract_info_for_online_media(input_artist=artist, input_title=title)
basic_karaoke_gen.extract_info_for_online_media(input_artist=artist, input_title=title)
# Verify ydl was instantiated with correct options
expected_ydl_opts = {"quiet": "True", "format": "bestaudio", "noplaylist": "True", "extract_flat": True}
@@ -107,26 +107,26 @@ class TestMetadata:
expected_query = f"ytsearch1:{artist} {title}"
mock_ydl_instance.extract_info.assert_called_once_with(expected_query, download=False)
def test_parse_single_track_metadata_complete(self, basic_karaoke_prep):
def test_parse_single_track_metadata_complete(self, basic_karaoke_gen):
"""Test parsing metadata from extracted info with complete information."""
basic_karaoke_prep.extracted_info = {
basic_karaoke_gen.extracted_info = {
"title": "Test Artist - Test Title",
"extractor_key": "Youtube",
"id": "12345",
"url": "https://example.com/video"
}
basic_karaoke_prep.parse_single_track_metadata(None, None)
basic_karaoke_gen.parse_single_track_metadata(None, None)
assert basic_karaoke_prep.url == "https://example.com/video"
assert basic_karaoke_prep.extractor == "Youtube"
assert basic_karaoke_prep.media_id == "12345"
assert basic_karaoke_prep.artist == "Test Artist"
assert basic_karaoke_prep.title == "Test Title"
assert basic_karaoke_gen.url == "https://example.com/video"
assert basic_karaoke_gen.extractor == "Youtube"
assert basic_karaoke_gen.media_id == "12345"
assert basic_karaoke_gen.artist == "Test Artist"
assert basic_karaoke_gen.title == "Test Title"
def test_parse_single_track_metadata_with_input_values(self, basic_karaoke_prep):
def test_parse_single_track_metadata_with_input_values(self, basic_karaoke_gen):
"""Test parsing metadata with provided input values."""
basic_karaoke_prep.extracted_info = {
basic_karaoke_gen.extracted_info = {
"title": "Wrong Artist - Wrong Title",
"extractor_key": "Youtube",
"id": "12345",
@@ -138,88 +138,88 @@ class TestMetadata:
# Set artist and title on the instance *before* calling parse,
# because the method uses these values in its final check.
basic_karaoke_prep.artist = input_artist
basic_karaoke_prep.title = input_title
basic_karaoke_gen.artist = input_artist
basic_karaoke_gen.title = input_title
# Call the method
basic_karaoke_prep.parse_single_track_metadata(input_artist, input_title)
basic_karaoke_gen.parse_single_track_metadata(input_artist, input_title)
# Verify URL, extractor, and ID are parsed correctly
assert basic_karaoke_prep.url == "https://example.com/video"
assert basic_karaoke_prep.extractor == "Youtube"
assert basic_karaoke_prep.media_id == "12345"
assert basic_karaoke_gen.url == "https://example.com/video"
assert basic_karaoke_gen.extractor == "Youtube"
assert basic_karaoke_gen.media_id == "12345"
# Verify the artist and title remain the input values
assert basic_karaoke_prep.artist == input_artist
assert basic_karaoke_prep.title == input_title
assert basic_karaoke_gen.artist == input_artist
assert basic_karaoke_gen.title == input_title
def test_parse_single_track_metadata_with_persistent_artist(self, basic_karaoke_prep):
def test_parse_single_track_metadata_with_persistent_artist(self, basic_karaoke_gen):
"""Test parsing metadata with persistent artist."""
basic_karaoke_prep.extracted_info = {
basic_karaoke_gen.extracted_info = {
"title": "Test Artist - Test Title",
"extractor_key": "Youtube",
"id": "12345",
"url": "https://example.com/video"
}
basic_karaoke_prep.persistent_artist = "Persistent Artist"
basic_karaoke_gen.persistent_artist = "Persistent Artist"
basic_karaoke_prep.parse_single_track_metadata(None, None)
basic_karaoke_gen.parse_single_track_metadata(None, None)
assert basic_karaoke_prep.artist == "Persistent Artist"
assert basic_karaoke_prep.title == "Test Title"
assert basic_karaoke_gen.artist == "Persistent Artist"
assert basic_karaoke_gen.title == "Test Title"
def test_parse_single_track_metadata_with_ie_key(self, basic_karaoke_prep):
def test_parse_single_track_metadata_with_ie_key(self, basic_karaoke_gen):
"""Test parsing metadata with ie_key instead of extractor_key."""
basic_karaoke_prep.extracted_info = {
basic_karaoke_gen.extracted_info = {
"title": "Test Artist - Test Title",
"ie_key": "Youtube",
"id": "12345",
"url": "https://example.com/video"
}
basic_karaoke_prep.parse_single_track_metadata(None, None)
basic_karaoke_gen.parse_single_track_metadata(None, None)
assert basic_karaoke_prep.extractor == "Youtube"
assert basic_karaoke_gen.extractor == "Youtube"
def test_parse_single_track_metadata_with_webpage_url(self, basic_karaoke_prep):
def test_parse_single_track_metadata_with_webpage_url(self, basic_karaoke_gen):
"""Test parsing metadata with webpage_url instead of url."""
basic_karaoke_prep.extracted_info = {
basic_karaoke_gen.extracted_info = {
"title": "Test Artist - Test Title",
"extractor_key": "Youtube",
"id": "12345",
"webpage_url": "https://example.com/video"
}
basic_karaoke_prep.parse_single_track_metadata(None, None)
basic_karaoke_gen.parse_single_track_metadata(None, None)
assert basic_karaoke_prep.url == "https://example.com/video"
assert basic_karaoke_gen.url == "https://example.com/video"
def test_parse_single_track_metadata_missing_url(self, basic_karaoke_prep):
def test_parse_single_track_metadata_missing_url(self, basic_karaoke_gen):
"""Test parsing metadata with missing URL."""
basic_karaoke_prep.extracted_info = {
basic_karaoke_gen.extracted_info = {
"title": "Test Artist - Test Title",
"extractor_key": "Youtube",
"id": "12345"
}
with pytest.raises(Exception, match="Failed to extract URL from input media metadata"):
basic_karaoke_prep.parse_single_track_metadata(None, None)
basic_karaoke_gen.parse_single_track_metadata(None, None)
def test_parse_single_track_metadata_missing_extractor(self, basic_karaoke_prep):
def test_parse_single_track_metadata_missing_extractor(self, basic_karaoke_gen):
"""Test parsing metadata with missing extractor."""
basic_karaoke_prep.extracted_info = {
basic_karaoke_gen.extracted_info = {
"title": "Test Artist - Test Title",
"id": "12345",
"url": "https://example.com/video"
}
with pytest.raises(Exception, match="Failed to find extractor name from input media metadata"):
basic_karaoke_prep.parse_single_track_metadata(None, None)
basic_karaoke_gen.parse_single_track_metadata(None, None)
def test_parse_single_track_metadata_with_uploader(self, basic_karaoke_prep):
def test_parse_single_track_metadata_with_uploader(self, basic_karaoke_gen):
"""Test parsing metadata with uploader as artist fallback."""
basic_karaoke_prep.extracted_info = {
basic_karaoke_gen.extracted_info = {
"title": "Test Title", # No artist in title
"extractor_key": "Youtube",
"id": "12345",
@@ -227,18 +227,18 @@ class TestMetadata:
"uploader": "Test Uploader"
}
basic_karaoke_prep.parse_single_track_metadata(None, None)
basic_karaoke_gen.parse_single_track_metadata(None, None)
assert basic_karaoke_prep.artist == "Test Uploader"
assert basic_karaoke_prep.title == "Test Title"
assert basic_karaoke_gen.artist == "Test Uploader"
assert basic_karaoke_gen.title == "Test Title"
def test_parse_single_track_metadata_missing_artist_title(self, basic_karaoke_prep):
def test_parse_single_track_metadata_missing_artist_title(self, basic_karaoke_gen):
"""Test parsing metadata with missing artist and title."""
basic_karaoke_prep.extracted_info = {
basic_karaoke_gen.extracted_info = {
"extractor_key": "Youtube",
"id": "12345",
"url": "https://example.com/video"
}
with pytest.raises(Exception, match="Failed to extract artist and title from the input media metadata"):
basic_karaoke_prep.parse_single_track_metadata(None, None)
basic_karaoke_gen.parse_single_track_metadata(None, None)
+48 -48
View File
@@ -3,10 +3,10 @@ import pytest
from unittest.mock import MagicMock, patch, call, mock_open
from PIL import Image, ImageDraw, ImageFont
import json
from karaoke_prep.karaoke_prep import KaraokePrep
from karaoke_gen.karaoke_gen import KaraokePrep
class TestVideo:
def test_create_video_with_defaults(self, basic_karaoke_prep, temp_dir):
def test_create_video_with_defaults(self, basic_karaoke_gen, temp_dir):
"""Test creating a video with default parameters."""
# Setup
output_image_filepath_noext = os.path.join(temp_dir, "output")
@@ -37,11 +37,11 @@ class TestVideo:
mock_draw.return_value = mock_draw_obj
# Call the method
basic_karaoke_prep.video_generator.create_video(
basic_karaoke_gen.video_generator.create_video(
extra_text="Extra Text",
title_text="Test Title",
artist_text="Test Artist",
format=basic_karaoke_prep.title_format,
format=basic_karaoke_gen.title_format,
output_image_filepath_noext=output_image_filepath_noext,
output_video_filepath=output_video_filepath,
duration=5
@@ -55,7 +55,7 @@ class TestVideo:
# Verify os.system was called (access the patch object directly)
# Note: os.system is patched within the 'with' block, so we access it there
# We can't assert call_count directly on basic_karaoke_prep._os_system
# We can't assert call_count directly on basic_karaoke_gen._os_system
# Instead, we rely on the patch context manager
# Let's verify the call arguments if possible, or just that it was called.
# Since os.system is patched without assigning to a variable, we check its call count via the patcher object if needed,
@@ -65,7 +65,7 @@ class TestVideo:
# Let's refine the assertion later if needed, for now, ensure the TypeError is gone.
pass # Original assertion was incorrect, removing for now.
def test_create_video_with_existing_image(self, basic_karaoke_prep, temp_dir):
def test_create_video_with_existing_image(self, basic_karaoke_gen, temp_dir):
"""Test creating a video with an existing image."""
# Setup
existing_image = os.path.join(temp_dir, "existing.png")
@@ -87,11 +87,11 @@ class TestVideo:
mock_image.mode = "RGBA"
# Call the method
basic_karaoke_prep.video_generator.create_video(
basic_karaoke_gen.video_generator.create_video(
extra_text=None,
title_text=None,
artist_text=None,
format=basic_karaoke_prep.title_format,
format=basic_karaoke_gen.title_format,
output_image_filepath_noext=output_image_filepath_noext,
output_video_filepath=output_video_filepath,
existing_image=existing_image,
@@ -104,7 +104,7 @@ class TestVideo:
# Verify os.system was called to create the video
mock_os_system.assert_called_once() # Check the patch object directly
def test_create_video_with_background_image(self, basic_karaoke_prep, temp_dir):
def test_create_video_with_background_image(self, basic_karaoke_gen, temp_dir):
"""Test creating a video with a background image."""
# Setup
background_image = os.path.join(temp_dir, "background.png")
@@ -116,7 +116,7 @@ class TestVideo:
f.write("mock background image content")
# Create a format with background image
format = basic_karaoke_prep.title_format.copy()
format = basic_karaoke_gen.title_format.copy()
format["background_image"] = background_image
# Mock dependencies
@@ -143,7 +143,7 @@ class TestVideo:
mock_draw.return_value = mock_draw_obj
# Call the method
basic_karaoke_prep.video_generator.create_video(
basic_karaoke_gen.video_generator.create_video(
extra_text="Extra Text",
title_text="Test Title",
artist_text="Test Artist",
@@ -162,11 +162,11 @@ class TestVideo:
# Verify os.system was called to create the video
mock_os_system.assert_called_once() # Check the patch object
def test_create_video_with_no_output_images(self, basic_karaoke_prep, temp_dir):
def test_create_video_with_no_output_images(self, basic_karaoke_gen, temp_dir):
"""Test creating a video without saving output images."""
# Setup
# Re-init KaraokePrep with specific output flags for this test
kp_no_images = KaraokePrep(logger=basic_karaoke_prep.logger, output_png=False, output_jpg=False)
kp_no_images = KaraokePrep(logger=basic_karaoke_gen.logger, output_png=False, output_jpg=False)
output_image_filepath_noext = os.path.join(temp_dir, "output")
output_video_filepath = os.path.join(temp_dir, "output.mov")
@@ -198,7 +198,7 @@ class TestVideo:
extra_text="Extra Text",
title_text="Test Title",
artist_text="Test Artist",
format=basic_karaoke_prep.title_format,
format=basic_karaoke_gen.title_format,
output_image_filepath_noext=output_image_filepath_noext,
output_video_filepath=output_video_filepath,
duration=5
@@ -210,7 +210,7 @@ class TestVideo:
# Verify os.system was called to create the video
mock_os_system.assert_called_once() # Check the patch object
def test_create_video_with_zero_duration(self, basic_karaoke_prep, temp_dir):
def test_create_video_with_zero_duration(self, basic_karaoke_gen, temp_dir):
"""Test creating a video with zero duration (no video, just images)."""
# Setup
output_image_filepath_noext = os.path.join(temp_dir, "output")
@@ -239,11 +239,11 @@ class TestVideo:
mock_draw.return_value = mock_draw_obj
# Call the method
basic_karaoke_prep.video_generator.create_video(
basic_karaoke_gen.video_generator.create_video(
extra_text="Extra Text",
title_text="Test Title",
artist_text="Test Artist",
format=basic_karaoke_prep.title_format,
format=basic_karaoke_gen.title_format,
output_image_filepath_noext=output_image_filepath_noext,
output_video_filepath=output_video_filepath,
duration=0
@@ -255,95 +255,95 @@ class TestVideo:
# Verify os.system was not called to create the video
mock_os_system.assert_not_called() # Check the patch object
def test_create_title_video(self, basic_karaoke_prep, temp_dir):
def test_create_title_video(self, basic_karaoke_gen, temp_dir):
"""Test creating a title video."""
# Setup
output_image_filepath_noext = os.path.join(temp_dir, "output")
output_video_filepath = os.path.join(temp_dir, "output.mov")
# Mock dependencies
with patch.object(basic_karaoke_prep.video_generator, 'create_video') as mock_create_video:
with patch.object(basic_karaoke_gen.video_generator, 'create_video') as mock_create_video:
# Call the method
basic_karaoke_prep.video_generator.create_title_video(
basic_karaoke_gen.video_generator.create_title_video(
artist="Test Artist",
title="Test Title",
format=basic_karaoke_prep.title_format,
format=basic_karaoke_gen.title_format,
output_image_filepath_noext=output_image_filepath_noext,
output_video_filepath=output_video_filepath,
existing_title_image=basic_karaoke_prep.existing_title_image,
intro_video_duration=basic_karaoke_prep.intro_video_duration
existing_title_image=basic_karaoke_gen.existing_title_image,
intro_video_duration=basic_karaoke_gen.intro_video_duration
)
# Verify create_video was called with transformed text and correct duration
mock_create_video.assert_called_once_with(
title_text="Test Title",
artist_text="Test Artist",
extra_text=basic_karaoke_prep.title_format["extra_text"],
format=basic_karaoke_prep.title_format,
extra_text=basic_karaoke_gen.title_format["extra_text"],
format=basic_karaoke_gen.title_format,
output_image_filepath_noext=output_image_filepath_noext,
output_video_filepath=output_video_filepath,
existing_image=basic_karaoke_prep.existing_title_image,
duration=basic_karaoke_prep.intro_video_duration,
existing_image=basic_karaoke_gen.existing_title_image,
duration=basic_karaoke_gen.intro_video_duration,
)
def test_create_end_video(self, basic_karaoke_prep, temp_dir):
def test_create_end_video(self, basic_karaoke_gen, temp_dir):
"""Test creating an end video."""
# Setup
output_image_filepath_noext = os.path.join(temp_dir, "output")
output_video_filepath = os.path.join(temp_dir, "output.mov")
# Mock dependencies
with patch.object(basic_karaoke_prep.video_generator, 'create_video') as mock_create_video:
with patch.object(basic_karaoke_gen.video_generator, 'create_video') as mock_create_video:
# Call the method
basic_karaoke_prep.video_generator.create_end_video(
basic_karaoke_gen.video_generator.create_end_video(
artist="Test Artist",
title="Test Title",
format=basic_karaoke_prep.end_format,
format=basic_karaoke_gen.end_format,
output_image_filepath_noext=output_image_filepath_noext,
output_video_filepath=output_video_filepath,
existing_end_image=basic_karaoke_prep.existing_end_image,
end_video_duration=basic_karaoke_prep.end_video_duration
existing_end_image=basic_karaoke_gen.existing_end_image,
end_video_duration=basic_karaoke_gen.end_video_duration
)
# Verify create_video was called with transformed text and correct duration
mock_create_video.assert_called_once_with(
title_text="Test Title",
artist_text="Test Artist",
extra_text=basic_karaoke_prep.end_format["extra_text"],
format=basic_karaoke_prep.end_format,
extra_text=basic_karaoke_gen.end_format["extra_text"],
format=basic_karaoke_gen.end_format,
output_image_filepath_noext=output_image_filepath_noext,
output_video_filepath=output_video_filepath,
existing_image=basic_karaoke_prep.existing_end_image,
duration=basic_karaoke_prep.end_video_duration,
existing_image=basic_karaoke_gen.existing_end_image,
duration=basic_karaoke_gen.end_video_duration,
)
def test_hex_to_rgb(self, basic_karaoke_prep):
def test_hex_to_rgb(self, basic_karaoke_gen):
"""Test converting hex color to RGB tuple."""
# Test with hash prefix
assert basic_karaoke_prep.video_generator.hex_to_rgb("#FF0000") == (255, 0, 0)
assert basic_karaoke_gen.video_generator.hex_to_rgb("#FF0000") == (255, 0, 0)
# Test without hash prefix
assert basic_karaoke_prep.video_generator.hex_to_rgb("00FF00") == (0, 255, 0)
assert basic_karaoke_gen.video_generator.hex_to_rgb("00FF00") == (0, 255, 0)
# Test mixed case
assert basic_karaoke_prep.video_generator.hex_to_rgb("0000Ff") == (0, 0, 255)
assert basic_karaoke_gen.video_generator.hex_to_rgb("0000Ff") == (0, 0, 255)
def test_transform_text(self, basic_karaoke_prep):
def test_transform_text(self, basic_karaoke_gen):
"""Test transforming text based on specified type."""
# Test uppercase
assert basic_karaoke_prep.video_generator._transform_text("test", "uppercase") == "TEST"
assert basic_karaoke_gen.video_generator._transform_text("test", "uppercase") == "TEST"
# Test lowercase
assert basic_karaoke_prep.video_generator._transform_text("TEST", "lowercase") == "test"
assert basic_karaoke_gen.video_generator._transform_text("TEST", "lowercase") == "test"
# Test propercase (title)
assert basic_karaoke_prep.video_generator._transform_text("test title", "propercase") == "Test Title"
assert basic_karaoke_gen.video_generator._transform_text("test title", "propercase") == "Test Title"
# Test None
assert basic_karaoke_prep.video_generator._transform_text("test", "none") == "test"
assert basic_karaoke_gen.video_generator._transform_text("test", "none") == "test"
# Test unknown
assert basic_karaoke_prep.video_generator._transform_text("test", "unknown") == "test"
assert basic_karaoke_gen.video_generator._transform_text("test", "unknown") == "test"
# Test None input
assert basic_karaoke_prep.video_generator._transform_text(None, "uppercase") is None
assert basic_karaoke_gen.video_generator._transform_text(None, "uppercase") is None