mirror of
https://github.com/nomadkaraoke/karaoke-gen.git
synced 2026-11-21 13:28:08 +09:00
Compare commits
18
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
398c100785 | ||
|
|
06397b7a60 | ||
|
|
8c283c7987 | ||
|
|
f3f508b563 | ||
|
|
c9c1456dbb | ||
|
|
efa9e85121 | ||
|
|
7c6e6992b9 | ||
|
|
54ecde878f | ||
|
|
aada7c84e7 | ||
|
|
cc76db0c04 | ||
|
|
aa9a6e8659 | ||
|
|
9169e5b4a7 | ||
|
|
9599dd595e | ||
|
|
4775d97d3f | ||
|
|
bd42951779 | ||
|
|
d53d015e72 | ||
|
|
193f8367b8 | ||
|
|
3d3393ab89 |
No files matched your search
@@ -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
|
||||
|
||||
@@ -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
@@ -9,7 +9,7 @@ audio/
|
||||
lyrics/
|
||||
karaoke/
|
||||
tests/outputs
|
||||
|
||||
input
|
||||
|
||||
# Byte-compiled / optimized / DLL files
|
||||
__pycache__/
|
||||
|
||||
+271
@@ -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.
|
||||
@@ -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.
|
||||
@@ -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.
|
||||

|
||||

|
||||

|
||||

|
||||
|
||||
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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -0,0 +1 @@
|
||||
gen.nomadkaraoke.com
|
||||
+141
@@ -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
@@ -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!');
|
||||
@@ -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
@@ -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;
|
||||
}
|
||||
@@ -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.
File renamed without changes.
+8
-1
@@ -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.
File renamed without changes.
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 +0,0 @@
|
||||
from .karaoke_prep import KaraokePrep
|
||||
Generated
+2292
-1523
File diff suppressed because it is too large.
Load diff
+38
-13
@@ -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",
|
||||
]
|
||||
@@ -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
@@ -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 ---")
|
||||
@@ -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."""
|
||||
|
||||
@@ -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
@@ -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
@@ -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
@@ -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."""
|
||||
|
||||
@@ -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
@@ -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()
|
||||
|
||||
|
||||
@@ -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
@@ -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
@@ -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
@@ -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
|
||||
Reference in new issue
Block a user