mirror of
https://github.com/nomadkaraoke/karaoke-gen.git
synced 2026-11-21 21:38:07 +09:00
Compare commits
7
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
4e84fec706 | ||
|
|
12bea3e0e8 | ||
|
|
c61029a9f3 | ||
|
|
c1aee2a680 | ||
|
|
9fa527aa59 | ||
|
|
e641b8e639 | ||
|
|
abaa9b5351 |
No files matched your search
@@ -1,28 +0,0 @@
|
||||
2384d2383
|
||||
< triton = ">=2.0.0,<3"
|
||||
4185d4183
|
||||
< triton = {version = "2.3.1", markers = "platform_system == \"Linux\" and platform_machine == \"x86_64\" and python_version < \"3.12\""}
|
||||
4318,4340d4315
|
||||
< name = "triton"
|
||||
< version = "2.3.1"
|
||||
< description = "A language and compiler for custom Deep Learning operations"
|
||||
< optional = false
|
||||
< python-versions = "*"
|
||||
< files = [
|
||||
< {file = "triton-2.3.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3c84595cbe5e546b1b290d2a58b1494df5a2ef066dd890655e5b8a8a92205c33"},
|
||||
< {file = "triton-2.3.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c9d64ae33bcb3a7a18081e3a746e8cf87ca8623ca13d2c362413ce7a486f893e"},
|
||||
< {file = "triton-2.3.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eaf80e8761a9e3498aa92e7bf83a085b31959c61f5e8ac14eedd018df6fccd10"},
|
||||
< {file = "triton-2.3.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b13bf35a2b659af7159bf78e92798dc62d877aa991de723937329e2d382f1991"},
|
||||
< {file = "triton-2.3.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:63381e35ded3304704ea867ffde3b7cfc42c16a55b3062d41e017ef510433d66"},
|
||||
< {file = "triton-2.3.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1d968264523c7a07911c8fb51b4e0d1b920204dae71491b1fe7b01b62a31e124"},
|
||||
< ]
|
||||
<
|
||||
< [package.dependencies]
|
||||
< filelock = "*"
|
||||
<
|
||||
< [package.extras]
|
||||
< build = ["cmake (>=3.20)", "lit"]
|
||||
< tests = ["autopep8", "flake8", "isort", "numpy", "pytest", "scipy (>=1.7.1)", "torch"]
|
||||
< tutorials = ["matplotlib", "pandas", "tabulate", "torch"]
|
||||
<
|
||||
< [[package]]
|
||||
@@ -17,35 +17,3 @@ jobs:
|
||||
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
|
||||
|
||||
+4
-4
@@ -5,10 +5,10 @@
|
||||
*.mp3
|
||||
|
||||
# Andrew functional adds
|
||||
audio/
|
||||
lyrics/
|
||||
karaoke/
|
||||
tests/outputs
|
||||
/audio/
|
||||
/lyrics/
|
||||
/karaoke/
|
||||
/tests/outputs
|
||||
|
||||
|
||||
# Byte-compiled / optimized / DLL files
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2024 Nomad Karaoke LLC
|
||||
Copyright (c) 2025 Nomad Karaoke LLC
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
|
||||
@@ -27,6 +27,9 @@ karaoke-gen "https://www.youtube.com/watch?v=dQw4w9WgXcQ" "Rick Astley" "Never G
|
||||
|
||||
# Or let it search YouTube for you
|
||||
karaoke-gen "Rick Astley" "Never Gonna Give You Up"
|
||||
|
||||
# Process multiple tracks in bulk from a CSV file
|
||||
karaoke-bulk input.csv --style_params_json=style.json
|
||||
```
|
||||
|
||||
## Workflow Options
|
||||
@@ -82,12 +85,58 @@ karaoke-gen --youtube_client_secrets_file="path/to/client_secret.json" --youtube
|
||||
karaoke-gen --brand_prefix="BRAND" --organised_dir="path/to/Tracks-Organized" "Rick Astley" "Never Gonna Give You Up"
|
||||
```
|
||||
|
||||
## Python API
|
||||
|
||||
Karaoke Gen can also be used as a Python library:
|
||||
|
||||
```python
|
||||
import asyncio
|
||||
from karaoke_gen import KaraokeController, ProjectConfig
|
||||
|
||||
async def generate_karaoke():
|
||||
# Create a configuration
|
||||
config = ProjectConfig(
|
||||
artist="Rick Astley",
|
||||
title="Never Gonna Give You Up",
|
||||
input_media="https://www.youtube.com/watch?v=dQw4w9WgXcQ",
|
||||
output_dir="output",
|
||||
create_track_subfolders=True,
|
||||
)
|
||||
|
||||
# Create a controller
|
||||
controller = KaraokeController(config)
|
||||
|
||||
# Process the track
|
||||
tracks = await controller.process()
|
||||
|
||||
# Print the output files
|
||||
for track in tracks:
|
||||
print(f"Final video: {track.final_video}")
|
||||
|
||||
# Run the async function
|
||||
asyncio.run(generate_karaoke())
|
||||
```
|
||||
|
||||
## Architecture
|
||||
|
||||
Karaoke Gen has a modular architecture with the following components:
|
||||
|
||||
- **Controller**: Orchestrates the entire process
|
||||
- **Services**: Handle specific aspects of the process
|
||||
- **Media Service**: Downloads and extracts media
|
||||
- **Audio Service**: Separates and processes audio
|
||||
- **Lyrics Service**: Fetches and synchronizes lyrics
|
||||
- **Video Service**: Renders video with synchronized lyrics
|
||||
- **Distribution Service**: Organizes and shares the output files
|
||||
- **Utilities**: Common utility functions for file handling, logging, etc.
|
||||
|
||||
## Full Command Reference
|
||||
|
||||
For a complete list of options:
|
||||
|
||||
```bash
|
||||
karaoke-gen --help
|
||||
karaoke-bulk --help
|
||||
```
|
||||
|
||||
## License
|
||||
|
||||
@@ -0,0 +1,20 @@
|
||||
name: karaoke-gen
|
||||
channels:
|
||||
- conda-forge
|
||||
# We want to have a reproducible setup, so we don't want default channels,
|
||||
# which may be different for different users. All required channels should
|
||||
# be listed explicitly here.
|
||||
- nodefaults
|
||||
dependencies:
|
||||
- python>=3.10,<3.12 # or don't specify the version and use the latest stable Python
|
||||
- mamba
|
||||
- pip # pip must be mentioned explicitly, or conda-lock will fail
|
||||
- poetry
|
||||
|
||||
# Non-standard section listing target platforms for conda-lock:
|
||||
platforms:
|
||||
- linux-64
|
||||
- osx-64
|
||||
- win-64
|
||||
- osx-arm64 # Apple Silicon, e.g. M1/M2
|
||||
- linux-aarch64 # Docker on Apple Silicon
|
||||
@@ -0,0 +1,87 @@
|
||||
# Pre-Refactor Finalise Functionality Map
|
||||
|
||||
This document maps the functionality in the original `old_finalise.py` file, organized by major functional areas with specific line ranges.
|
||||
|
||||
## Class Definition and Initialization
|
||||
|
||||
- **Class Definition**: Lines 23-23
|
||||
- **Initialization and Configuration**: Lines 23-140
|
||||
- Logging setup: Lines 46-64
|
||||
- FFmpeg path and command setup: Lines 67-77
|
||||
- Configuration parameters: Lines 79-107
|
||||
- Feature flags: Lines 109-114
|
||||
- File naming conventions: Lines 116-137
|
||||
- Codec detection: Line 129
|
||||
|
||||
## Configuration and Validation
|
||||
|
||||
- **Input Files Validation**: Lines 142-171
|
||||
- **Output Filenames Preparation**: Lines 173-187
|
||||
- **User Interaction Utilities**: Lines 189-210
|
||||
- **Feature Validation**: Lines 212-271
|
||||
|
||||
## YouTube Integration
|
||||
|
||||
- **YouTube Authentication**: Lines 273-292
|
||||
- **YouTube Channel ID Retrieval**: Lines 294-305
|
||||
- **Video Existence Check**: Lines 307-345
|
||||
- **Video Deletion**: Lines 347-364
|
||||
- **Title Handling**: Lines 366-371
|
||||
- **Video Upload**: Lines 373-434
|
||||
|
||||
## Folder Organization and Branding
|
||||
|
||||
- **Brand Code Generation**: Lines 436-454
|
||||
- **Discord Notifications**: Lines 456-460
|
||||
- **File Organization**: Lines 589-607
|
||||
- **Public Share Directory Management**: Lines 609-652
|
||||
- **Remote Sync (rclone)**: Lines 654-668
|
||||
- **Sharing Link Generation**: Lines 682-702
|
||||
- **Existing Brand Code Extraction**: Lines 704-715
|
||||
|
||||
## File Discovery and Processing
|
||||
|
||||
- **With Vocals File Finding**: Lines 462-502
|
||||
- **Instrumental Audio Selection**: Lines 504-562
|
||||
- **Artist and Title Extraction**: Lines 564-587
|
||||
|
||||
## Video Processing (FFmpeg Operations)
|
||||
|
||||
- **Command Execution Wrapper**: Lines 589-596
|
||||
- **Video Remuxing with Instrumental Audio**: Lines 598-606
|
||||
- **MOV to MP4 Conversion**: Lines 608-616
|
||||
- **Lossless MP4 Encoding**: Lines 618-629
|
||||
- **Lossy MP4 Encoding**: Lines 631-639
|
||||
- **MKV Encoding**: Lines 641-649
|
||||
- **720p Version Encoding**: Lines 651-661
|
||||
- **Concatenation Filter Preparation**: Lines 663-675
|
||||
- **Final Video File Creation**: Lines 677-716
|
||||
|
||||
## CDG/TXT Creation (Karaoke File Formats)
|
||||
|
||||
- **CDG ZIP File Creation**: Lines 718-783
|
||||
- **TXT ZIP File Creation**: Lines 785-816
|
||||
|
||||
## Distribution and Notifications
|
||||
|
||||
- **Discord Notification Posting**: Lines 670-680
|
||||
- **Email Integration**: Lines 738-809
|
||||
- Gmail Authentication: Lines 738-757
|
||||
- Email Draft Creation: Lines 759-783
|
||||
- Email Template Testing: Lines 785-797
|
||||
|
||||
## Codec Detection
|
||||
|
||||
- **AAC Codec Detection**: Lines 799-813
|
||||
|
||||
## Main Processing Flow
|
||||
|
||||
- **Process Method (Main Workflow)**: Lines 815-886
|
||||
- Feature validation: Line 821
|
||||
- File discovery: Lines 823-827
|
||||
- Output preparation: Lines 829-830
|
||||
- CDG/TXT creation: Lines 832-835
|
||||
- Video processing: Line 837
|
||||
- Optional features execution: Line 839
|
||||
- Result compilation: Lines 841-861
|
||||
- Email notification: Line 863
|
||||
@@ -0,0 +1,37 @@
|
||||
# -*- mode: python ; coding: utf-8 -*-
|
||||
|
||||
|
||||
a = Analysis(
|
||||
['karaoke_gen/utils/gen_cli.py'],
|
||||
pathex=[],
|
||||
binaries=[('platform/ffmpeg.exe', '.')],
|
||||
datas=[],
|
||||
hiddenimports=[],
|
||||
hookspath=[],
|
||||
hooksconfig={},
|
||||
runtime_hooks=[],
|
||||
excludes=[],
|
||||
noarchive=False,
|
||||
)
|
||||
pyz = PYZ(a.pure)
|
||||
|
||||
exe = EXE(
|
||||
pyz,
|
||||
a.scripts,
|
||||
a.binaries,
|
||||
a.datas,
|
||||
[],
|
||||
name='karaoke-gen',
|
||||
debug=False,
|
||||
bootloader_ignore_signals=False,
|
||||
strip=False,
|
||||
upx=True,
|
||||
upx_exclude=[],
|
||||
runtime_tmpdir=None,
|
||||
console=True,
|
||||
disable_windowed_traceback=False,
|
||||
argv_emulation=False,
|
||||
target_arch=None,
|
||||
codesign_identity=None,
|
||||
entitlements_file=None,
|
||||
)
|
||||
@@ -0,0 +1,209 @@
|
||||
"""
|
||||
Karaoke Generator package.
|
||||
|
||||
This package provides tools for generating karaoke videos with synchronized lyrics.
|
||||
It handles the entire process from downloading audio and lyrics to creating the final
|
||||
video with title screens, synchronized lyrics, and distribution options.
|
||||
"""
|
||||
|
||||
__version__ = "0.50.0"
|
||||
|
||||
# Import core components
|
||||
from karaoke_gen.controller import KaraokeController
|
||||
from karaoke_gen.core import ProjectConfig, Track, KaraokeGenError
|
||||
|
||||
# Import services
|
||||
from karaoke_gen.services import (
|
||||
MainService,
|
||||
AudioService,
|
||||
LyricsService,
|
||||
MediaService,
|
||||
VideoService,
|
||||
DistributionService,
|
||||
)
|
||||
|
||||
# Import utility functions
|
||||
from karaoke_gen.utils import (
|
||||
# Config utilities
|
||||
load_config_file,
|
||||
save_config_file,
|
||||
get_config_value,
|
||||
set_config_value,
|
||||
merge_configs,
|
||||
validate_required_config_keys,
|
||||
get_nested_config_value,
|
||||
set_nested_config_value,
|
||||
|
||||
# File utilities
|
||||
sanitize_filename,
|
||||
ensure_directory_exists,
|
||||
backup_existing_files,
|
||||
file_exists,
|
||||
copy_file,
|
||||
move_file,
|
||||
delete_file,
|
||||
create_zip_file,
|
||||
execute_command,
|
||||
|
||||
# Logging utilities
|
||||
setup_logger,
|
||||
get_log_level_from_string,
|
||||
configure_logger_from_config,
|
||||
log_section,
|
||||
log_subsection,
|
||||
log_dict,
|
||||
log_exception,
|
||||
|
||||
# Path utilities
|
||||
normalize_path,
|
||||
join_paths,
|
||||
get_absolute_path,
|
||||
get_relative_path,
|
||||
get_parent_directory,
|
||||
get_filename,
|
||||
get_filename_without_extension,
|
||||
get_file_extension,
|
||||
create_directory,
|
||||
delete_directory,
|
||||
list_files,
|
||||
list_directories,
|
||||
get_file_info,
|
||||
find_files_by_extension,
|
||||
copy_directory,
|
||||
move_directory,
|
||||
get_directory_size,
|
||||
|
||||
# String utilities
|
||||
slugify,
|
||||
truncate_string,
|
||||
extract_artist_and_title,
|
||||
format_duration,
|
||||
format_filesize,
|
||||
strip_html_tags,
|
||||
normalize_whitespace,
|
||||
extract_urls,
|
||||
replace_placeholders,
|
||||
generate_random_string,
|
||||
|
||||
# Validation utilities
|
||||
is_url,
|
||||
is_file,
|
||||
is_directory,
|
||||
prompt_user_confirmation_or_raise_exception,
|
||||
prompt_user_bool,
|
||||
validate_input_parameters_for_features,
|
||||
|
||||
# Date utilities
|
||||
get_current_timestamp,
|
||||
get_current_date,
|
||||
get_current_time,
|
||||
format_date,
|
||||
parse_date,
|
||||
get_date_components,
|
||||
add_days,
|
||||
days_between,
|
||||
is_date_in_range,
|
||||
get_month_name,
|
||||
get_day_of_week,
|
||||
)
|
||||
|
||||
__all__ = [
|
||||
# Version
|
||||
"__version__",
|
||||
|
||||
# Core components
|
||||
"KaraokeController",
|
||||
"ProjectConfig",
|
||||
"Track",
|
||||
"KaraokeGenError",
|
||||
|
||||
# Services
|
||||
"MainService",
|
||||
"AudioService",
|
||||
"LyricsService",
|
||||
"MediaService",
|
||||
"VideoService",
|
||||
"DistributionService",
|
||||
|
||||
# Config utilities
|
||||
"load_config_file",
|
||||
"save_config_file",
|
||||
"get_config_value",
|
||||
"set_config_value",
|
||||
"merge_configs",
|
||||
"validate_required_config_keys",
|
||||
"get_nested_config_value",
|
||||
"set_nested_config_value",
|
||||
|
||||
# File utilities
|
||||
"sanitize_filename",
|
||||
"ensure_directory_exists",
|
||||
"backup_existing_files",
|
||||
"file_exists",
|
||||
"copy_file",
|
||||
"move_file",
|
||||
"delete_file",
|
||||
"create_zip_file",
|
||||
"execute_command",
|
||||
|
||||
# Logging utilities
|
||||
"setup_logger",
|
||||
"get_log_level_from_string",
|
||||
"configure_logger_from_config",
|
||||
"log_section",
|
||||
"log_subsection",
|
||||
"log_dict",
|
||||
"log_exception",
|
||||
|
||||
# Path utilities
|
||||
"normalize_path",
|
||||
"join_paths",
|
||||
"get_absolute_path",
|
||||
"get_relative_path",
|
||||
"get_parent_directory",
|
||||
"get_filename",
|
||||
"get_filename_without_extension",
|
||||
"get_file_extension",
|
||||
"create_directory",
|
||||
"delete_directory",
|
||||
"list_files",
|
||||
"list_directories",
|
||||
"get_file_info",
|
||||
"find_files_by_extension",
|
||||
"copy_directory",
|
||||
"move_directory",
|
||||
"get_directory_size",
|
||||
|
||||
# String utilities
|
||||
"slugify",
|
||||
"truncate_string",
|
||||
"extract_artist_and_title",
|
||||
"format_duration",
|
||||
"format_filesize",
|
||||
"strip_html_tags",
|
||||
"normalize_whitespace",
|
||||
"extract_urls",
|
||||
"replace_placeholders",
|
||||
"generate_random_string",
|
||||
|
||||
# Validation utilities
|
||||
"is_url",
|
||||
"is_file",
|
||||
"is_directory",
|
||||
"prompt_user_confirmation_or_raise_exception",
|
||||
"prompt_user_bool",
|
||||
"validate_input_parameters_for_features",
|
||||
|
||||
# Date utilities
|
||||
"get_current_timestamp",
|
||||
"get_current_date",
|
||||
"get_current_time",
|
||||
"format_date",
|
||||
"parse_date",
|
||||
"get_date_components",
|
||||
"add_days",
|
||||
"days_between",
|
||||
"is_date_in_range",
|
||||
"get_month_name",
|
||||
"get_day_of_week",
|
||||
]
|
||||
@@ -0,0 +1,8 @@
|
||||
"""
|
||||
Main entry point for the karaoke generator.
|
||||
"""
|
||||
|
||||
from karaoke_gen.cli import main
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,35 @@
|
||||
"""
|
||||
Command-line interface module for the karaoke_gen package.
|
||||
|
||||
This module provides the command-line interface for the karaoke generator.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
from typing import Dict, Any
|
||||
|
||||
from karaoke_gen.cli.parser import parse_args, create_parser
|
||||
from karaoke_gen.cli.commands import execute_command, get_command, Command, ProcessCommand, TestEmailTemplateCommand, BulkProcessCommand
|
||||
|
||||
__all__ = [
|
||||
"main",
|
||||
"parse_args",
|
||||
"create_parser",
|
||||
"execute_command",
|
||||
"get_command",
|
||||
"Command",
|
||||
"ProcessCommand",
|
||||
"TestEmailTemplateCommand",
|
||||
"BulkProcessCommand",
|
||||
]
|
||||
|
||||
|
||||
def main() -> None:
|
||||
"""
|
||||
Main entry point for the CLI.
|
||||
"""
|
||||
args = parse_args()
|
||||
asyncio.run(execute_command(args))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,8 @@
|
||||
"""
|
||||
Main entry point for running the CLI as a module.
|
||||
"""
|
||||
|
||||
from karaoke_gen.cli import main
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,339 @@
|
||||
#!/usr/bin/env python
|
||||
import argparse
|
||||
import logging
|
||||
import pkg_resources
|
||||
import os
|
||||
import csv
|
||||
import asyncio
|
||||
import json
|
||||
import sys
|
||||
from typing import Dict, Any, List
|
||||
|
||||
from karaoke_gen.core.project import ProjectConfig
|
||||
from karaoke_gen.core.track import Track
|
||||
from karaoke_gen.controller import KaraokeController
|
||||
from karaoke_gen.utils.logging import setup_logger
|
||||
|
||||
# Global logger
|
||||
logger = logging.getLogger(__name__)
|
||||
logger.setLevel(logging.INFO) # Set initial log level
|
||||
|
||||
|
||||
async def process_track_prep(row: Dict[str, str], args: Dict[str, Any], log_formatter: logging.Formatter) -> bool:
|
||||
"""
|
||||
First phase: Process a track through prep stage only, without video rendering.
|
||||
|
||||
Args:
|
||||
row: The CSV row containing track information
|
||||
args: The parsed command-line arguments
|
||||
log_formatter: The log formatter to use
|
||||
|
||||
Returns:
|
||||
True if processing was successful, False otherwise
|
||||
"""
|
||||
original_dir = os.getcwd()
|
||||
try:
|
||||
artist = row["Artist"].strip()
|
||||
title = row["Title"].strip()
|
||||
guide_file = row["Mixed Audio Filename"].strip()
|
||||
instrumental_file = row["Instrumental Audio Filename"].strip()
|
||||
|
||||
logger.info(f"Initial prep phase for track: {artist} - {title}")
|
||||
|
||||
# Create configuration
|
||||
config = ProjectConfig(
|
||||
# Basic inputs
|
||||
artist=artist,
|
||||
title=title,
|
||||
input_media=guide_file,
|
||||
existing_instrumental=instrumental_file,
|
||||
|
||||
# Workflow control
|
||||
prep_only=True, # Only run prep phase
|
||||
render_video=False, # No video rendering in first phase
|
||||
|
||||
# Logging & Debugging
|
||||
logger=logger,
|
||||
log_level=args.get("log_level", logging.INFO),
|
||||
log_formatter=log_formatter,
|
||||
dry_run=args.get("dry_run", False),
|
||||
|
||||
# Input/Output Configuration
|
||||
output_dir=args.get("output_dir", "."),
|
||||
create_track_subfolders=True,
|
||||
|
||||
# Style Configuration
|
||||
style_params_json=args.get("style_params_json"),
|
||||
)
|
||||
|
||||
# Create controller and process
|
||||
controller = KaraokeController(config)
|
||||
tracks = await controller.process()
|
||||
|
||||
return True
|
||||
except Exception as e:
|
||||
logger.error(f"Failed initial prep for {artist} - {title}: {str(e)}")
|
||||
return False
|
||||
finally:
|
||||
os.chdir(original_dir)
|
||||
|
||||
|
||||
async def process_track_render(row: Dict[str, str], args: Dict[str, Any], log_formatter: logging.Formatter) -> bool:
|
||||
"""
|
||||
Second phase: Re-run prep with video rendering and run finalise.
|
||||
|
||||
Args:
|
||||
row: The CSV row containing track information
|
||||
args: The parsed command-line arguments
|
||||
log_formatter: The log formatter to use
|
||||
|
||||
Returns:
|
||||
True if processing was successful, False otherwise
|
||||
"""
|
||||
original_dir = os.getcwd()
|
||||
try:
|
||||
artist = row["Artist"].strip()
|
||||
title = row["Title"].strip()
|
||||
guide_file = row["Mixed Audio Filename"].strip()
|
||||
instrumental_file = row["Instrumental Audio Filename"].strip()
|
||||
|
||||
logger.info(f"Render phase for track: {artist} - {title}")
|
||||
|
||||
# Create configuration for the render phase
|
||||
config = ProjectConfig(
|
||||
# Basic inputs
|
||||
artist=artist,
|
||||
title=title,
|
||||
input_media=guide_file,
|
||||
existing_instrumental=instrumental_file,
|
||||
|
||||
# Workflow control
|
||||
render_video=True,
|
||||
skip_transcription_review=True,
|
||||
|
||||
# Logging & Debugging
|
||||
logger=logger,
|
||||
log_level=args.get("log_level", logging.INFO),
|
||||
log_formatter=log_formatter,
|
||||
dry_run=args.get("dry_run", False),
|
||||
|
||||
# Input/Output Configuration
|
||||
output_dir=args.get("output_dir", "."),
|
||||
create_track_subfolders=True,
|
||||
|
||||
# Style Configuration
|
||||
style_params_json=args.get("style_params_json"),
|
||||
|
||||
# Finalisation Configuration
|
||||
enable_cdg=args.get("enable_cdg", False),
|
||||
enable_txt=args.get("enable_txt", False),
|
||||
brand_prefix=args.get("brand_prefix"),
|
||||
organised_dir=args.get("organised_dir"),
|
||||
organised_dir_rclone_root=args.get("organised_dir_rclone_root"),
|
||||
public_share_dir=args.get("public_share_dir"),
|
||||
youtube_client_secrets_file=args.get("youtube_client_secrets_file"),
|
||||
youtube_description_file=args.get("youtube_description_file"),
|
||||
rclone_destination=args.get("rclone_destination"),
|
||||
discord_webhook_url=args.get("discord_webhook_url"),
|
||||
email_template_file=args.get("email_template_file"),
|
||||
non_interactive=True, # Always run in non-interactive mode for bulk processing
|
||||
)
|
||||
|
||||
# Create controller and process
|
||||
controller = KaraokeController(config)
|
||||
tracks = await controller.process()
|
||||
|
||||
logger.info(f"Successfully completed auto processing for: {artist} - {title}")
|
||||
return True
|
||||
except Exception as e:
|
||||
logger.error(f"Failed render/finalise for {artist} - {title}: {str(e)}")
|
||||
return False
|
||||
finally:
|
||||
os.chdir(original_dir)
|
||||
|
||||
|
||||
def update_csv_status(csv_path: str, row_index: int, new_status: str) -> None:
|
||||
"""
|
||||
Update the status of a processed row in the CSV file.
|
||||
|
||||
Args:
|
||||
csv_path: The path to the CSV file
|
||||
row_index: The index of the row to update
|
||||
new_status: The new status to set
|
||||
"""
|
||||
# Read all rows
|
||||
with open(csv_path, "r") as f:
|
||||
rows = list(csv.DictReader(f))
|
||||
|
||||
# Update status for the processed row
|
||||
rows[row_index]["Status"] = new_status
|
||||
|
||||
# Write back to CSV
|
||||
fieldnames = rows[0].keys()
|
||||
with open(csv_path, "w", newline="") as f:
|
||||
writer = csv.DictWriter(f, fieldnames=fieldnames)
|
||||
writer.writeheader()
|
||||
writer.writerows(rows)
|
||||
|
||||
|
||||
async def async_main() -> None:
|
||||
"""
|
||||
Main async function for bulk processing.
|
||||
"""
|
||||
parser = argparse.ArgumentParser(
|
||||
description="Process multiple karaoke tracks in bulk from a CSV file.",
|
||||
formatter_class=lambda prog: argparse.RawTextHelpFormatter(prog, max_help_position=54),
|
||||
)
|
||||
|
||||
# Basic information
|
||||
parser.add_argument(
|
||||
"input_csv",
|
||||
help="Path to CSV file containing tracks to process. CSV should have columns: Artist,Title,Mixed Audio Filename,Instrumental Audio Filename,Status",
|
||||
)
|
||||
|
||||
package_version = pkg_resources.get_distribution("karaoke-gen").version
|
||||
parser.add_argument("-v", "--version", action="version", version=f"%(prog)s {package_version}")
|
||||
|
||||
# Required arguments
|
||||
parser.add_argument(
|
||||
"--style_params_json",
|
||||
required=True,
|
||||
help="Path to style parameters JSON file",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--output_dir",
|
||||
default=".",
|
||||
help="Optional: directory to write output files (default: <current dir>). Example: --output_dir=/app/karaoke",
|
||||
)
|
||||
|
||||
# Finalise-specific arguments
|
||||
parser.add_argument(
|
||||
"--enable_cdg",
|
||||
action="store_true",
|
||||
help="Optional: Enable CDG ZIP generation during finalisation. Example: --enable_cdg",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--enable_txt",
|
||||
action="store_true",
|
||||
help="Optional: Enable TXT ZIP generation during finalisation. Example: --enable_txt",
|
||||
)
|
||||
|
||||
# Distribution-specific arguments
|
||||
parser.add_argument(
|
||||
"--brand_prefix",
|
||||
help="Optional: Your brand prefix to calculate the next sequential number. Example: --brand_prefix=BRAND",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--organised_dir",
|
||||
help="Optional: Target directory where the processed folder will be moved. Example: --organised_dir='/path/to/Tracks-Organized'",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--organised_dir_rclone_root",
|
||||
help="Optional: Rclone path which maps to your organised_dir. Example: --organised_dir_rclone_root='dropbox:Media/Karaoke/Tracks-Organized'",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--public_share_dir",
|
||||
help="Optional: Public share directory for final files. Example: --public_share_dir='/path/to/Tracks-PublicShare'",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--youtube_client_secrets_file",
|
||||
help="Optional: Path to youtube client secrets file. Example: --youtube_client_secrets_file='/path/to/client_secret.json'",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--youtube_description_file",
|
||||
help="Optional: Path to youtube description template. Example: --youtube_description_file='/path/to/description.txt'",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--rclone_destination",
|
||||
help="Optional: Rclone destination for public_share_dir sync. Example: --rclone_destination='googledrive:KaraokeFolder'",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--discord_webhook_url",
|
||||
help="Optional: Discord webhook URL for notifications. Example: --discord_webhook_url='https://discord.com/api/webhooks/...'",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--email_template_file",
|
||||
help="Optional: Path to email template file. Example: --email_template_file='/path/to/template.txt'",
|
||||
)
|
||||
|
||||
# Logging & Debugging
|
||||
parser.add_argument(
|
||||
"--log_level",
|
||||
default="info",
|
||||
help="Optional: logging level, e.g. info, debug, warning (default: %(default)s). Example: --log_level=debug",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--dry_run",
|
||||
action="store_true",
|
||||
help="Optional: perform a dry run without making any changes (default: %(default)s). Example: --dry_run",
|
||||
)
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
# Convert input_csv to absolute path
|
||||
args.input_csv = os.path.abspath(args.input_csv)
|
||||
|
||||
if not os.path.isfile(args.input_csv):
|
||||
logger.error(f"Input CSV file not found: {args.input_csv}")
|
||||
exit(1)
|
||||
|
||||
# Fix: Convert log level to uppercase before getting attribute
|
||||
log_level = getattr(logging, args.log_level.upper())
|
||||
args.log_level = log_level # Store the numeric log level in args
|
||||
|
||||
# Convert args to dictionary for easier access
|
||||
args_dict = vars(args)
|
||||
|
||||
logger.info(f"Starting bulk processing with input CSV: {args.input_csv}")
|
||||
|
||||
# Read CSV
|
||||
with open(args.input_csv, "r") as f:
|
||||
reader = csv.DictReader(f)
|
||||
rows = list(reader)
|
||||
|
||||
# Phase 1: Initial prep for all tracks
|
||||
logger.info("Starting Phase 1: Initial prep for all tracks")
|
||||
for i, row in enumerate(rows):
|
||||
if row["Status"].lower() != "uploaded":
|
||||
logger.info(f"Skipping {row['Artist']} - {row['Title']} (Status: {row['Status']})")
|
||||
continue
|
||||
|
||||
success = await process_track_prep(row, args_dict, log_formatter)
|
||||
if not args.dry_run:
|
||||
if success:
|
||||
update_csv_status(args.input_csv, i, "Prep_Complete")
|
||||
else:
|
||||
update_csv_status(args.input_csv, i, "Prep_Failed")
|
||||
|
||||
# Phase 2: Render and finalise all tracks
|
||||
logger.info("Starting Phase 2: Render and finalise for all tracks")
|
||||
for i, row in enumerate(rows):
|
||||
if row["Status"].lower() not in ["prep_complete", "uploaded"]:
|
||||
logger.info(f"Skipping {row['Artist']} - {row['Title']} (Status: {row['Status']})")
|
||||
continue
|
||||
|
||||
success = await process_track_render(row, args_dict, log_formatter)
|
||||
if not args.dry_run:
|
||||
if success:
|
||||
update_csv_status(args.input_csv, i, "Completed")
|
||||
else:
|
||||
update_csv_status(args.input_csv, i, "Render_Failed")
|
||||
|
||||
|
||||
def main() -> None:
|
||||
"""
|
||||
Main entry point for bulk processing.
|
||||
"""
|
||||
# Set up logging only once
|
||||
global log_formatter # Make log_formatter accessible to other functions
|
||||
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)
|
||||
|
||||
# Run the async main function using asyncio
|
||||
asyncio.run(async_main())
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,441 @@
|
||||
import os
|
||||
import logging
|
||||
import asyncio
|
||||
import time
|
||||
import pyperclip
|
||||
import json
|
||||
import warnings
|
||||
from typing import Dict, Any, List, Optional
|
||||
from abc import ABC, abstractmethod
|
||||
|
||||
from karaoke_gen.core.project import ProjectConfig
|
||||
from karaoke_gen.core.track import Track
|
||||
from karaoke_gen.controller import KaraokeController
|
||||
from karaoke_gen.cli.bulk_cli import async_main as bulk_async_main
|
||||
|
||||
|
||||
class Command(ABC):
|
||||
"""Base class for all commands."""
|
||||
|
||||
@abstractmethod
|
||||
async def execute(self, args: Dict[str, Any]) -> None:
|
||||
"""
|
||||
Execute the command.
|
||||
|
||||
Args:
|
||||
args: The parsed command-line arguments
|
||||
"""
|
||||
pass
|
||||
|
||||
|
||||
class ProcessCommand(Command):
|
||||
"""Command for processing a track or tracks."""
|
||||
|
||||
async def execute(self, args: Dict[str, Any]) -> None:
|
||||
"""
|
||||
Execute the process command.
|
||||
|
||||
Args:
|
||||
args: The parsed command-line arguments
|
||||
"""
|
||||
# Set up logging
|
||||
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)
|
||||
|
||||
log_level = getattr(logging, args.get("log_level", "INFO").upper())
|
||||
logger.setLevel(log_level)
|
||||
|
||||
# Parse input arguments
|
||||
input_media, artist, title, filename_pattern = self._parse_input_args(args, logger)
|
||||
|
||||
# Set up environment variables for lyrics-only mode
|
||||
if args.get("lyrics_only"):
|
||||
args["skip_separation"] = True
|
||||
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")
|
||||
|
||||
# Create configuration
|
||||
config = self._create_config(args, input_media, artist, title, filename_pattern, log_formatter, log_level, logger)
|
||||
|
||||
# Create controller
|
||||
controller = KaraokeController(config)
|
||||
|
||||
# Process tracks
|
||||
tracks = await controller.process()
|
||||
|
||||
# Display results
|
||||
self._display_results(tracks, args, logger)
|
||||
|
||||
def _parse_input_args(self, args: Dict[str, Any], logger: logging.Logger) -> tuple:
|
||||
"""
|
||||
Parse input arguments.
|
||||
|
||||
Args:
|
||||
args: The parsed command-line arguments
|
||||
logger: The logger
|
||||
|
||||
Returns:
|
||||
Tuple of (input_media, artist, title, filename_pattern)
|
||||
"""
|
||||
input_media, artist, title, filename_pattern = None, None, None, None
|
||||
|
||||
if not args.get("args"):
|
||||
logger.error("No input arguments provided")
|
||||
exit(1)
|
||||
|
||||
# Allow 3 forms of positional arguments:
|
||||
# 1. URL or Media File only (may be single track URL, playlist URL, or local file)
|
||||
# 2. Artist and Title only
|
||||
# 3. URL, Artist, and Title
|
||||
if args["args"] and (self._is_url(args["args"][0]) or self._is_file(args["args"][0])):
|
||||
input_media = args["args"][0]
|
||||
if len(args["args"]) > 2:
|
||||
artist = args["args"][1]
|
||||
title = args["args"][2]
|
||||
elif len(args["args"]) > 1:
|
||||
artist = args["args"][1]
|
||||
else:
|
||||
logger.warning("Input media provided without Artist and Title, both will be guessed from title")
|
||||
|
||||
elif os.path.isdir(args["args"][0]):
|
||||
if not args.get("filename_pattern"):
|
||||
logger.error("Filename pattern is required when processing a folder.")
|
||||
exit(1)
|
||||
if len(args["args"]) <= 1:
|
||||
logger.error("Second parameter provided must be Artist name; Artist is required when processing a folder.")
|
||||
exit(1)
|
||||
|
||||
input_media = args["args"][0]
|
||||
artist = args["args"][1]
|
||||
filename_pattern = args.get("filename_pattern")
|
||||
|
||||
elif len(args["args"]) > 1:
|
||||
artist = args["args"][0]
|
||||
title = args["args"][1]
|
||||
logger.warning(f"No input media provided, the top YouTube search result for {artist} - {title} will be used.")
|
||||
|
||||
else:
|
||||
logger.error("Invalid input arguments")
|
||||
exit(1)
|
||||
|
||||
return input_media, artist, title, filename_pattern
|
||||
|
||||
def _is_url(self, string: str) -> bool:
|
||||
"""
|
||||
Check if a string is a URL.
|
||||
|
||||
Args:
|
||||
string: The string to check
|
||||
|
||||
Returns:
|
||||
True if the string is a URL, False otherwise
|
||||
"""
|
||||
return string.startswith("http://") or string.startswith("https://")
|
||||
|
||||
def _is_file(self, string: str) -> bool:
|
||||
"""
|
||||
Check if a string is a file.
|
||||
|
||||
Args:
|
||||
string: The string to check
|
||||
|
||||
Returns:
|
||||
True if the string is a file, False otherwise
|
||||
"""
|
||||
return os.path.isfile(string)
|
||||
|
||||
def _create_config(self, args: Dict[str, Any], input_media: Optional[str], artist: Optional[str],
|
||||
title: Optional[str], filename_pattern: Optional[str], log_formatter: logging.Formatter,
|
||||
log_level: int, logger: logging.Logger) -> ProjectConfig:
|
||||
"""
|
||||
Create a project configuration.
|
||||
|
||||
Args:
|
||||
args: The parsed command-line arguments
|
||||
input_media: The input media
|
||||
artist: The artist
|
||||
title: The title
|
||||
filename_pattern: The filename pattern
|
||||
log_formatter: The log formatter
|
||||
log_level: The log level
|
||||
logger: The logger
|
||||
|
||||
Returns:
|
||||
The project configuration
|
||||
"""
|
||||
# Load CDG styles if CDG generation is enabled
|
||||
cdg_styles = None
|
||||
if args.get("enable_cdg") and args.get("style_params_json"):
|
||||
try:
|
||||
with open(args.get("style_params_json"), "r") as f:
|
||||
style_params = json.loads(f.read())
|
||||
cdg_styles = style_params.get("cdg")
|
||||
except FileNotFoundError:
|
||||
logger.error(f"CDG styles configuration file not found: {args.get('style_params_json')}")
|
||||
exit(1)
|
||||
except json.JSONDecodeError as e:
|
||||
logger.error(f"Invalid JSON in CDG styles configuration file: {e}")
|
||||
exit(1)
|
||||
|
||||
return ProjectConfig(
|
||||
# Basic inputs
|
||||
input_media=input_media,
|
||||
artist=artist,
|
||||
title=title,
|
||||
filename_pattern=filename_pattern,
|
||||
|
||||
# Workflow control
|
||||
prep_only=args.get("prep_only", False),
|
||||
finalise_only=args.get("finalise_only", False),
|
||||
skip_transcription=args.get("skip_transcription", False),
|
||||
skip_separation=args.get("skip_separation", False),
|
||||
skip_lyrics=args.get("skip_lyrics", False),
|
||||
lyrics_only=args.get("lyrics_only", False),
|
||||
edit_lyrics=args.get("edit_lyrics", False),
|
||||
|
||||
# Logging & Debugging
|
||||
dry_run=args.get("dry_run", False),
|
||||
logger=logger,
|
||||
log_level=log_level,
|
||||
log_formatter=log_formatter,
|
||||
render_bounding_boxes=args.get("render_bounding_boxes", False),
|
||||
|
||||
# Input/Output Configuration
|
||||
output_dir=args.get("output_dir", "."),
|
||||
create_track_subfolders=args.get("no_track_subfolders", True),
|
||||
lossless_output_format=args.get("lossless_output_format", "FLAC"),
|
||||
output_png=args.get("output_png", True),
|
||||
output_jpg=args.get("output_jpg", True),
|
||||
|
||||
# Audio Processing Configuration
|
||||
clean_instrumental_model=args.get("clean_instrumental_model", "model_bs_roformer_ep_317_sdr_12.9755.ckpt"),
|
||||
backing_vocals_models=args.get("backing_vocals_models", ["mel_band_roformer_karaoke_aufr33_viperx_sdr_10.1956.ckpt"]),
|
||||
other_stems_models=args.get("other_stems_models", ["htdemucs_6s.yaml"]),
|
||||
model_file_dir=args.get("model_file_dir", os.path.join(os.path.dirname(os.path.dirname(__file__)), "models")),
|
||||
existing_instrumental=args.get("existing_instrumental"),
|
||||
instrumental_format=args.get("instrumental_format", "flac"),
|
||||
|
||||
# Lyrics Configuration
|
||||
lyrics_artist=args.get("lyrics_artist"),
|
||||
lyrics_title=args.get("lyrics_title"),
|
||||
lyrics_file=args.get("lyrics_file"),
|
||||
skip_transcription_review=args.get("skip_transcription_review", False),
|
||||
subtitle_offset_ms=args.get("subtitle_offset_ms", 0),
|
||||
|
||||
# Style Configuration
|
||||
style_params_json=args.get("style_params_json"),
|
||||
|
||||
# Finalisation Configuration
|
||||
enable_cdg=args.get("enable_cdg", False),
|
||||
enable_txt=args.get("enable_txt", False),
|
||||
brand_prefix=args.get("brand_prefix"),
|
||||
organised_dir=args.get("organised_dir"),
|
||||
organised_dir_rclone_root=args.get("organised_dir_rclone_root"),
|
||||
public_share_dir=args.get("public_share_dir"),
|
||||
youtube_client_secrets_file=args.get("youtube_client_secrets_file"),
|
||||
youtube_description_file=args.get("youtube_description_file"),
|
||||
rclone_destination=args.get("rclone_destination"),
|
||||
discord_webhook_url=args.get("discord_webhook_url"),
|
||||
email_template_file=args.get("email_template_file"),
|
||||
cdg_styles=cdg_styles,
|
||||
keep_brand_code=args.get("keep_brand_code", False),
|
||||
non_interactive=args.get("yes", False),
|
||||
)
|
||||
|
||||
def _display_results(self, tracks: List[Track], args: Dict[str, Any], logger: logging.Logger) -> None:
|
||||
"""
|
||||
Display the results of processing.
|
||||
|
||||
Args:
|
||||
tracks: The processed tracks
|
||||
args: The parsed command-line arguments
|
||||
logger: The logger
|
||||
"""
|
||||
# If prep-only mode, display detailed output
|
||||
if args.get("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
|
||||
if track.separated_audio and "clean_instrumental" in track.separated_audio:
|
||||
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
|
||||
if track.separated_audio and "other_stems" in track.separated_audio:
|
||||
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
|
||||
if track.separated_audio and "backing_vocals" in track.separated_audio:
|
||||
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
|
||||
if track.separated_audio and "combined_instrumentals" in track.separated_audio:
|
||||
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.")
|
||||
return
|
||||
|
||||
# For finalise-only or full workflow, display summary of outputs
|
||||
for track in tracks:
|
||||
logger.info(f"Karaoke processing complete! Output files:")
|
||||
logger.info(f"")
|
||||
logger.info(f"Track: {track.artist} - {track.title}")
|
||||
logger.info(f"")
|
||||
logger.info(f"Working Files:")
|
||||
logger.info(f" Video With Vocals: {track.video_with_vocals}")
|
||||
logger.info(f" Video With Instrumental: {track.video_with_instrumental}")
|
||||
logger.info(f"")
|
||||
logger.info(f"Final Videos:")
|
||||
logger.info(f" Lossless 4K MP4 (PCM): {track.final_video}")
|
||||
logger.info(f" Lossless 4K MKV (FLAC): {track.final_video_mkv}")
|
||||
logger.info(f" Lossy 4K MP4 (AAC): {track.final_video_lossy}")
|
||||
logger.info(f" Lossy 720p MP4 (AAC): {track.final_video_720p}")
|
||||
|
||||
if hasattr(track, "final_karaoke_cdg_zip") or hasattr(track, "final_karaoke_txt_zip"):
|
||||
logger.info(f"")
|
||||
logger.info(f"Karaoke Files:")
|
||||
|
||||
if hasattr(track, "final_karaoke_cdg_zip") and track.final_karaoke_cdg_zip:
|
||||
logger.info(f" CDG+MP3 ZIP: {track.final_karaoke_cdg_zip}")
|
||||
|
||||
if hasattr(track, "final_karaoke_txt_zip") and track.final_karaoke_txt_zip:
|
||||
logger.info(f" TXT+MP3 ZIP: {track.final_karaoke_txt_zip}")
|
||||
|
||||
if hasattr(track, "brand_code") and track.brand_code:
|
||||
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}")
|
||||
|
||||
if (hasattr(track, "youtube_url") and track.youtube_url) or (hasattr(track, "brand_code_dir_sharing_link") and track.brand_code_dir_sharing_link):
|
||||
logger.info(f"")
|
||||
logger.info(f"Sharing:")
|
||||
|
||||
if hasattr(track, "brand_code_dir_sharing_link") and track.brand_code_dir_sharing_link:
|
||||
logger.info(f" Folder Link: {track.brand_code_dir_sharing_link}")
|
||||
try:
|
||||
time.sleep(1) # Brief pause between clipboard operations
|
||||
pyperclip.copy(track.brand_code_dir_sharing_link)
|
||||
logger.info(f" (Folder link copied to clipboard)")
|
||||
except Exception as e:
|
||||
logger.warning(f" Failed to copy folder link to clipboard: {str(e)}")
|
||||
|
||||
if hasattr(track, "youtube_url") and track.youtube_url:
|
||||
logger.info(f" YouTube URL: {track.youtube_url}")
|
||||
try:
|
||||
pyperclip.copy(track.youtube_url)
|
||||
logger.info(f" (YouTube URL copied to clipboard)")
|
||||
except Exception as e:
|
||||
logger.warning(f" Failed to copy YouTube URL to clipboard: {str(e)}")
|
||||
|
||||
|
||||
class TestEmailTemplateCommand(Command):
|
||||
"""Command for testing the email template."""
|
||||
|
||||
async def execute(self, args: Dict[str, Any]) -> None:
|
||||
"""
|
||||
Execute the test email template command.
|
||||
|
||||
Args:
|
||||
args: The parsed command-line arguments
|
||||
"""
|
||||
# Set up logging
|
||||
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)
|
||||
|
||||
log_level = getattr(logging, args.get("log_level", "INFO").upper())
|
||||
logger.setLevel(log_level)
|
||||
|
||||
logger.info("Testing email template functionality...")
|
||||
|
||||
# Create configuration
|
||||
config = ProjectConfig(
|
||||
log_formatter=log_formatter,
|
||||
log_level=log_level,
|
||||
email_template_file=args.get("email_template_file"),
|
||||
)
|
||||
|
||||
# Create controller
|
||||
controller = KaraokeController(config)
|
||||
|
||||
# Test email template
|
||||
await controller.distribution_service._test_email_template()
|
||||
|
||||
|
||||
class BulkProcessCommand(Command):
|
||||
"""Command for bulk processing tracks."""
|
||||
|
||||
async def execute(self, args: Dict[str, Any]) -> None:
|
||||
"""
|
||||
Execute the bulk process command.
|
||||
|
||||
Args:
|
||||
args: The parsed command-line arguments
|
||||
"""
|
||||
# Execute the bulk CLI
|
||||
await bulk_async_main()
|
||||
|
||||
|
||||
def get_command(args: Dict[str, Any]) -> Command:
|
||||
"""
|
||||
Get the appropriate command based on the arguments.
|
||||
|
||||
Args:
|
||||
args: The parsed command-line arguments
|
||||
|
||||
Returns:
|
||||
The command to execute
|
||||
"""
|
||||
if args.get("test_email_template"):
|
||||
return TestEmailTemplateCommand()
|
||||
elif args.get("bulk"):
|
||||
return BulkProcessCommand()
|
||||
else:
|
||||
return ProcessCommand()
|
||||
|
||||
|
||||
async def execute_command(args: Dict[str, Any]) -> None:
|
||||
"""
|
||||
Execute the appropriate command based on the arguments.
|
||||
|
||||
Args:
|
||||
args: The parsed command-line arguments
|
||||
"""
|
||||
command = get_command(args)
|
||||
await command.execute(args)
|
||||
@@ -0,0 +1,287 @@
|
||||
import argparse
|
||||
import logging
|
||||
import pkg_resources
|
||||
import tempfile
|
||||
import os
|
||||
from typing import Dict, Any
|
||||
|
||||
|
||||
def create_parser() -> argparse.ArgumentParser:
|
||||
"""
|
||||
Create the command-line argument parser.
|
||||
|
||||
Returns:
|
||||
The argument parser
|
||||
"""
|
||||
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),
|
||||
)
|
||||
|
||||
# Basic information
|
||||
parser.add_argument(
|
||||
"args",
|
||||
nargs="*",
|
||||
help="[Media or playlist URL] [Artist] [Title] of song to process. If URL is provided, Artist and Title are optional but increase chance of fetching the correct lyrics. If Artist and Title are provided with no URL, the top YouTube search result will be fetched.",
|
||||
)
|
||||
|
||||
package_version = pkg_resources.get_distribution("karaoke-gen").version
|
||||
parser.add_argument("-v", "--version", action="version", version=f"%(prog)s {package_version}")
|
||||
|
||||
# Workflow control
|
||||
workflow_group = parser.add_argument_group("Workflow Control")
|
||||
workflow_group.add_argument(
|
||||
"--prep-only",
|
||||
action="store_true",
|
||||
help="Only run the preparation phase (download audio, lyrics, separate stems, create title screens). Example: --prep-only",
|
||||
)
|
||||
workflow_group.add_argument(
|
||||
"--finalise-only",
|
||||
action="store_true",
|
||||
help="Only run the finalisation phase (remux, encode, organize). Must be run in a directory prepared by the prep phase. Example: --finalise-only",
|
||||
)
|
||||
workflow_group.add_argument(
|
||||
"--bulk",
|
||||
action="store_true",
|
||||
help="Process multiple tracks in bulk from a CSV file. Example: --bulk",
|
||||
)
|
||||
workflow_group.add_argument(
|
||||
"--input_csv",
|
||||
help="Path to CSV file containing tracks to process when using --bulk. CSV should have columns: Artist,Title,Mixed Audio Filename,Instrumental Audio Filename,Status. Example: --input_csv=/path/to/tracks.csv",
|
||||
)
|
||||
workflow_group.add_argument(
|
||||
"--skip-transcription",
|
||||
action="store_true",
|
||||
help="Skip automatic lyrics transcription/synchronization. Use this to fall back to manual syncing. Example: --skip-transcription",
|
||||
)
|
||||
workflow_group.add_argument(
|
||||
"--skip-separation",
|
||||
action="store_true",
|
||||
help="Skip audio separation process. Example: --skip-separation",
|
||||
)
|
||||
workflow_group.add_argument(
|
||||
"--skip-lyrics",
|
||||
action="store_true",
|
||||
help="Skip fetching and processing lyrics. Example: --skip-lyrics",
|
||||
)
|
||||
workflow_group.add_argument(
|
||||
"--lyrics-only",
|
||||
action="store_true",
|
||||
help="Only process lyrics, skipping audio separation and title/end screen generation. Example: --lyrics-only",
|
||||
)
|
||||
workflow_group.add_argument(
|
||||
"--edit-lyrics",
|
||||
action="store_true",
|
||||
help="Edit lyrics of an existing track. This will backup existing outputs, re-run the lyrics transcription process, and update all outputs. Example: --edit-lyrics",
|
||||
)
|
||||
|
||||
# Logging & Debugging
|
||||
debug_group = parser.add_argument_group("Logging & Debugging")
|
||||
debug_group.add_argument(
|
||||
"--log_level",
|
||||
default="info",
|
||||
help="Optional: logging level, e.g. info, debug, warning (default: %(default)s). Example: --log_level=debug",
|
||||
)
|
||||
debug_group.add_argument(
|
||||
"--dry_run",
|
||||
action="store_true",
|
||||
help="Optional: perform a dry run without making any changes. Example: --dry_run",
|
||||
)
|
||||
debug_group.add_argument(
|
||||
"--render_bounding_boxes",
|
||||
action="store_true",
|
||||
help="Optional: render bounding boxes around text regions for debugging. Example: --render_bounding_boxes",
|
||||
)
|
||||
|
||||
# Input/Output Configuration
|
||||
io_group = parser.add_argument_group("Input/Output Configuration")
|
||||
io_group.add_argument(
|
||||
"--filename_pattern",
|
||||
help="Required if processing a folder: Python regex pattern to extract track names from filenames. Must contain a named group 'title'. Example: --filename_pattern='(?P<index>\\d+) - (?P<title>.+).mp3'",
|
||||
)
|
||||
io_group.add_argument(
|
||||
"--output_dir",
|
||||
default=".",
|
||||
help="Optional: directory to write output files (default: <current dir>). Example: --output_dir=/app/karaoke",
|
||||
)
|
||||
io_group.add_argument(
|
||||
"--no_track_subfolders",
|
||||
action="store_false",
|
||||
dest="no_track_subfolders",
|
||||
help="Optional: do NOT create a named subfolder for each track. Example: --no_track_subfolders",
|
||||
)
|
||||
io_group.add_argument(
|
||||
"--lossless_output_format",
|
||||
default="FLAC",
|
||||
help="Optional: lossless output format for separated audio (default: FLAC). Example: --lossless_output_format=WAV",
|
||||
)
|
||||
io_group.add_argument(
|
||||
"--output_png",
|
||||
type=lambda x: (str(x).lower() == "true"),
|
||||
default=True,
|
||||
help="Optional: output PNG format for title and end images (default: %(default)s). Example: --output_png=False",
|
||||
)
|
||||
io_group.add_argument(
|
||||
"--output_jpg",
|
||||
type=lambda x: (str(x).lower() == "true"),
|
||||
default=True,
|
||||
help="Optional: output JPG format for title and end images (default: %(default)s). Example: --output_jpg=False",
|
||||
)
|
||||
|
||||
# Audio Processing Configuration
|
||||
audio_group = parser.add_argument_group("Audio Processing Configuration")
|
||||
audio_group.add_argument(
|
||||
"--clean_instrumental_model",
|
||||
default="model_bs_roformer_ep_317_sdr_12.9755.ckpt",
|
||||
help="Optional: Model for clean instrumental separation (default: %(default)s).",
|
||||
)
|
||||
audio_group.add_argument(
|
||||
"--backing_vocals_models",
|
||||
nargs="+",
|
||||
default=["mel_band_roformer_karaoke_aufr33_viperx_sdr_10.1956.ckpt"],
|
||||
help="Optional: List of models for backing vocals separation (default: %(default)s).",
|
||||
)
|
||||
audio_group.add_argument(
|
||||
"--other_stems_models",
|
||||
nargs="+",
|
||||
default=["htdemucs_6s.yaml"],
|
||||
help="Optional: List of models for other stems separation (default: %(default)s).",
|
||||
)
|
||||
|
||||
default_model_dir_unix = "/tmp/audio-separator-models/"
|
||||
if os.name == "posix" and os.path.exists(default_model_dir_unix):
|
||||
default_model_dir = default_model_dir_unix
|
||||
else:
|
||||
# Use tempfile to get the platform-independent temp directory
|
||||
default_model_dir = os.path.join(tempfile.gettempdir(), "audio-separator-models")
|
||||
|
||||
audio_group.add_argument(
|
||||
"--model_file_dir",
|
||||
default=default_model_dir,
|
||||
help="Optional: model files directory (default: %(default)s). Example: --model_file_dir=/app/models",
|
||||
)
|
||||
audio_group.add_argument(
|
||||
"--existing_instrumental",
|
||||
help="Optional: Path to an existing instrumental audio file. If provided, audio separation will be skipped.",
|
||||
)
|
||||
audio_group.add_argument(
|
||||
"--instrumental_format",
|
||||
default="flac",
|
||||
help="Optional: format / file extension for instrumental track to use for remux (default: %(default)s). Example: --instrumental_format=mp3",
|
||||
)
|
||||
|
||||
# Lyrics Configuration
|
||||
lyrics_group = parser.add_argument_group("Lyrics Configuration")
|
||||
lyrics_group.add_argument(
|
||||
"--lyrics_artist",
|
||||
help="Optional: Override the artist name used for lyrics search. Example: --lyrics_artist='The Beatles'",
|
||||
)
|
||||
lyrics_group.add_argument(
|
||||
"--lyrics_title",
|
||||
help="Optional: Override the song title used for lyrics search. Example: --lyrics_title='Hey Jude'",
|
||||
)
|
||||
lyrics_group.add_argument(
|
||||
"--lyrics_file",
|
||||
help="Optional: Path to a file containing lyrics to use instead of fetching from online. Example: --lyrics_file='/path/to/lyrics.txt'",
|
||||
)
|
||||
lyrics_group.add_argument(
|
||||
"--subtitle_offset_ms",
|
||||
type=int,
|
||||
default=0,
|
||||
help="Optional: Adjust subtitle timing by N milliseconds (+ve delays, -ve advances). Example: --subtitle_offset_ms=500",
|
||||
)
|
||||
lyrics_group.add_argument(
|
||||
"--skip_transcription_review",
|
||||
action="store_true",
|
||||
help="Optional: Skip the review step after transcription. Example: --skip_transcription_review",
|
||||
)
|
||||
|
||||
# Style Configuration
|
||||
style_group = parser.add_argument_group("Style Configuration")
|
||||
style_group.add_argument(
|
||||
"--style_params_json",
|
||||
help="Optional: Path to JSON file containing style configuration. Example: --style_params_json='/path/to/style_params.json'",
|
||||
)
|
||||
|
||||
# Finalisation Configuration
|
||||
finalise_group = parser.add_argument_group("Finalisation Configuration")
|
||||
finalise_group.add_argument(
|
||||
"--enable_cdg",
|
||||
action="store_true",
|
||||
help="Optional: Enable CDG ZIP generation during finalisation. Example: --enable_cdg",
|
||||
)
|
||||
finalise_group.add_argument(
|
||||
"--enable_txt",
|
||||
action="store_true",
|
||||
help="Optional: Enable TXT ZIP generation during finalisation. Example: --enable_txt",
|
||||
)
|
||||
finalise_group.add_argument(
|
||||
"--brand_prefix",
|
||||
help="Optional: Your brand prefix to calculate the next sequential number. Example: --brand_prefix=BRAND",
|
||||
)
|
||||
finalise_group.add_argument(
|
||||
"--organised_dir",
|
||||
help="Optional: Target directory where the processed folder will be moved. Example: --organised_dir='/path/to/Tracks-Organized'",
|
||||
)
|
||||
finalise_group.add_argument(
|
||||
"--organised_dir_rclone_root",
|
||||
help="Optional: Rclone path which maps to your organised_dir. Example: --organised_dir_rclone_root='dropbox:Media/Karaoke/Tracks-Organized'",
|
||||
)
|
||||
finalise_group.add_argument(
|
||||
"--public_share_dir",
|
||||
help="Optional: Public share directory for final files. Example: --public_share_dir='/path/to/Tracks-PublicShare'",
|
||||
)
|
||||
finalise_group.add_argument(
|
||||
"--youtube_client_secrets_file",
|
||||
help="Optional: Path to youtube client secrets file. Example: --youtube_client_secrets_file='/path/to/client_secret.json'",
|
||||
)
|
||||
finalise_group.add_argument(
|
||||
"--youtube_description_file",
|
||||
help="Optional: Path to youtube description template. Example: --youtube_description_file='/path/to/description.txt'",
|
||||
)
|
||||
finalise_group.add_argument(
|
||||
"--rclone_destination",
|
||||
help="Optional: Rclone destination for public_share_dir sync. Example: --rclone_destination='googledrive:KaraokeFolder'",
|
||||
)
|
||||
finalise_group.add_argument(
|
||||
"--discord_webhook_url",
|
||||
help="Optional: Discord webhook URL for notifications. Example: --discord_webhook_url='https://discord.com/api/webhooks/...'",
|
||||
)
|
||||
finalise_group.add_argument(
|
||||
"--email_template_file",
|
||||
help="Optional: Path to email template file. Example: --email_template_file='/path/to/template.txt'",
|
||||
)
|
||||
finalise_group.add_argument(
|
||||
"--keep-brand-code",
|
||||
action="store_true",
|
||||
help="Optional: Use existing brand code from current directory instead of generating new one. Example: --keep-brand-code",
|
||||
)
|
||||
finalise_group.add_argument(
|
||||
"-y",
|
||||
"--yes",
|
||||
action="store_true",
|
||||
help="Optional: Run in non-interactive mode, assuming yes to all prompts. Example: -y",
|
||||
)
|
||||
finalise_group.add_argument(
|
||||
"--test_email_template",
|
||||
action="store_true",
|
||||
help="Optional: Test the email template functionality with fake data. Example: --test_email_template",
|
||||
)
|
||||
|
||||
return parser
|
||||
|
||||
|
||||
def parse_args() -> Dict[str, Any]:
|
||||
"""
|
||||
Parse command-line arguments.
|
||||
|
||||
Returns:
|
||||
Dictionary of parsed arguments
|
||||
"""
|
||||
parser = create_parser()
|
||||
args = parser.parse_args()
|
||||
|
||||
# Convert args to dictionary
|
||||
args_dict = vars(args)
|
||||
|
||||
return args_dict
|
||||
@@ -0,0 +1,273 @@
|
||||
import asyncio
|
||||
import logging
|
||||
import os
|
||||
from typing import List, Optional
|
||||
|
||||
from karaoke_gen.core.project import ProjectConfig
|
||||
from karaoke_gen.core.track import Track
|
||||
from karaoke_gen.core.exceptions import KaraokeGenError
|
||||
|
||||
|
||||
class KaraokeController:
|
||||
"""
|
||||
Main controller for the karaoke generation process.
|
||||
This class orchestrates the entire workflow by delegating to specialized services.
|
||||
"""
|
||||
|
||||
def __init__(self, config: ProjectConfig):
|
||||
"""
|
||||
Initialize the controller with the given configuration.
|
||||
|
||||
Args:
|
||||
config: The project configuration
|
||||
"""
|
||||
self.config = config
|
||||
self.logger = config.logger or logging.getLogger(__name__)
|
||||
|
||||
# Services will be imported and initialized lazily to avoid circular imports
|
||||
self._audio_service = None
|
||||
self._lyrics_service = None
|
||||
self._media_service = None
|
||||
self._video_service = None
|
||||
self._distribution_service = None
|
||||
|
||||
@property
|
||||
def audio_service(self):
|
||||
"""Lazy-loaded audio service"""
|
||||
if self._audio_service is None:
|
||||
from karaoke_gen.services.audio import AudioService
|
||||
self._audio_service = AudioService(self.config)
|
||||
return self._audio_service
|
||||
|
||||
@property
|
||||
def lyrics_service(self):
|
||||
"""Lazy-loaded lyrics service"""
|
||||
if self._lyrics_service is None:
|
||||
from karaoke_gen.services.lyrics import LyricsService
|
||||
self._lyrics_service = LyricsService(self.config)
|
||||
return self._lyrics_service
|
||||
|
||||
@property
|
||||
def media_service(self):
|
||||
"""Lazy-loaded media service"""
|
||||
if self._media_service is None:
|
||||
from karaoke_gen.services.media import MediaService
|
||||
self._media_service = MediaService(self.config)
|
||||
return self._media_service
|
||||
|
||||
@property
|
||||
def video_service(self):
|
||||
"""Lazy-loaded video service"""
|
||||
if self._video_service is None:
|
||||
from karaoke_gen.services.video import VideoService
|
||||
self._video_service = VideoService(self.config)
|
||||
return self._video_service
|
||||
|
||||
@property
|
||||
def distribution_service(self):
|
||||
"""Lazy-loaded distribution service"""
|
||||
if self._distribution_service is None:
|
||||
from karaoke_gen.services.distribution.service import DistributionService
|
||||
self._distribution_service = DistributionService(self.config)
|
||||
return self._distribution_service
|
||||
|
||||
async def process_track(self, track: Track) -> Track:
|
||||
"""
|
||||
Process a single track through the entire workflow.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The processed track with updated information
|
||||
"""
|
||||
self.logger.info(f"Processing track: {track.base_name}")
|
||||
|
||||
try:
|
||||
# Setup output directory
|
||||
track = await self._setup_output_directory(track)
|
||||
|
||||
# Media acquisition and preparation
|
||||
if track.is_url:
|
||||
track = await self.media_service.download_media(track)
|
||||
elif track.is_file:
|
||||
track = await self.media_service.process_media(track)
|
||||
|
||||
# Skip further processing if we're only doing lyrics
|
||||
if self.config.lyrics_only:
|
||||
track = await self.lyrics_service.process_lyrics(track)
|
||||
return track
|
||||
|
||||
# Audio processing (if not skipped)
|
||||
if not self.config.skip_separation:
|
||||
track = await self.audio_service.separate_audio(track)
|
||||
|
||||
# Lyrics processing (if not skipped)
|
||||
if not self.config.skip_lyrics:
|
||||
track = await self.lyrics_service.process_lyrics(track)
|
||||
|
||||
# Video generation
|
||||
track = await self.video_service.process_video(track)
|
||||
|
||||
# Distribution (if not prep_only)
|
||||
if not self.config.prep_only:
|
||||
track = await self.distribution_service.distribute(track)
|
||||
|
||||
self.logger.info(f"Successfully processed track: {track.base_name}")
|
||||
return track
|
||||
|
||||
except KaraokeGenError as e:
|
||||
self.logger.error(f"Error processing track {track.base_name}: {str(e)}")
|
||||
raise
|
||||
|
||||
async def _setup_output_directory(self, track: Track) -> Track:
|
||||
"""
|
||||
Set up the output directory for the track.
|
||||
|
||||
Args:
|
||||
track: The track to set up the output directory for
|
||||
|
||||
Returns:
|
||||
The track with updated output directory information
|
||||
"""
|
||||
if self.config.create_track_subfolders and track.artist and track.title:
|
||||
# Create a subfolder for the track
|
||||
track_dir_name = f"{track.artist} - {track.title}"
|
||||
track_dir_name = self._sanitize_filename(track_dir_name)
|
||||
track_output_dir = os.path.join(self.config.output_dir, track_dir_name)
|
||||
|
||||
# Create the directory if it doesn't exist
|
||||
if not os.path.exists(track_output_dir) and not self.config.dry_run:
|
||||
os.makedirs(track_output_dir, exist_ok=True)
|
||||
self.logger.info(f"Created output directory: {track_output_dir}")
|
||||
else:
|
||||
# Use the output directory directly
|
||||
track_output_dir = self.config.output_dir
|
||||
|
||||
track.track_output_dir = track_output_dir
|
||||
return track
|
||||
|
||||
def _sanitize_filename(self, filename: str) -> str:
|
||||
"""
|
||||
Sanitize a filename by removing invalid characters.
|
||||
|
||||
Args:
|
||||
filename: The filename to sanitize
|
||||
|
||||
Returns:
|
||||
The sanitized filename
|
||||
"""
|
||||
# Replace characters that are invalid in filenames
|
||||
invalid_chars = ['<', '>', ':', '"', '/', '\\', '|', '?', '*']
|
||||
for char in invalid_chars:
|
||||
filename = filename.replace(char, '_')
|
||||
return filename
|
||||
|
||||
async def process_tracks(self, tracks: List[Track] = None) -> List[Track]:
|
||||
"""
|
||||
Process multiple tracks.
|
||||
|
||||
Args:
|
||||
tracks: List of tracks to process. If None, a track will be created from the config.
|
||||
|
||||
Returns:
|
||||
List of processed tracks
|
||||
"""
|
||||
if tracks is None:
|
||||
# Create a track from the configuration
|
||||
track = Track(
|
||||
artist=self.config.artist,
|
||||
title=self.config.title,
|
||||
input_media=self.config.input_media
|
||||
)
|
||||
tracks = [track]
|
||||
|
||||
processed_tracks = []
|
||||
for track in tracks:
|
||||
processed_track = await self.process_track(track)
|
||||
processed_tracks.append(processed_track)
|
||||
|
||||
return processed_tracks
|
||||
|
||||
async def process(self) -> List[Track]:
|
||||
"""
|
||||
Process tracks based on the configuration.
|
||||
This is the main entry point for the controller.
|
||||
|
||||
Returns:
|
||||
List of processed tracks
|
||||
"""
|
||||
# Handle edit lyrics mode
|
||||
if self.config.edit_lyrics:
|
||||
return await self._handle_edit_lyrics_mode()
|
||||
|
||||
# Handle finalise only mode
|
||||
if self.config.finalise_only:
|
||||
return await self._handle_finalise_only_mode()
|
||||
|
||||
# Normal processing
|
||||
return await self.process_tracks()
|
||||
|
||||
async def _handle_edit_lyrics_mode(self) -> List[Track]:
|
||||
"""
|
||||
Handle edit lyrics mode.
|
||||
|
||||
Returns:
|
||||
List of processed tracks
|
||||
"""
|
||||
self.logger.info("Running in edit-lyrics mode...")
|
||||
|
||||
# Get the current directory name to extract artist and title
|
||||
current_dir = os.path.basename(os.getcwd())
|
||||
self.logger.info(f"Current directory: {current_dir}")
|
||||
|
||||
# Extract artist and title from directory name
|
||||
if " - " not in current_dir:
|
||||
raise ValueError("Current directory name does not contain ' - ' separator. Cannot extract artist and title.")
|
||||
|
||||
parts = current_dir.split(" - ")
|
||||
if len(parts) == 2:
|
||||
artist, title = parts
|
||||
elif len(parts) >= 3:
|
||||
# Handle brand code format: "BRAND-XXXX - Artist - Title"
|
||||
artist = parts[1]
|
||||
title = " - ".join(parts[2:])
|
||||
else:
|
||||
raise ValueError(f"Could not parse artist and title from directory name: {current_dir}")
|
||||
|
||||
self.logger.info(f"Extracted artist: {artist}, title: {title}")
|
||||
|
||||
# Create a track
|
||||
track = Track(
|
||||
artist=artist,
|
||||
title=title,
|
||||
track_output_dir=os.getcwd()
|
||||
)
|
||||
|
||||
# Backup existing outputs and get the input audio file
|
||||
track = await self.lyrics_service.backup_and_prepare_for_edit(track)
|
||||
|
||||
# Process lyrics
|
||||
track = await self.lyrics_service.process_lyrics(track)
|
||||
|
||||
# Distribute
|
||||
track = await self.distribution_service.distribute(track, replace_existing=True)
|
||||
|
||||
return [track]
|
||||
|
||||
async def _handle_finalise_only_mode(self) -> List[Track]:
|
||||
"""
|
||||
Handle finalise only mode.
|
||||
|
||||
Returns:
|
||||
List of processed tracks
|
||||
"""
|
||||
self.logger.info("Running in finalise-only mode...")
|
||||
|
||||
# Create a track with the current directory
|
||||
track = Track(track_output_dir=os.getcwd())
|
||||
|
||||
# Distribute
|
||||
track = await self.distribution_service.distribute(track)
|
||||
|
||||
return [track]
|
||||
@@ -0,0 +1,11 @@
|
||||
"""
|
||||
Core module for the karaoke_gen package.
|
||||
|
||||
This module contains the core domain models and exceptions.
|
||||
"""
|
||||
|
||||
from karaoke_gen.core.project import ProjectConfig
|
||||
from karaoke_gen.core.track import Track
|
||||
from karaoke_gen.core.exceptions import KaraokeGenError
|
||||
|
||||
__all__ = ["ProjectConfig", "Track", "KaraokeGenError"]
|
||||
@@ -0,0 +1,83 @@
|
||||
class KaraokeGenError(Exception):
|
||||
"""Base exception for all karaoke generator errors"""
|
||||
pass
|
||||
|
||||
|
||||
class MediaError(KaraokeGenError):
|
||||
"""Exception raised for errors related to media handling"""
|
||||
pass
|
||||
|
||||
|
||||
class DownloadError(MediaError):
|
||||
"""Exception raised when a download fails"""
|
||||
pass
|
||||
|
||||
|
||||
class ConversionError(MediaError):
|
||||
"""Exception raised when a media conversion fails"""
|
||||
pass
|
||||
|
||||
|
||||
class LyricsError(KaraokeGenError):
|
||||
"""Exception raised for errors related to lyrics processing"""
|
||||
pass
|
||||
|
||||
|
||||
class LyricsFetchError(LyricsError):
|
||||
"""Exception raised when lyrics fetching fails"""
|
||||
pass
|
||||
|
||||
|
||||
class TranscriptionError(LyricsError):
|
||||
"""Exception raised when lyrics transcription fails"""
|
||||
pass
|
||||
|
||||
|
||||
class SynchronizationError(LyricsError):
|
||||
"""Exception raised when lyrics synchronization fails"""
|
||||
pass
|
||||
|
||||
|
||||
class FormattingError(LyricsError):
|
||||
"""Exception raised when lyrics formatting fails"""
|
||||
pass
|
||||
|
||||
|
||||
class AudioError(KaraokeGenError):
|
||||
"""Exception raised for errors related to audio processing"""
|
||||
pass
|
||||
|
||||
|
||||
class SeparationError(AudioError):
|
||||
"""Exception raised when audio separation fails"""
|
||||
pass
|
||||
|
||||
|
||||
class NormalizationError(AudioError):
|
||||
"""Exception raised when audio normalization fails"""
|
||||
pass
|
||||
|
||||
|
||||
class VideoError(KaraokeGenError):
|
||||
"""Exception raised for errors related to video processing"""
|
||||
pass
|
||||
|
||||
|
||||
class RenderingError(VideoError):
|
||||
"""Exception raised when video rendering fails"""
|
||||
pass
|
||||
|
||||
|
||||
class DistributionError(KaraokeGenError):
|
||||
"""Exception raised for errors related to distribution"""
|
||||
pass
|
||||
|
||||
|
||||
class YouTubeError(DistributionError):
|
||||
"""Exception raised when YouTube operations fail"""
|
||||
pass
|
||||
|
||||
|
||||
class UserCancellationError(KaraokeGenError):
|
||||
"""Exception raised when the user cancels an operation"""
|
||||
pass
|
||||
@@ -0,0 +1,107 @@
|
||||
from dataclasses import dataclass, field
|
||||
from typing import Dict, List, Optional, Any
|
||||
import logging
|
||||
import os
|
||||
import tempfile
|
||||
|
||||
|
||||
@dataclass
|
||||
class ProjectConfig:
|
||||
"""
|
||||
Configuration for a karaoke generation project.
|
||||
This class holds all the configuration parameters for the karaoke generation process.
|
||||
"""
|
||||
# Basic inputs
|
||||
input_media: Optional[str] = None
|
||||
artist: Optional[str] = None
|
||||
title: Optional[str] = None
|
||||
filename_pattern: Optional[str] = None
|
||||
|
||||
# Workflow control
|
||||
prep_only: bool = False
|
||||
finalise_only: bool = False
|
||||
skip_transcription: bool = False
|
||||
skip_separation: bool = False
|
||||
skip_lyrics: bool = False
|
||||
skip_download: bool = False
|
||||
lyrics_only: bool = False
|
||||
edit_lyrics: bool = False
|
||||
|
||||
# Logging & Debugging
|
||||
dry_run: bool = False
|
||||
logger: Optional[logging.Logger] = None
|
||||
log_level: int = logging.DEBUG
|
||||
log_formatter: Optional[logging.Formatter] = None
|
||||
render_bounding_boxes: bool = False
|
||||
|
||||
# Input/Output Configuration
|
||||
output_dir: str = "."
|
||||
create_track_subfolders: bool = True
|
||||
lossless_output_format: str = "flac"
|
||||
output_png: bool = True
|
||||
output_jpg: bool = True
|
||||
|
||||
# Audio Processing Configuration
|
||||
clean_instrumental_model: str = "model_bs_roformer_ep_317_sdr_12.9755.ckpt"
|
||||
backing_vocals_models: List[str] = field(default_factory=lambda: ["mel_band_roformer_karaoke_aufr33_viperx_sdr_10.1956.ckpt"])
|
||||
other_stems_models: List[str] = field(default_factory=lambda: ["htdemucs_6s.yaml"])
|
||||
model_file_dir: str = field(default_factory=lambda: os.path.join(tempfile.gettempdir(), "audio-separator-models"))
|
||||
existing_instrumental: Optional[str] = None
|
||||
instrumental_format: str = "flac"
|
||||
|
||||
# Lyrics Configuration
|
||||
lyrics_artist: Optional[str] = None
|
||||
lyrics_title: Optional[str] = None
|
||||
lyrics_file: Optional[str] = None
|
||||
skip_transcription_review: bool = False
|
||||
render_video: bool = True
|
||||
subtitle_offset_ms: int = 0
|
||||
|
||||
# Style Configuration
|
||||
style_params_json: Optional[str] = None
|
||||
|
||||
# Video Configuration
|
||||
title_screen_duration: float = 5.0
|
||||
end_screen_duration: float = 5.0
|
||||
title_fade_in: float = 1.0
|
||||
title_fade_out: float = 1.0
|
||||
end_fade_in: float = 1.0
|
||||
end_fade_out: float = 1.0
|
||||
|
||||
# Finalisation Configuration
|
||||
enable_cdg: bool = False
|
||||
enable_txt: bool = False
|
||||
brand_prefix: Optional[str] = None
|
||||
organised_dir: Optional[str] = None
|
||||
organised_dir_rclone_root: Optional[str] = None
|
||||
public_share_dir: Optional[str] = None
|
||||
youtube_client_secrets_file: Optional[str] = None
|
||||
youtube_description_file: Optional[str] = None
|
||||
rclone_destination: Optional[str] = None
|
||||
discord_webhook_url: Optional[str] = None
|
||||
email_template_file: Optional[str] = None
|
||||
cdg_styles: Optional[Dict[str, Any]] = None
|
||||
keep_brand_code: bool = False
|
||||
non_interactive: bool = False
|
||||
|
||||
def __post_init__(self):
|
||||
"""Perform post-initialization setup"""
|
||||
# Set up logger if not provided
|
||||
if self.logger is None:
|
||||
self.logger = logging.getLogger("karaoke_gen")
|
||||
handler = logging.StreamHandler()
|
||||
if self.log_formatter is None:
|
||||
self.log_formatter = logging.Formatter(
|
||||
fmt="%(asctime)s.%(msecs)03d - %(levelname)s - %(module)s - %(message)s",
|
||||
datefmt="%Y-%m-%d %H:%M:%S"
|
||||
)
|
||||
handler.setFormatter(self.log_formatter)
|
||||
self.logger.addHandler(handler)
|
||||
self.logger.setLevel(self.log_level)
|
||||
|
||||
# If lyrics_artist/title not specified, use the main artist/title
|
||||
if self.lyrics_artist is None and self.artist is not None:
|
||||
self.lyrics_artist = self.artist
|
||||
|
||||
if self.lyrics_title is None and self.title is not None:
|
||||
self.lyrics_title = self.title
|
||||
@@ -0,0 +1,116 @@
|
||||
from dataclasses import dataclass, field
|
||||
from typing import Dict, List, Optional, Any
|
||||
import os
|
||||
|
||||
|
||||
@dataclass
|
||||
class Track:
|
||||
"""
|
||||
Represents a track being processed through the karaoke generation pipeline.
|
||||
This class holds all the data related to a single track throughout its lifecycle.
|
||||
"""
|
||||
# Basic track information
|
||||
artist: Optional[str] = None
|
||||
title: Optional[str] = None
|
||||
input_media: Optional[str] = None
|
||||
|
||||
# Media source information
|
||||
extractor: Optional[str] = "Original" # Default to "Original" for local files
|
||||
media_id: Optional[str] = None
|
||||
|
||||
# Paths to generated files
|
||||
track_output_dir: Optional[str] = None
|
||||
input_audio_wav: Optional[str] = None
|
||||
input_still_image: Optional[str] = None
|
||||
|
||||
# Lyrics information
|
||||
lyrics: Optional[str] = None
|
||||
processed_lyrics: Optional[str] = None
|
||||
|
||||
# Separated audio files
|
||||
separated_audio: Dict[str, Any] = field(default_factory=lambda: {
|
||||
"clean_instrumental": {},
|
||||
"other_stems": {},
|
||||
"backing_vocals": {},
|
||||
"combined_instrumentals": {}
|
||||
})
|
||||
|
||||
# Video files
|
||||
title_video: Optional[str] = None
|
||||
end_video: Optional[str] = None
|
||||
video_with_lyrics: Optional[str] = None
|
||||
video_with_instrumental: Optional[str] = None
|
||||
|
||||
# Final output files
|
||||
final_video: Optional[str] = None
|
||||
final_video_mkv: Optional[str] = None
|
||||
final_video_lossy: Optional[str] = None
|
||||
final_video_720p: Optional[str] = None
|
||||
final_karaoke_cdg_zip: Optional[str] = None
|
||||
final_karaoke_txt_zip: Optional[str] = None
|
||||
|
||||
# Distribution information
|
||||
brand_code: Optional[str] = None
|
||||
new_brand_code_dir_path: Optional[str] = None
|
||||
youtube_url: Optional[str] = None
|
||||
brand_code_dir_sharing_link: Optional[str] = None
|
||||
|
||||
# Metadata
|
||||
metadata: Dict[str, Any] = field(default_factory=dict)
|
||||
|
||||
@property
|
||||
def base_name(self) -> str:
|
||||
"""Returns the base name for the track (artist - title)"""
|
||||
if self.artist and self.title:
|
||||
return f"{self.artist} - {self.title}"
|
||||
return os.path.basename(self.input_media) if self.input_media else "unknown"
|
||||
|
||||
@property
|
||||
def is_url(self) -> bool:
|
||||
"""Returns True if the input_media is a URL"""
|
||||
if not self.input_media:
|
||||
return False
|
||||
return self.input_media.startswith("http://") or self.input_media.startswith("https://")
|
||||
|
||||
@property
|
||||
def is_file(self) -> bool:
|
||||
"""Returns True if the input_media is a file"""
|
||||
if not self.input_media:
|
||||
return False
|
||||
return os.path.isfile(self.input_media)
|
||||
|
||||
@property
|
||||
def is_directory(self) -> bool:
|
||||
"""Returns True if the input_media is a directory"""
|
||||
if not self.input_media:
|
||||
return False
|
||||
return os.path.isdir(self.input_media)
|
||||
|
||||
@property
|
||||
def instrumental(self) -> Optional[str]:
|
||||
"""Returns the path to the instrumental audio file"""
|
||||
if self.separated_audio and "clean_instrumental" in self.separated_audio:
|
||||
return self.separated_audio["clean_instrumental"].get("instrumental")
|
||||
return None
|
||||
|
||||
@property
|
||||
def duration(self) -> float:
|
||||
"""Returns the duration of the track in seconds"""
|
||||
if self.metadata and "duration" in self.metadata:
|
||||
return self.metadata["duration"]
|
||||
return 0.0
|
||||
|
||||
@property
|
||||
def audio_file(self) -> Optional[str]:
|
||||
"""Returns the path to the input audio file (WAV)"""
|
||||
return self.input_audio_wav
|
||||
|
||||
@property
|
||||
def wav_file(self) -> Optional[str]:
|
||||
"""Alias for input_audio_wav"""
|
||||
return self.input_audio_wav
|
||||
|
||||
@property
|
||||
def video_with_vocals(self) -> Optional[str]:
|
||||
"""Alias for video_with_lyrics for backward compatibility"""
|
||||
return self.video_with_lyrics
|
||||
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
@@ -0,0 +1,24 @@
|
||||
"""
|
||||
Services module for the karaoke_gen package.
|
||||
|
||||
This module contains the various services used by the karaoke generator.
|
||||
"""
|
||||
|
||||
# Import and re-export service modules
|
||||
from karaoke_gen.services.audio import AudioService
|
||||
from karaoke_gen.services.lyrics import LyricsService
|
||||
from karaoke_gen.services.media import MediaService
|
||||
from karaoke_gen.services.video import VideoService
|
||||
from karaoke_gen.services.distribution import DistributionService
|
||||
|
||||
# Import main service
|
||||
from karaoke_gen.services.main import MainService
|
||||
|
||||
__all__ = [
|
||||
"MainService",
|
||||
"AudioService",
|
||||
"LyricsService",
|
||||
"MediaService",
|
||||
"VideoService",
|
||||
"DistributionService",
|
||||
]
|
||||
@@ -0,0 +1,5 @@
|
||||
from karaoke_gen.services.audio.service import AudioService
|
||||
from karaoke_gen.services.audio.converter import AudioConverter
|
||||
from karaoke_gen.services.audio.separator import AudioSeparator
|
||||
from karaoke_gen.services.audio.normalizer import AudioNormalizer
|
||||
from karaoke_gen.services.audio.mixer import AudioMixer
|
||||
@@ -0,0 +1,91 @@
|
||||
import os
|
||||
import subprocess
|
||||
import asyncio
|
||||
from karaoke_gen.core.track import Track
|
||||
from karaoke_gen.core.exceptions import AudioError
|
||||
|
||||
|
||||
class AudioConverter:
|
||||
"""
|
||||
Handles audio format conversion operations.
|
||||
"""
|
||||
|
||||
def __init__(self, config):
|
||||
"""
|
||||
Initialize the audio converter.
|
||||
|
||||
Args:
|
||||
config: The project configuration
|
||||
"""
|
||||
self.config = config
|
||||
self.logger = config.logger
|
||||
|
||||
# Path to ffmpeg
|
||||
self.ffmpeg_path = "ffmpeg"
|
||||
|
||||
# Set up ffmpeg base command
|
||||
self.ffmpeg_base_command = f"{self.ffmpeg_path} -hide_banner -nostats"
|
||||
|
||||
if self.config.log_level <= 10: # DEBUG
|
||||
self.ffmpeg_base_command += " -loglevel verbose"
|
||||
else:
|
||||
self.ffmpeg_base_command += " -loglevel fatal"
|
||||
|
||||
async def convert_to_wav(self, track):
|
||||
"""
|
||||
Convert the input audio to WAV format.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated audio information
|
||||
"""
|
||||
self.logger.info(f"Converting audio to WAV for {track.base_name}")
|
||||
|
||||
# Determine input file
|
||||
input_file = track.input_media
|
||||
if not os.path.isfile(input_file):
|
||||
raise AudioError(f"Input file not found: {input_file}")
|
||||
|
||||
# Determine output file
|
||||
output_filename_no_extension = os.path.join(
|
||||
track.track_output_dir,
|
||||
f"{track.base_name}"
|
||||
)
|
||||
output_wav = f"{output_filename_no_extension}.wav"
|
||||
|
||||
# Skip if output already exists
|
||||
if os.path.isfile(output_wav):
|
||||
self.logger.info(f"WAV file already exists: {output_wav}")
|
||||
track.input_audio_wav = output_wav
|
||||
return track
|
||||
|
||||
# Build ffmpeg command
|
||||
command = f'{self.ffmpeg_base_command} -i "{input_file}" -vn -acodec pcm_s16le -ar 44100 -ac 2 "{output_wav}"'
|
||||
|
||||
# Execute command
|
||||
if not self.config.dry_run:
|
||||
self.logger.debug(f"Executing command: {command}")
|
||||
try:
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
stdout, stderr = await process.communicate()
|
||||
|
||||
if process.returncode != 0:
|
||||
error_message = stderr.decode() if stderr else "Unknown error"
|
||||
raise AudioError(f"Failed to convert audio to WAV: {error_message}")
|
||||
|
||||
self.logger.info(f"Successfully converted audio to WAV: {output_wav}")
|
||||
track.input_audio_wav = output_wav
|
||||
|
||||
except Exception as e:
|
||||
raise AudioError(f"Failed to convert audio to WAV: {str(e)}") from e
|
||||
else:
|
||||
self.logger.info(f"[DRY RUN] Would convert audio to WAV: {output_wav}")
|
||||
track.input_audio_wav = output_wav
|
||||
|
||||
return track
|
||||
@@ -0,0 +1,283 @@
|
||||
import os
|
||||
import asyncio
|
||||
import subprocess
|
||||
from typing import List, Optional
|
||||
from pydub import AudioSegment
|
||||
from karaoke_gen.core.track import Track
|
||||
from karaoke_gen.core.exceptions import AudioError
|
||||
|
||||
|
||||
class AudioMixer:
|
||||
"""
|
||||
Handles audio mixing operations.
|
||||
"""
|
||||
|
||||
def __init__(self, config):
|
||||
"""
|
||||
Initialize the audio mixer.
|
||||
|
||||
Args:
|
||||
config: The project configuration
|
||||
"""
|
||||
self.config = config
|
||||
self.logger = config.logger
|
||||
|
||||
# Set up ffmpeg base command
|
||||
self.ffmpeg_base_command = "ffmpeg -hide_banner"
|
||||
if self.config.log_level <= 10: # DEBUG
|
||||
self.ffmpeg_base_command += " -loglevel verbose"
|
||||
else:
|
||||
self.ffmpeg_base_command += " -loglevel fatal"
|
||||
|
||||
async def mix_audio_files(self, input_files: List[str], output_file: str, weights: Optional[List[float]] = None):
|
||||
"""
|
||||
Mix multiple audio files into a single output file.
|
||||
|
||||
Args:
|
||||
input_files: List of input audio file paths
|
||||
output_file: Output file path
|
||||
weights: Optional list of weights for each input file (default: equal weights)
|
||||
|
||||
Returns:
|
||||
The path to the mixed audio file
|
||||
"""
|
||||
self.logger.info(f"Mixing {len(input_files)} audio files into {output_file}")
|
||||
|
||||
# Validate inputs
|
||||
if not input_files:
|
||||
raise AudioError("No input files provided for mixing")
|
||||
|
||||
for input_file in input_files:
|
||||
if not os.path.isfile(input_file):
|
||||
raise AudioError(f"Input file not found: {input_file}")
|
||||
|
||||
# Set default weights if not provided
|
||||
if weights is None:
|
||||
weights = [1.0] * len(input_files)
|
||||
|
||||
# Ensure weights match input files
|
||||
if len(weights) != len(input_files):
|
||||
raise AudioError(f"Number of weights ({len(weights)}) does not match number of input files ({len(input_files)})")
|
||||
|
||||
# Build ffmpeg command
|
||||
input_args = " ".join([f'-i "{input_file}"' for input_file in input_files])
|
||||
weight_str = " ".join([str(w) for w in weights])
|
||||
|
||||
filter_complex = f'"'
|
||||
for i in range(len(input_files)):
|
||||
filter_complex += f"[{i}:a]"
|
||||
filter_complex += f"amix=inputs={len(input_files)}:duration=longest:weights={weight_str}[outa]"
|
||||
filter_complex += f'"'
|
||||
|
||||
output_format = os.path.splitext(output_file)[1][1:].lower()
|
||||
if not output_format:
|
||||
output_format = self.config.lossless_output_format.lower()
|
||||
|
||||
ffmpeg_command = (
|
||||
f'{self.ffmpeg_base_command} {input_args} '
|
||||
f'-filter_complex {filter_complex} '
|
||||
f'-map "[outa]" -c:a {output_format} "{output_file}"'
|
||||
)
|
||||
|
||||
# Execute command
|
||||
if not self.config.dry_run:
|
||||
self.logger.debug(f"Running command: {ffmpeg_command}")
|
||||
|
||||
try:
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
ffmpeg_command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
|
||||
stdout, stderr = await process.communicate()
|
||||
|
||||
if process.returncode != 0:
|
||||
error_message = stderr.decode() if stderr else "Unknown error"
|
||||
raise AudioError(f"Failed to mix audio files: {error_message}")
|
||||
|
||||
self.logger.info(f"Successfully mixed audio files to {output_file}")
|
||||
return output_file
|
||||
|
||||
except Exception as e:
|
||||
raise AudioError(f"Error mixing audio files: {str(e)}") from e
|
||||
else:
|
||||
self.logger.info(f"[DRY RUN] Would mix audio files to {output_file}")
|
||||
return output_file
|
||||
|
||||
async def mix_audio(self, track):
|
||||
"""
|
||||
Mix audio for a track.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated mixed audio information
|
||||
"""
|
||||
self.logger.info(f"Mixing audio for {track.base_name}")
|
||||
|
||||
# Skip if no separated audio
|
||||
if not track.separated_audio["clean_instrumental"].get("instrumental"):
|
||||
self.logger.info("No instrumental available for mixing, skipping")
|
||||
return track
|
||||
|
||||
# Mix instrumental with backing vocals if available
|
||||
if track.separated_audio["backing_vocals"]:
|
||||
for model, paths in track.separated_audio["backing_vocals"].items():
|
||||
if "backing_vocals" not in paths:
|
||||
continue
|
||||
|
||||
instrumental_path = track.separated_audio["clean_instrumental"]["instrumental"]
|
||||
backing_vocals_path = paths["backing_vocals"]
|
||||
|
||||
output_path = os.path.join(
|
||||
track.track_output_dir,
|
||||
f"{track.base_name} (Karaoke Mix {model}).{self.config.lossless_output_format.lower()}"
|
||||
)
|
||||
|
||||
# Skip if output already exists
|
||||
if os.path.isfile(output_path):
|
||||
self.logger.info(f"Mixed audio for model {model} already exists")
|
||||
track.metadata[f"karaoke_mix_{model}"] = output_path
|
||||
continue
|
||||
|
||||
# Mix files
|
||||
try:
|
||||
mixed_path = await self.mix_audio_files(
|
||||
[instrumental_path, backing_vocals_path],
|
||||
output_path,
|
||||
weights=[1.0, 0.8] # Slightly reduce backing vocals volume
|
||||
)
|
||||
|
||||
track.metadata[f"karaoke_mix_{model}"] = mixed_path
|
||||
self.logger.info(f"Created karaoke mix for model {model}")
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to create karaoke mix for model {model}: {str(e)}")
|
||||
|
||||
return track
|
||||
|
||||
async def generate_combined_instrumentals(self, track, stems_dir):
|
||||
"""
|
||||
Generate combined instrumental tracks by mixing different stems.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
stems_dir: The directory containing stems
|
||||
|
||||
Returns:
|
||||
The track with updated audio information
|
||||
"""
|
||||
self.logger.info(f"Generating combined instrumentals for {track.base_name}")
|
||||
|
||||
# Skip if no clean instrumental
|
||||
if not track.separated_audio.get("clean_instrumental", {}).get("instrumental"):
|
||||
self.logger.info("No clean instrumental available, skipping combined instrumentals")
|
||||
track.separated_audio["combined_instrumentals"] = {}
|
||||
return track
|
||||
|
||||
# Initialize combined instrumentals
|
||||
track.separated_audio["combined_instrumentals"] = {}
|
||||
|
||||
# Get clean instrumental path
|
||||
instrumental_path = track.separated_audio["clean_instrumental"]["instrumental"]
|
||||
|
||||
# Get backing vocals path if available
|
||||
backing_vocals_path = None
|
||||
for model_name, stems in track.separated_audio.get("backing_vocals", {}).items():
|
||||
if stems.get("backing_vocals"):
|
||||
backing_vocals_path = stems["backing_vocals"]
|
||||
break
|
||||
|
||||
# Generate instrumental with backing vocals if available
|
||||
if backing_vocals_path:
|
||||
output_path = os.path.join(
|
||||
stems_dir,
|
||||
f"{track.base_name} (Instrumental with Backing Vocals).{self.config.lossless_output_format.lower()}"
|
||||
)
|
||||
|
||||
# Skip if output already exists
|
||||
if os.path.isfile(output_path):
|
||||
self.logger.info(f"Instrumental with backing vocals already exists: {output_path}")
|
||||
track.separated_audio["combined_instrumentals"]["instrumental_with_backing_vocals"] = output_path
|
||||
else:
|
||||
# Mix instrumental and backing vocals
|
||||
if not self.config.dry_run:
|
||||
try:
|
||||
await self._mix_audio_files(
|
||||
[instrumental_path, backing_vocals_path],
|
||||
output_path
|
||||
)
|
||||
track.separated_audio["combined_instrumentals"]["instrumental_with_backing_vocals"] = output_path
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to mix instrumental with backing vocals: {str(e)}")
|
||||
else:
|
||||
self.logger.info(f"[DRY RUN] Would mix instrumental with backing vocals: {output_path}")
|
||||
track.separated_audio["combined_instrumentals"]["instrumental_with_backing_vocals"] = output_path
|
||||
|
||||
# Generate other combined instrumentals from demucs stems if available
|
||||
demucs_stems = {}
|
||||
for model_name, stems in track.separated_audio.get("other_stems", {}).items():
|
||||
if "demucs" in model_name.lower():
|
||||
demucs_stems = stems
|
||||
break
|
||||
|
||||
if demucs_stems:
|
||||
# Mix drums + bass + other (no vocals)
|
||||
if all(stem in demucs_stems for stem in ["drums", "bass", "other"]):
|
||||
output_path = os.path.join(
|
||||
stems_dir,
|
||||
f"{track.base_name} (Demucs Instrumental).{self.config.lossless_output_format.lower()}"
|
||||
)
|
||||
|
||||
# Skip if output already exists
|
||||
if os.path.isfile(output_path):
|
||||
self.logger.info(f"Demucs instrumental already exists: {output_path}")
|
||||
track.separated_audio["combined_instrumentals"]["demucs_instrumental"] = output_path
|
||||
else:
|
||||
# Mix drums, bass, and other
|
||||
if not self.config.dry_run:
|
||||
try:
|
||||
await self._mix_audio_files(
|
||||
[demucs_stems["drums"], demucs_stems["bass"], demucs_stems["other"]],
|
||||
output_path
|
||||
)
|
||||
track.separated_audio["combined_instrumentals"]["demucs_instrumental"] = output_path
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to mix demucs instrumental: {str(e)}")
|
||||
else:
|
||||
self.logger.info(f"[DRY RUN] Would mix demucs instrumental: {output_path}")
|
||||
track.separated_audio["combined_instrumentals"]["demucs_instrumental"] = output_path
|
||||
|
||||
return track
|
||||
|
||||
async def _mix_audio_files(self, input_paths, output_path):
|
||||
"""
|
||||
Mix multiple audio files together.
|
||||
|
||||
Args:
|
||||
input_paths: List of input audio file paths
|
||||
output_path: Output audio file path
|
||||
|
||||
Returns:
|
||||
True if successful, False otherwise
|
||||
"""
|
||||
try:
|
||||
# Load first audio file
|
||||
mixed = AudioSegment.from_file(input_paths[0])
|
||||
|
||||
# Mix in additional audio files
|
||||
for path in input_paths[1:]:
|
||||
audio = AudioSegment.from_file(path)
|
||||
mixed = mixed.overlay(audio)
|
||||
|
||||
# Export mixed audio
|
||||
mixed.export(output_path, format=os.path.splitext(output_path)[1][1:])
|
||||
|
||||
self.logger.info(f"Successfully mixed audio files: {output_path}")
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to mix audio files: {str(e)}")
|
||||
raise AudioError(f"Failed to mix audio files: {str(e)}") from e
|
||||
@@ -0,0 +1,308 @@
|
||||
import os
|
||||
import asyncio
|
||||
import subprocess
|
||||
from pydub import AudioSegment
|
||||
from karaoke_gen.core.track import Track
|
||||
from karaoke_gen.core.exceptions import AudioError
|
||||
|
||||
|
||||
class AudioNormalizer:
|
||||
"""
|
||||
Handles audio normalization operations.
|
||||
"""
|
||||
|
||||
def __init__(self, config):
|
||||
"""
|
||||
Initialize the audio normalizer.
|
||||
|
||||
Args:
|
||||
config: The project configuration
|
||||
"""
|
||||
self.config = config
|
||||
self.logger = config.logger
|
||||
|
||||
# Path to ffmpeg
|
||||
self.ffmpeg_path = "ffmpeg"
|
||||
|
||||
# Set up ffmpeg base command
|
||||
self.ffmpeg_base_command = f"{self.ffmpeg_path} -hide_banner -nostats"
|
||||
|
||||
if self.config.log_level <= 10: # DEBUG
|
||||
self.ffmpeg_base_command += " -loglevel verbose"
|
||||
else:
|
||||
self.ffmpeg_base_command += " -loglevel fatal"
|
||||
|
||||
async def normalize_audio_file(self, input_path, output_path, target_level=0.0):
|
||||
"""
|
||||
Normalize an audio file to a target level.
|
||||
|
||||
Args:
|
||||
input_path: The input audio file path
|
||||
output_path: The output audio file path
|
||||
target_level: The target level in dB (default: 0.0)
|
||||
|
||||
Returns:
|
||||
The path to the normalized audio file
|
||||
"""
|
||||
self.logger.info(f"Normalizing audio file: {input_path}")
|
||||
|
||||
# Validate input
|
||||
if not os.path.isfile(input_path):
|
||||
raise AudioError(f"Input file not found: {input_path}")
|
||||
|
||||
if os.path.getsize(input_path) == 0:
|
||||
raise AudioError(f"Input file is empty: {input_path}")
|
||||
|
||||
# Skip if dry run
|
||||
if self.config.dry_run:
|
||||
self.logger.info(f"[DRY RUN] Would normalize audio file: {input_path}")
|
||||
return output_path
|
||||
|
||||
try:
|
||||
# Load audio file
|
||||
audio = AudioSegment.from_file(input_path)
|
||||
|
||||
# Calculate the peak amplitude
|
||||
peak_amplitude = float(audio.max_dBFS)
|
||||
|
||||
# Calculate the necessary gain
|
||||
gain_db = target_level - peak_amplitude
|
||||
|
||||
# Apply gain
|
||||
normalized_audio = audio.apply_gain(gain_db)
|
||||
|
||||
# Ensure the audio is not completely silent
|
||||
if normalized_audio.rms == 0:
|
||||
self.logger.warning(f"Normalized audio is silent for {input_path}. Using original audio.")
|
||||
normalized_audio = audio
|
||||
|
||||
# Export normalized audio
|
||||
normalized_audio.export(
|
||||
output_path,
|
||||
format=self.config.lossless_output_format.lower()
|
||||
)
|
||||
|
||||
self.logger.info(f"Normalized audio saved to: {output_path}")
|
||||
self.logger.debug(f"Original peak: {peak_amplitude} dB, Applied gain: {gain_db} dB")
|
||||
|
||||
return output_path
|
||||
|
||||
except Exception as e:
|
||||
raise AudioError(f"Failed to normalize audio file: {str(e)}") from e
|
||||
|
||||
async def normalize_audio(self, track):
|
||||
"""
|
||||
Normalize audio for a track.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with normalized audio
|
||||
"""
|
||||
self.logger.info(f"Normalizing audio for {track.base_name}")
|
||||
|
||||
files_to_normalize = []
|
||||
|
||||
# Add clean instrumental
|
||||
if track.separated_audio["clean_instrumental"].get("instrumental"):
|
||||
files_to_normalize.append(
|
||||
("clean_instrumental", track.separated_audio["clean_instrumental"]["instrumental"])
|
||||
)
|
||||
|
||||
# Add combined instrumentals
|
||||
for model, path in track.separated_audio["combined_instrumentals"].items():
|
||||
files_to_normalize.append(("combined_instrumentals", path))
|
||||
|
||||
# Add karaoke mixes
|
||||
for key, path in track.metadata.items():
|
||||
if key.startswith("karaoke_mix_") and os.path.isfile(path):
|
||||
files_to_normalize.append(("karaoke_mix", path))
|
||||
|
||||
# Skip if no files to normalize
|
||||
if not files_to_normalize:
|
||||
self.logger.info("No files to normalize, skipping")
|
||||
return track
|
||||
|
||||
# Normalize each file
|
||||
for key, file_path in files_to_normalize:
|
||||
if os.path.isfile(file_path):
|
||||
try:
|
||||
# Normalize in-place
|
||||
await self.normalize_audio_file(file_path, file_path)
|
||||
|
||||
# Verify the normalized file
|
||||
if os.path.getsize(file_path) > 0:
|
||||
self.logger.info(f"Successfully normalized: {file_path}")
|
||||
else:
|
||||
raise AudioError("Normalized file is empty")
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Error during normalization of {file_path}: {e}")
|
||||
self.logger.warning(f"Normalization failed for {file_path}. Original file remains unchanged.")
|
||||
else:
|
||||
self.logger.warning(f"File not found for normalization: {file_path}")
|
||||
|
||||
self.logger.info("Audio normalization process completed")
|
||||
return track
|
||||
|
||||
async def normalize_audio_files(self, track):
|
||||
"""
|
||||
Normalize all separated audio files.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated audio information
|
||||
"""
|
||||
self.logger.info(f"Normalizing audio files for {track.base_name}")
|
||||
|
||||
# Skip if no separated audio
|
||||
if not track.separated_audio:
|
||||
self.logger.info("No separated audio to normalize")
|
||||
return track
|
||||
|
||||
# Normalize clean instrumental
|
||||
if track.separated_audio.get("clean_instrumental"):
|
||||
instrumental_path = track.separated_audio["clean_instrumental"].get("instrumental")
|
||||
if instrumental_path and os.path.isfile(instrumental_path):
|
||||
normalized_path = self._get_normalized_path(instrumental_path)
|
||||
await self._normalize_audio(instrumental_path, normalized_path)
|
||||
track.separated_audio["clean_instrumental"]["instrumental"] = normalized_path
|
||||
|
||||
vocals_path = track.separated_audio["clean_instrumental"].get("vocals")
|
||||
if vocals_path and os.path.isfile(vocals_path):
|
||||
normalized_path = self._get_normalized_path(vocals_path)
|
||||
await self._normalize_audio(vocals_path, normalized_path)
|
||||
track.separated_audio["clean_instrumental"]["vocals"] = normalized_path
|
||||
|
||||
# Normalize backing vocals
|
||||
for model_name, stems in track.separated_audio.get("backing_vocals", {}).items():
|
||||
lead_vocals_path = stems.get("lead_vocals")
|
||||
if lead_vocals_path and os.path.isfile(lead_vocals_path):
|
||||
normalized_path = self._get_normalized_path(lead_vocals_path)
|
||||
await self._normalize_audio(lead_vocals_path, normalized_path)
|
||||
track.separated_audio["backing_vocals"][model_name]["lead_vocals"] = normalized_path
|
||||
|
||||
backing_vocals_path = stems.get("backing_vocals")
|
||||
if backing_vocals_path and os.path.isfile(backing_vocals_path):
|
||||
normalized_path = self._get_normalized_path(backing_vocals_path)
|
||||
await self._normalize_audio(backing_vocals_path, normalized_path)
|
||||
track.separated_audio["backing_vocals"][model_name]["backing_vocals"] = normalized_path
|
||||
|
||||
# Normalize other stems
|
||||
for model_name, stems in track.separated_audio.get("other_stems", {}).items():
|
||||
for stem_name, stem_path in stems.items():
|
||||
if stem_path and os.path.isfile(stem_path):
|
||||
normalized_path = self._get_normalized_path(stem_path)
|
||||
await self._normalize_audio(stem_path, normalized_path)
|
||||
track.separated_audio["other_stems"][model_name][stem_name] = normalized_path
|
||||
|
||||
# Normalize combined instrumentals
|
||||
for name, path in track.separated_audio.get("combined_instrumentals", {}).items():
|
||||
if path and os.path.isfile(path):
|
||||
normalized_path = self._get_normalized_path(path)
|
||||
await self._normalize_audio(path, normalized_path)
|
||||
track.separated_audio["combined_instrumentals"][name] = normalized_path
|
||||
|
||||
return track
|
||||
|
||||
def _get_normalized_path(self, input_path):
|
||||
"""
|
||||
Get the path for the normalized audio file.
|
||||
|
||||
Args:
|
||||
input_path: The input audio file path
|
||||
|
||||
Returns:
|
||||
The path for the normalized audio file
|
||||
"""
|
||||
# Replace extension with .normalized.ext
|
||||
base, ext = os.path.splitext(input_path)
|
||||
return f"{base}.normalized{ext}"
|
||||
|
||||
async def _normalize_audio(self, input_path, output_path, target_level=-14.0):
|
||||
"""
|
||||
Normalize an audio file to a target loudness level.
|
||||
|
||||
Args:
|
||||
input_path: The input audio file path
|
||||
output_path: The output audio file path
|
||||
target_level: The target loudness level in LUFS
|
||||
|
||||
Returns:
|
||||
True if successful, False otherwise
|
||||
"""
|
||||
# Skip if output already exists
|
||||
if os.path.isfile(output_path):
|
||||
self.logger.debug(f"Normalized audio already exists: {output_path}")
|
||||
return True
|
||||
|
||||
# Skip if input doesn't exist
|
||||
if not os.path.isfile(input_path):
|
||||
self.logger.warning(f"Input audio file not found: {input_path}")
|
||||
return False
|
||||
|
||||
# Build ffmpeg command
|
||||
command = (
|
||||
f'{self.ffmpeg_base_command} -i "{input_path}" '
|
||||
f'-af loudnorm=I={target_level}:TP=-1.0:LRA=11.0:print_format=json '
|
||||
f'-f null -'
|
||||
)
|
||||
|
||||
# Execute command to get loudness stats
|
||||
if not self.config.dry_run:
|
||||
try:
|
||||
self.logger.debug(f"Analyzing audio loudness: {command}")
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
stdout, stderr = await process.communicate()
|
||||
|
||||
if process.returncode != 0:
|
||||
self.logger.error(f"Failed to analyze audio loudness: {stderr.decode()}")
|
||||
return False
|
||||
|
||||
# Extract loudnorm stats from stderr
|
||||
stderr_text = stderr.decode()
|
||||
stats_start = stderr_text.rfind("{")
|
||||
stats_end = stderr_text.rfind("}") + 1
|
||||
|
||||
if stats_start >= 0 and stats_end > stats_start:
|
||||
loudness_stats = stderr_text[stats_start:stats_end]
|
||||
|
||||
# Build second pass command with measured stats
|
||||
command = (
|
||||
f'{self.ffmpeg_base_command} -i "{input_path}" '
|
||||
f'-af loudnorm=I={target_level}:TP=-1.0:LRA=11.0:measured_I={target_level}:measured_TP=-1.0:measured_LRA=11.0:measured_thresh=-25.0:offset=0.0:linear=true:print_format=json '
|
||||
f'"{output_path}"'
|
||||
)
|
||||
|
||||
# Execute second pass command
|
||||
self.logger.debug(f"Normalizing audio: {command}")
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
stdout, stderr = await process.communicate()
|
||||
|
||||
if process.returncode != 0:
|
||||
self.logger.error(f"Failed to normalize audio: {stderr.decode()}")
|
||||
return False
|
||||
|
||||
self.logger.info(f"Successfully normalized audio: {output_path}")
|
||||
return True
|
||||
else:
|
||||
self.logger.error("Failed to extract loudness stats from ffmpeg output")
|
||||
return False
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to normalize audio: {str(e)}")
|
||||
return False
|
||||
else:
|
||||
self.logger.info(f"[DRY RUN] Would normalize audio: {output_path}")
|
||||
return True
|
||||
@@ -0,0 +1,724 @@
|
||||
import os
|
||||
import asyncio
|
||||
import json
|
||||
import time
|
||||
import fcntl
|
||||
import errno
|
||||
import tempfile
|
||||
import shutil
|
||||
from datetime import datetime
|
||||
from karaoke_gen.core.track import Track
|
||||
from karaoke_gen.core.exceptions import AudioError
|
||||
import platform
|
||||
import subprocess
|
||||
import logging
|
||||
from typing import Dict, List, Optional, Any
|
||||
import re
|
||||
|
||||
|
||||
class AudioSeparator:
|
||||
"""
|
||||
Handles audio stem separation operations.
|
||||
"""
|
||||
|
||||
def __init__(self, config):
|
||||
"""
|
||||
Initialize the audio separator.
|
||||
|
||||
Args:
|
||||
config: The project configuration
|
||||
"""
|
||||
self.config = config
|
||||
self.logger = config.logger
|
||||
|
||||
# Initialize separator lazily to avoid circular imports
|
||||
self._separator = None
|
||||
|
||||
@property
|
||||
def separator(self):
|
||||
"""Lazy-loaded separator instance"""
|
||||
if self._separator is None:
|
||||
# Import here to avoid circular imports
|
||||
from audio_separator.separator import Separator
|
||||
|
||||
self._separator = Separator(
|
||||
log_level=self.config.log_level,
|
||||
log_formatter=self.config.log_formatter,
|
||||
model_file_dir=self.config.model_file_dir,
|
||||
output_format=self.config.lossless_output_format,
|
||||
)
|
||||
|
||||
return self._separator
|
||||
|
||||
async def separate_clean_instrumental(self, track, input_audio, stems_dir):
|
||||
"""
|
||||
Separate clean instrumental from a track.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
input_audio: The input audio file
|
||||
stems_dir: The directory to store stems
|
||||
|
||||
Returns:
|
||||
The track with updated audio information
|
||||
"""
|
||||
self.logger.info(f"Separating clean instrumental for {track.base_name}")
|
||||
|
||||
# Skip if existing instrumental is provided
|
||||
if self.config.existing_instrumental:
|
||||
self.logger.info(f"Using existing instrumental: {self.config.existing_instrumental}")
|
||||
track.separated_audio["clean_instrumental"] = {
|
||||
"instrumental": self.config.existing_instrumental,
|
||||
"vocals": None
|
||||
}
|
||||
return track
|
||||
|
||||
# Acquire lock for audio separation
|
||||
with self._acquire_lock(track.base_name):
|
||||
artist_title = track.base_name
|
||||
|
||||
# Define output paths
|
||||
instrumental_path = os.path.join(
|
||||
stems_dir,
|
||||
f"{artist_title} (Clean Instrumental).{self.config.lossless_output_format.lower()}"
|
||||
)
|
||||
vocals_path = os.path.join(
|
||||
stems_dir,
|
||||
f"{artist_title} (Clean Vocals).{self.config.lossless_output_format.lower()}"
|
||||
)
|
||||
|
||||
# Skip if output already exists
|
||||
if os.path.isfile(instrumental_path) and os.path.isfile(vocals_path):
|
||||
self.logger.info(f"Clean instrumental and vocals already exist")
|
||||
track.separated_audio["clean_instrumental"] = {
|
||||
"instrumental": instrumental_path,
|
||||
"vocals": vocals_path
|
||||
}
|
||||
return track
|
||||
|
||||
# Perform separation
|
||||
if not self.config.dry_run:
|
||||
try:
|
||||
self.logger.info(f"Separating clean instrumental using model: {self.config.clean_instrumental_model}")
|
||||
|
||||
# Load model first
|
||||
self.separator.load_model(model_filename=self.config.clean_instrumental_model)
|
||||
|
||||
# Convert input_audio to absolute path
|
||||
input_audio_abs = os.path.abspath(input_audio)
|
||||
|
||||
# Call separate with the absolute path to the audio file
|
||||
output_files = self.separator.separate(input_audio_abs)
|
||||
|
||||
# Process the output files
|
||||
result = {}
|
||||
for file in output_files:
|
||||
# The file path returned by separator.separate()
|
||||
# may already be the full path or just the filename
|
||||
file_name = os.path.basename(file)
|
||||
file_path = file # Use the path as returned by separator
|
||||
|
||||
if "(Vocals)" in file_name:
|
||||
if os.path.exists(file_path) and not os.path.exists(vocals_path):
|
||||
shutil.move(file_path, vocals_path)
|
||||
result["vocals"] = vocals_path
|
||||
elif "(Instrumental)" in file_name:
|
||||
if os.path.exists(file_path) and not os.path.exists(instrumental_path):
|
||||
shutil.move(file_path, instrumental_path)
|
||||
result["instrumental"] = instrumental_path
|
||||
|
||||
# Update track with separation results
|
||||
track.separated_audio["clean_instrumental"] = result
|
||||
|
||||
self.logger.info(f"Successfully separated clean instrumental")
|
||||
|
||||
except Exception as e:
|
||||
raise AudioError(f"Failed to separate clean instrumental: {str(e)}") from e
|
||||
else:
|
||||
self.logger.info(f"[DRY RUN] Would separate clean instrumental")
|
||||
track.separated_audio["clean_instrumental"] = {
|
||||
"instrumental": instrumental_path,
|
||||
"vocals": vocals_path
|
||||
}
|
||||
|
||||
return track
|
||||
|
||||
async def separate_other_stems(self, track, input_audio, stems_dir):
|
||||
"""
|
||||
Separate other stems from the input audio.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
input_audio: The input audio file
|
||||
stems_dir: The directory to store stems
|
||||
|
||||
Returns:
|
||||
The track with updated audio information
|
||||
"""
|
||||
self.logger.info(f"Separating other stems for {track.base_name}")
|
||||
|
||||
# Skip if no models are specified
|
||||
if not self.config.other_stems_models:
|
||||
self.logger.info("No other stems models specified, skipping")
|
||||
track.separated_audio["other_stems"] = {}
|
||||
return track
|
||||
|
||||
# Acquire lock for audio separation
|
||||
with self._acquire_lock(track.base_name):
|
||||
artist_title = track.base_name
|
||||
|
||||
# Initialize results
|
||||
track.separated_audio["other_stems"] = {}
|
||||
|
||||
# Process each model
|
||||
for model_name in self.config.other_stems_models:
|
||||
self.logger.info(f"Separating stems using model: {model_name}")
|
||||
|
||||
# Define output paths based on model
|
||||
if "demucs" in model_name.lower():
|
||||
stems = ["drums", "bass", "other", "vocals"]
|
||||
output_paths = {
|
||||
stem: os.path.join(
|
||||
stems_dir,
|
||||
f"{artist_title} ({stem.capitalize()} {model_name}).{self.config.lossless_output_format.lower()}"
|
||||
) for stem in stems
|
||||
}
|
||||
else:
|
||||
# Default to 2-stem separation
|
||||
stems = ["instrumental", "vocals"]
|
||||
output_paths = {
|
||||
stem: os.path.join(
|
||||
stems_dir,
|
||||
f"{artist_title} ({model_name} {stem.capitalize()}).{self.config.lossless_output_format.lower()}"
|
||||
) for stem in stems
|
||||
}
|
||||
|
||||
# Check if all output files already exist
|
||||
if all(os.path.isfile(path) for path in output_paths.values()):
|
||||
self.logger.info(f"All stems for model {model_name} already exist")
|
||||
track.separated_audio["other_stems"][model_name] = output_paths
|
||||
continue
|
||||
|
||||
# Perform separation
|
||||
if not self.config.dry_run:
|
||||
try:
|
||||
# Load model first
|
||||
self.separator.load_model(model_filename=model_name)
|
||||
|
||||
# Convert input_audio to absolute path
|
||||
input_audio_abs = os.path.abspath(input_audio)
|
||||
|
||||
# Call separate with the absolute path to the audio file
|
||||
output_files = self.separator.separate(input_audio_abs)
|
||||
|
||||
# Process the output files
|
||||
result = {}
|
||||
for file in output_files:
|
||||
# The file path returned by separator.separate()
|
||||
# may already be the full path or just the filename
|
||||
file_name = os.path.basename(file)
|
||||
file_path = file
|
||||
|
||||
if "demucs" in model_name.lower():
|
||||
# Extract stem name from demucs output
|
||||
if "_(Drums)_" in file_name or "_drums." in file_name.lower():
|
||||
stem_path = output_paths["drums"]
|
||||
if os.path.exists(file_path) and not os.path.exists(stem_path):
|
||||
shutil.move(file_path, stem_path)
|
||||
result["drums"] = stem_path
|
||||
elif "_(Bass)_" in file_name or "_bass." in file_name.lower():
|
||||
stem_path = output_paths["bass"]
|
||||
if os.path.exists(file_path) and not os.path.exists(stem_path):
|
||||
shutil.move(file_path, stem_path)
|
||||
result["bass"] = stem_path
|
||||
elif "_(Other)_" in file_name or "_other." in file_name.lower():
|
||||
stem_path = output_paths["other"]
|
||||
if os.path.exists(file_path) and not os.path.exists(stem_path):
|
||||
shutil.move(file_path, stem_path)
|
||||
result["other"] = stem_path
|
||||
elif "_(Vocals)_" in file_name or "_vocals." in file_name.lower():
|
||||
stem_path = output_paths["vocals"]
|
||||
if os.path.exists(file_path) and not os.path.exists(stem_path):
|
||||
shutil.move(file_path, stem_path)
|
||||
result["vocals"] = stem_path
|
||||
elif "_(Guitar)_" in file_name:
|
||||
# For additional stems like guitar and piano, add them to the other stems too
|
||||
stem_name = "guitar"
|
||||
stem_path = os.path.join(
|
||||
stems_dir,
|
||||
f"{artist_title} ({stem_name.capitalize()} {model_name}).{self.config.lossless_output_format.lower()}"
|
||||
)
|
||||
if os.path.exists(file_path) and not os.path.exists(stem_path):
|
||||
shutil.move(file_path, stem_path)
|
||||
result[stem_name] = stem_path
|
||||
elif "_(Piano)_" in file_name:
|
||||
stem_name = "piano"
|
||||
stem_path = os.path.join(
|
||||
stems_dir,
|
||||
f"{artist_title} ({stem_name.capitalize()} {model_name}).{self.config.lossless_output_format.lower()}"
|
||||
)
|
||||
if os.path.exists(file_path) and not os.path.exists(stem_path):
|
||||
shutil.move(file_path, stem_path)
|
||||
result[stem_name] = stem_path
|
||||
else:
|
||||
# Try to extract stem name for any other stems that might be present
|
||||
try:
|
||||
# Extract stem name from patterns like "_(StemName)_"
|
||||
stem_match = re.search(r"_\(([^)]+)\)_", file_name)
|
||||
if stem_match:
|
||||
stem_name = stem_match.group(1)
|
||||
stem_path = os.path.join(
|
||||
stems_dir,
|
||||
f"{artist_title} ({stem_name} {model_name}).{self.config.lossless_output_format.lower()}"
|
||||
)
|
||||
if os.path.exists(file_path) and not os.path.exists(stem_path):
|
||||
shutil.move(file_path, stem_path)
|
||||
result[stem_name.lower()] = stem_path
|
||||
except Exception as e:
|
||||
self.logger.warning(f"Could not process stem file {file_name}: {e}")
|
||||
else:
|
||||
# Handle 2-stem models
|
||||
if "(Vocals)" in file_name:
|
||||
stem_path = output_paths["vocals"]
|
||||
if os.path.exists(file_path) and not os.path.exists(stem_path):
|
||||
shutil.move(file_path, stem_path)
|
||||
result["vocals"] = stem_path
|
||||
elif "(Instrumental)" in file_name:
|
||||
stem_path = output_paths["instrumental"]
|
||||
if os.path.exists(file_path) and not os.path.exists(stem_path):
|
||||
shutil.move(file_path, stem_path)
|
||||
result["instrumental"] = stem_path
|
||||
|
||||
# Update track with separation results
|
||||
track.separated_audio["other_stems"][model_name] = result
|
||||
|
||||
self.logger.info(f"Successfully separated stems using model: {model_name}")
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to separate stems using model {model_name}: {str(e)}")
|
||||
# Continue with other models
|
||||
else:
|
||||
self.logger.info(f"[DRY RUN] Would separate stems using model: {model_name}")
|
||||
track.separated_audio["other_stems"][model_name] = output_paths
|
||||
|
||||
return track
|
||||
|
||||
async def separate_backing_vocals(self, track, stems_dir):
|
||||
"""
|
||||
Separate backing vocals from the clean vocals.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
stems_dir: The directory to store stems
|
||||
|
||||
Returns:
|
||||
The track with updated audio information
|
||||
"""
|
||||
self.logger.info(f"Separating backing vocals for {track.base_name}")
|
||||
|
||||
# Skip if no models are specified or no clean vocals
|
||||
if not self.config.backing_vocals_models or not track.separated_audio["clean_instrumental"].get("vocals"):
|
||||
self.logger.info("No backing vocals models specified or no clean vocals available, skipping")
|
||||
track.separated_audio["backing_vocals"] = {}
|
||||
return track
|
||||
|
||||
# Get vocals path
|
||||
vocals_path = track.separated_audio["clean_instrumental"]["vocals"]
|
||||
|
||||
# Acquire lock for audio separation
|
||||
with self._acquire_lock(track.base_name):
|
||||
artist_title = track.base_name
|
||||
|
||||
# Initialize results
|
||||
track.separated_audio["backing_vocals"] = {}
|
||||
|
||||
# Process each model
|
||||
for model_name in self.config.backing_vocals_models:
|
||||
self.logger.info(f"Separating backing vocals using model: {model_name}")
|
||||
|
||||
# Define output paths
|
||||
lead_vocals_path = os.path.join(
|
||||
stems_dir,
|
||||
f"{artist_title} (Lead Vocals {model_name}).{self.config.lossless_output_format.lower()}"
|
||||
)
|
||||
backing_vocals_path = os.path.join(
|
||||
stems_dir,
|
||||
f"{artist_title} (Backing Vocals {model_name}).{self.config.lossless_output_format.lower()}"
|
||||
)
|
||||
|
||||
# Check if output files already exist
|
||||
if os.path.isfile(lead_vocals_path) and os.path.isfile(backing_vocals_path):
|
||||
self.logger.info(f"Backing vocals for model {model_name} already exist")
|
||||
track.separated_audio["backing_vocals"][model_name] = {
|
||||
"lead_vocals": lead_vocals_path,
|
||||
"backing_vocals": backing_vocals_path
|
||||
}
|
||||
continue
|
||||
|
||||
# Perform separation
|
||||
if not self.config.dry_run:
|
||||
try:
|
||||
# Load model first
|
||||
self.separator.load_model(model_filename=model_name)
|
||||
|
||||
# Convert vocals_path to absolute path
|
||||
vocals_path_abs = os.path.abspath(vocals_path)
|
||||
|
||||
# Call separate with the absolute path to the audio file
|
||||
output_files = self.separator.separate(vocals_path_abs)
|
||||
|
||||
# Process the output files
|
||||
result = {}
|
||||
for file in output_files:
|
||||
# The file path returned by separator.separate()
|
||||
# may already be the full path or just the filename
|
||||
file_name = os.path.basename(file)
|
||||
file_path = file # Use the path as returned by separator
|
||||
|
||||
if "(Vocals)" in file_name:
|
||||
# This is the lead vocals
|
||||
if os.path.exists(file_path) and not os.path.exists(lead_vocals_path):
|
||||
shutil.move(file_path, lead_vocals_path)
|
||||
result["lead_vocals"] = lead_vocals_path
|
||||
elif "(Instrumental)" in file_name:
|
||||
# This is the backing vocals
|
||||
if os.path.exists(file_path) and not os.path.exists(backing_vocals_path):
|
||||
shutil.move(file_path, backing_vocals_path)
|
||||
result["backing_vocals"] = backing_vocals_path
|
||||
|
||||
# Update track with separation results
|
||||
track.separated_audio["backing_vocals"][model_name] = result
|
||||
|
||||
self.logger.info(f"Successfully separated backing vocals using model: {model_name}")
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to separate backing vocals using model {model_name}: {str(e)}")
|
||||
# Continue with other models
|
||||
else:
|
||||
self.logger.info(f"[DRY RUN] Would separate backing vocals using model: {model_name}")
|
||||
track.separated_audio["backing_vocals"][model_name] = {
|
||||
"lead_vocals": lead_vocals_path,
|
||||
"backing_vocals": backing_vocals_path
|
||||
}
|
||||
|
||||
return track
|
||||
|
||||
async def separate_audio(self, track):
|
||||
"""
|
||||
Orchestrate the entire audio separation process.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated audio information
|
||||
"""
|
||||
self.logger.info(f"Starting audio separation process for {track.base_name}")
|
||||
|
||||
# Skip if requested
|
||||
if self.config.skip_separation:
|
||||
self.logger.info("Skipping audio separation as requested")
|
||||
track.separated_audio = {
|
||||
"clean_instrumental": {},
|
||||
"backing_vocals": {},
|
||||
"other_stems": {},
|
||||
"combined_instrumentals": {}
|
||||
}
|
||||
return track
|
||||
|
||||
# Create stems directory
|
||||
stems_dir = os.path.join(track.track_output_dir, "stems")
|
||||
os.makedirs(stems_dir, exist_ok=True)
|
||||
self.logger.info(f"Created stems directory: {stems_dir}")
|
||||
|
||||
# Check for existing instrumental
|
||||
if self.config.existing_instrumental:
|
||||
self.logger.info(f"Using existing instrumental file: {self.config.existing_instrumental}")
|
||||
existing_instrumental_extension = os.path.splitext(self.config.existing_instrumental)[1]
|
||||
|
||||
instrumental_path = os.path.join(
|
||||
track.track_output_dir,
|
||||
f"{track.base_name} (Instrumental Custom){existing_instrumental_extension}"
|
||||
)
|
||||
|
||||
if not os.path.exists(instrumental_path):
|
||||
shutil.copy2(self.config.existing_instrumental, instrumental_path)
|
||||
|
||||
track.separated_audio["clean_instrumental"] = {
|
||||
"instrumental": instrumental_path,
|
||||
"vocals": None
|
||||
}
|
||||
return track
|
||||
|
||||
# Perform separation steps
|
||||
try:
|
||||
# Step 1: Separate clean instrumental
|
||||
track = await self.separate_clean_instrumental(track, track.input_audio_wav, stems_dir)
|
||||
|
||||
# Step 2: Separate other stems
|
||||
track = await self.separate_other_stems(track, track.input_audio_wav, stems_dir)
|
||||
|
||||
# Step 3: Separate backing vocals
|
||||
track = await self.separate_backing_vocals(track, stems_dir)
|
||||
|
||||
# Step 4: Generate combined instrumentals
|
||||
track = await self.generate_combined_instrumentals(track, stems_dir)
|
||||
|
||||
# Step 5: Normalize audio files
|
||||
track = await self.normalize_audio_files(track)
|
||||
|
||||
self.logger.info("Audio separation process completed successfully")
|
||||
return track
|
||||
|
||||
except Exception as e:
|
||||
raise AudioError(f"Error during audio separation: {str(e)}") from e
|
||||
|
||||
async def generate_combined_instrumentals(self, track, stems_dir):
|
||||
"""
|
||||
Generate combined instrumental tracks with backing vocals.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
stems_dir: The directory to store stems
|
||||
|
||||
Returns:
|
||||
The track with updated audio information
|
||||
"""
|
||||
self.logger.info(f"Generating combined instrumental tracks with backing vocals for {track.base_name}")
|
||||
|
||||
# Skip if no backing vocals or clean instrumental
|
||||
if (not track.separated_audio["backing_vocals"] or
|
||||
not track.separated_audio["clean_instrumental"].get("instrumental")):
|
||||
self.logger.info("No backing vocals or clean instrumental available, skipping")
|
||||
track.separated_audio["combined_instrumentals"] = {}
|
||||
return track
|
||||
|
||||
instrumental_path = track.separated_audio["clean_instrumental"]["instrumental"]
|
||||
track.separated_audio["combined_instrumentals"] = {}
|
||||
|
||||
# Process each backing vocals model
|
||||
for model, paths in track.separated_audio["backing_vocals"].items():
|
||||
if "backing_vocals" not in paths:
|
||||
continue
|
||||
|
||||
backing_vocals_path = paths["backing_vocals"]
|
||||
combined_path = os.path.join(
|
||||
track.track_output_dir,
|
||||
f"{track.base_name} (Instrumental +BV {model}).{self.config.lossless_output_format.lower()}"
|
||||
)
|
||||
|
||||
# Skip if output already exists
|
||||
if os.path.isfile(combined_path):
|
||||
self.logger.info(f"Combined instrumental for model {model} already exists")
|
||||
track.separated_audio["combined_instrumentals"][model] = combined_path
|
||||
continue
|
||||
|
||||
# Perform mixing
|
||||
if not self.config.dry_run:
|
||||
try:
|
||||
from karaoke_gen.services.audio.mixer import AudioMixer
|
||||
mixer = AudioMixer(self.config)
|
||||
|
||||
# Mix instrumental and backing vocals
|
||||
await mixer.mix_audio_files(
|
||||
[instrumental_path, backing_vocals_path],
|
||||
combined_path,
|
||||
weights=[1, 1]
|
||||
)
|
||||
|
||||
track.separated_audio["combined_instrumentals"][model] = combined_path
|
||||
self.logger.info(f"Successfully created combined instrumental for model {model}")
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to create combined instrumental for model {model}: {str(e)}")
|
||||
# Continue with other models
|
||||
else:
|
||||
self.logger.info(f"[DRY RUN] Would create combined instrumental for model {model}")
|
||||
track.separated_audio["combined_instrumentals"][model] = combined_path
|
||||
|
||||
return track
|
||||
|
||||
async def normalize_audio_files(self, track):
|
||||
"""
|
||||
Normalize audio levels for instrumental and combined tracks.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with normalized audio files
|
||||
"""
|
||||
self.logger.info(f"Normalizing audio files for {track.base_name}")
|
||||
|
||||
files_to_normalize = []
|
||||
|
||||
# Add clean instrumental
|
||||
if track.separated_audio["clean_instrumental"].get("instrumental"):
|
||||
files_to_normalize.append(
|
||||
("clean_instrumental", track.separated_audio["clean_instrumental"]["instrumental"])
|
||||
)
|
||||
|
||||
# Add combined instrumentals
|
||||
for model, path in track.separated_audio["combined_instrumentals"].items():
|
||||
files_to_normalize.append(("combined_instrumentals", path))
|
||||
|
||||
# Skip if no files to normalize
|
||||
if not files_to_normalize:
|
||||
self.logger.info("No files to normalize, skipping")
|
||||
return track
|
||||
|
||||
# Normalize each file
|
||||
for key, file_path in files_to_normalize:
|
||||
if os.path.isfile(file_path):
|
||||
try:
|
||||
from karaoke_gen.services.audio.normalizer import AudioNormalizer
|
||||
normalizer = AudioNormalizer(self.config)
|
||||
|
||||
# Normalize in-place
|
||||
await normalizer.normalize_audio_file(file_path, file_path)
|
||||
|
||||
# Verify the normalized file
|
||||
if os.path.getsize(file_path) > 0:
|
||||
self.logger.info(f"Successfully normalized: {file_path}")
|
||||
else:
|
||||
raise AudioError("Normalized file is empty")
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Error during normalization of {file_path}: {e}")
|
||||
self.logger.warning(f"Normalization failed for {file_path}. Original file remains unchanged.")
|
||||
else:
|
||||
self.logger.warning(f"File not found for normalization: {file_path}")
|
||||
|
||||
self.logger.info("Audio normalization process completed")
|
||||
return track
|
||||
|
||||
async def cleanup(self):
|
||||
"""
|
||||
Perform cleanup operations for the audio separator.
|
||||
"""
|
||||
self.logger.info("Cleaning up audio separator resources")
|
||||
|
||||
# Release any locks
|
||||
for lock in self._locks.values():
|
||||
if lock.locked():
|
||||
lock.release()
|
||||
|
||||
# Close any open resources
|
||||
if hasattr(self, 'demucs_model') and self.demucs_model:
|
||||
# Clean up demucs model resources if needed
|
||||
pass
|
||||
|
||||
if hasattr(self, 'spleeter_model') and self.spleeter_model:
|
||||
# Clean up spleeter model resources if needed
|
||||
pass
|
||||
|
||||
self.logger.info("Audio separator cleanup complete")
|
||||
|
||||
def _acquire_lock(self, track_name):
|
||||
"""
|
||||
Acquire a lock for audio separation.
|
||||
|
||||
Args:
|
||||
track_name: The name of the track being processed
|
||||
|
||||
Returns:
|
||||
A context manager for the lock
|
||||
"""
|
||||
class LockContextManager:
|
||||
def __init__(self, separator, track_name):
|
||||
self.separator = separator
|
||||
self.track_name = track_name
|
||||
self.lock_file = None
|
||||
self.lock_file_path = os.path.join(tempfile.gettempdir(), "audio_separator.lock")
|
||||
|
||||
def __enter__(self):
|
||||
# Try to acquire lock
|
||||
while True:
|
||||
try:
|
||||
# First check if there's a stale lock
|
||||
if os.path.exists(self.lock_file_path):
|
||||
try:
|
||||
with open(self.lock_file_path, "r") as f:
|
||||
lock_data = json.load(f)
|
||||
pid = lock_data.get("pid")
|
||||
start_time = datetime.fromisoformat(lock_data.get("start_time"))
|
||||
running_track = lock_data.get("track")
|
||||
|
||||
# Check if the process is still running
|
||||
if pid and self.separator._is_process_running(pid):
|
||||
# Process is still running
|
||||
self.separator.logger.info(f"Waiting for another separation process to complete: {running_track}")
|
||||
time.sleep(5)
|
||||
continue
|
||||
else:
|
||||
# Stale lock, remove it
|
||||
self.separator.logger.info(f"Removing stale lock file")
|
||||
os.remove(self.lock_file_path)
|
||||
except (json.JSONDecodeError, KeyError, ValueError):
|
||||
# Invalid lock file, remove it
|
||||
self.separator.logger.info(f"Removing invalid lock file")
|
||||
os.remove(self.lock_file_path)
|
||||
|
||||
# Create lock file
|
||||
lock_data = {
|
||||
"pid": os.getpid(),
|
||||
"start_time": datetime.now().isoformat(),
|
||||
"track": self.track_name
|
||||
}
|
||||
|
||||
with open(self.lock_file_path, "w") as f:
|
||||
json.dump(lock_data, f)
|
||||
|
||||
self.lock_file = self.lock_file_path
|
||||
self.separator.logger.info(f"Acquired lock for {self.track_name}")
|
||||
return self
|
||||
except Exception as e:
|
||||
self.separator.logger.error(f"Error acquiring lock: {str(e)}")
|
||||
time.sleep(5)
|
||||
|
||||
def __exit__(self, exc_type, exc_val, exc_tb):
|
||||
# Release lock
|
||||
if self.lock_file and os.path.exists(self.lock_file):
|
||||
try:
|
||||
os.remove(self.lock_file)
|
||||
self.separator.logger.info(f"Released lock for {self.track_name}")
|
||||
except Exception as e:
|
||||
self.separator.logger.error(f"Error releasing lock: {str(e)}")
|
||||
|
||||
return LockContextManager(self, track_name)
|
||||
|
||||
def _is_process_running(self, pid):
|
||||
"""
|
||||
Check if a process with the given PID is running.
|
||||
|
||||
Args:
|
||||
pid: The process ID to check
|
||||
|
||||
Returns:
|
||||
True if the process is running, False otherwise
|
||||
"""
|
||||
try:
|
||||
# For Unix/Linux/Mac
|
||||
if os.name == 'posix':
|
||||
# Send signal 0 to the process - this doesn't actually send a signal,
|
||||
# but it does error checking to see if the process exists
|
||||
os.kill(pid, 0)
|
||||
return True
|
||||
# For Windows
|
||||
elif os.name == 'nt':
|
||||
import ctypes
|
||||
kernel32 = ctypes.windll.kernel32
|
||||
SYNCHRONIZE = 0x00100000
|
||||
process = kernel32.OpenProcess(SYNCHRONIZE, False, pid)
|
||||
if process != 0:
|
||||
kernel32.CloseHandle(process)
|
||||
return True
|
||||
return False
|
||||
else:
|
||||
# Fallback for other OS
|
||||
return False
|
||||
except OSError:
|
||||
return False
|
||||
except Exception as e:
|
||||
self.logger.error(f"Error checking if process {pid} is running: {str(e)}")
|
||||
return False
|
||||
@@ -0,0 +1,90 @@
|
||||
import logging
|
||||
import os
|
||||
import asyncio
|
||||
from karaoke_gen.core.project import ProjectConfig
|
||||
from karaoke_gen.core.track import Track
|
||||
from karaoke_gen.core.exceptions import AudioError
|
||||
from karaoke_gen.services.audio.converter import AudioConverter
|
||||
from karaoke_gen.services.audio.separator import AudioSeparator
|
||||
from karaoke_gen.services.audio.normalizer import AudioNormalizer
|
||||
from karaoke_gen.services.audio.mixer import AudioMixer
|
||||
|
||||
|
||||
class AudioService:
|
||||
"""
|
||||
Service for orchestrating the audio processing workflow.
|
||||
"""
|
||||
|
||||
def __init__(self, config: ProjectConfig):
|
||||
"""
|
||||
Initialize the audio service.
|
||||
|
||||
Args:
|
||||
config: The project configuration
|
||||
"""
|
||||
self.config = config
|
||||
self.logger = config.logger or logging.getLogger(__name__)
|
||||
|
||||
# Initialize components
|
||||
self.converter = AudioConverter(config)
|
||||
self.separator = AudioSeparator(config)
|
||||
self.normalizer = AudioNormalizer(config)
|
||||
self.mixer = AudioMixer(config)
|
||||
|
||||
async def separate_audio(self, track: Track) -> Track:
|
||||
"""
|
||||
Separate audio for a track.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with separated audio
|
||||
"""
|
||||
self.logger.info(f"Separating audio for {track.base_name}")
|
||||
return await self.separator.separate_audio(track)
|
||||
|
||||
async def process_audio(self, track: Track) -> Track:
|
||||
"""
|
||||
Process audio for a track, including separation, mixing, and normalization.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated audio information
|
||||
"""
|
||||
self.logger.info(f"Processing audio for {track.base_name}")
|
||||
|
||||
try:
|
||||
# Skip if instrumental already exists and we're not forcing regeneration
|
||||
if track.instrumental and os.path.isfile(track.instrumental) and not self.config.force_regenerate:
|
||||
self.logger.info(f"Instrumental already exists for {track.base_name}, skipping audio processing")
|
||||
return track
|
||||
|
||||
# Separate audio
|
||||
track = await self.separator.separate_audio(track)
|
||||
|
||||
# Mix audio
|
||||
track = await self.mixer.mix_audio(track)
|
||||
|
||||
# Normalize audio
|
||||
track = await self.normalizer.normalize_audio(track)
|
||||
|
||||
return track
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to process audio for {track.base_name}: {str(e)}")
|
||||
# Continue with other processing
|
||||
return track
|
||||
|
||||
async def cleanup(self):
|
||||
"""
|
||||
Perform cleanup operations for audio processing.
|
||||
"""
|
||||
self.logger.info("Cleaning up audio processing resources")
|
||||
|
||||
# Close any open resources
|
||||
await self.separator.cleanup()
|
||||
|
||||
self.logger.info("Audio processing cleanup complete")
|
||||
@@ -0,0 +1,21 @@
|
||||
"""
|
||||
Distribution service module for the karaoke_gen package.
|
||||
|
||||
This module contains the distribution service and related components.
|
||||
"""
|
||||
|
||||
from karaoke_gen.services.distribution.service import DistributionService
|
||||
from karaoke_gen.services.distribution.youtube import YouTubeUploader
|
||||
from karaoke_gen.services.distribution.organizer import FileOrganizer
|
||||
from karaoke_gen.services.distribution.cdg import CDGGenerator
|
||||
from karaoke_gen.services.distribution.txt import TXTGenerator
|
||||
from karaoke_gen.services.distribution.notifier import Notifier
|
||||
|
||||
__all__ = [
|
||||
"DistributionService",
|
||||
"YouTubeUploader",
|
||||
"FileOrganizer",
|
||||
"CDGGenerator",
|
||||
"TXTGenerator",
|
||||
"Notifier",
|
||||
]
|
||||
@@ -0,0 +1,159 @@
|
||||
"""
|
||||
CDG file generation functionality for the distribution service.
|
||||
"""
|
||||
|
||||
import os
|
||||
import zipfile
|
||||
import logging
|
||||
from typing import Optional, Dict, Any, Tuple
|
||||
|
||||
from lyrics_transcriber.output.cdg import CDGGenerator as LyricsTranscriberCDGGenerator
|
||||
|
||||
from karaoke_gen.core.project import ProjectConfig
|
||||
from karaoke_gen.core.track import Track
|
||||
from karaoke_gen.core.exceptions import DistributionError
|
||||
|
||||
|
||||
class CDGGenerator:
|
||||
"""
|
||||
Class for handling CDG file generation.
|
||||
"""
|
||||
|
||||
def __init__(self, config: ProjectConfig):
|
||||
"""
|
||||
Initialize the CDG generator.
|
||||
|
||||
Args:
|
||||
config: The project configuration
|
||||
"""
|
||||
self.config = config
|
||||
self.logger = config.logger or logging.getLogger(__name__)
|
||||
|
||||
def create_cdg_zip_file(self, track: Track) -> Track:
|
||||
"""
|
||||
Create a CDG zip file for the track.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated CDG zip file information
|
||||
|
||||
Raises:
|
||||
DistributionError: If creating the CDG zip file fails
|
||||
"""
|
||||
self.logger.info(f"Creating CDG and MP3 files, then zipping them...")
|
||||
|
||||
if not self.config.enable_cdg:
|
||||
self.logger.warning("CDG generation not enabled, skipping")
|
||||
return track
|
||||
|
||||
if not track.processed_lyrics:
|
||||
self.logger.warning("No processed lyrics available, cannot create CDG file")
|
||||
return track
|
||||
|
||||
if not track.instrumental:
|
||||
self.logger.warning("No instrumental audio available, cannot create CDG file")
|
||||
return track
|
||||
|
||||
# Determine the output file paths
|
||||
cdg_zip_file = os.path.join(track.track_output_dir, f"{track.base_name} (Final Karaoke CDG).zip")
|
||||
cdg_file = os.path.join(track.track_output_dir, f"{track.base_name} (Karaoke).cdg")
|
||||
mp3_file = os.path.join(track.track_output_dir, f"{track.base_name} (Karaoke).mp3")
|
||||
lrc_file = os.path.join(track.track_output_dir, f"{track.base_name} (Karaoke).lrc")
|
||||
|
||||
# Check if CDG file already exists, if so, ask user to overwrite or skip
|
||||
if os.path.isfile(cdg_zip_file):
|
||||
if self.config.non_interactive:
|
||||
self.logger.info(f"Non-interactive mode, automatically overwriting existing CDG ZIP file: {cdg_zip_file}")
|
||||
else:
|
||||
from karaoke_gen.utils.validation import prompt_user_bool
|
||||
if not prompt_user_bool(
|
||||
f"Found existing CDG ZIP file: {cdg_zip_file}. Overwrite (y) or skip (n)?",
|
||||
):
|
||||
self.logger.info(f"Skipping CDG ZIP file creation, existing file will be used.")
|
||||
track.final_karaoke_cdg_zip = cdg_zip_file
|
||||
return track
|
||||
|
||||
# Check if individual MP3 and CDG files already exist
|
||||
if os.path.isfile(mp3_file) and os.path.isfile(cdg_file):
|
||||
self.logger.info(f"Found existing MP3 and CDG files, creating ZIP file directly")
|
||||
|
||||
if self.config.dry_run:
|
||||
self.logger.info(f"DRY RUN: Would create ZIP file from existing MP3 and CDG files")
|
||||
track.final_karaoke_cdg_zip = cdg_zip_file
|
||||
return track
|
||||
|
||||
try:
|
||||
with zipfile.ZipFile(cdg_zip_file, "w") as zipf:
|
||||
zipf.write(mp3_file, os.path.basename(mp3_file))
|
||||
zipf.write(cdg_file, os.path.basename(cdg_file))
|
||||
|
||||
self.logger.info(f"Created CDG ZIP file: {cdg_zip_file}")
|
||||
track.final_karaoke_cdg_zip = cdg_zip_file
|
||||
return track
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to create CDG ZIP file: {str(e)}")
|
||||
raise DistributionError(f"Failed to create CDG ZIP file: {str(e)}")
|
||||
|
||||
# Generate CDG and MP3 files if they don't exist
|
||||
if self.config.dry_run:
|
||||
self.logger.info(f"DRY RUN: Would generate CDG and MP3 files")
|
||||
track.final_karaoke_cdg_zip = cdg_zip_file
|
||||
return track
|
||||
|
||||
try:
|
||||
self.logger.info(f"Generating CDG and MP3 files")
|
||||
|
||||
if not self.config.cdg_styles:
|
||||
raise DistributionError("CDG styles configuration is required when enable_cdg is True")
|
||||
|
||||
# Create the LRC file if it doesn't exist
|
||||
if not os.path.isfile(lrc_file) and track.processed_lyrics:
|
||||
with open(lrc_file, "w", encoding="utf-8") as f:
|
||||
f.write(track.processed_lyrics)
|
||||
|
||||
# Use the CDGGenerator from lyrics_transcriber to generate the CDG file
|
||||
generator = LyricsTranscriberCDGGenerator(output_dir=track.track_output_dir, logger=self.logger)
|
||||
|
||||
cdg_file_generated, mp3_file_generated, zip_file_generated = generator.generate_cdg_from_lrc(
|
||||
lrc_file=lrc_file,
|
||||
audio_file=track.instrumental,
|
||||
title=track.title,
|
||||
artist=track.artist,
|
||||
cdg_styles=self.config.cdg_styles,
|
||||
)
|
||||
|
||||
# Rename the generated ZIP file to match our expected naming convention
|
||||
if os.path.isfile(zip_file_generated) and zip_file_generated != cdg_zip_file:
|
||||
os.rename(zip_file_generated, cdg_zip_file)
|
||||
self.logger.info(f"Renamed CDG ZIP file from {zip_file_generated} to {cdg_zip_file}")
|
||||
|
||||
# Verify the CDG ZIP file was created
|
||||
if not os.path.isfile(cdg_zip_file):
|
||||
self.logger.error(f"Failed to find any CDG ZIP file. Listing directory contents:")
|
||||
for file in os.listdir(track.track_output_dir):
|
||||
self.logger.error(f" - {file}")
|
||||
raise DistributionError(f"Failed to create CDG ZIP file: {cdg_zip_file}")
|
||||
|
||||
self.logger.info(f"CDG ZIP file created: {cdg_zip_file}")
|
||||
|
||||
# Extract the CDG ZIP file to get the individual files
|
||||
self.logger.info(f"Extracting CDG ZIP file: {cdg_zip_file}")
|
||||
with zipfile.ZipFile(cdg_zip_file, "r") as zip_ref:
|
||||
zip_ref.extractall(track.track_output_dir)
|
||||
|
||||
# Verify the MP3 file was extracted
|
||||
if os.path.isfile(mp3_file):
|
||||
self.logger.info(f"Found extracted MP3 file: {mp3_file}")
|
||||
else:
|
||||
self.logger.error("Failed to find extracted MP3 file")
|
||||
raise DistributionError("Failed to extract MP3 file from CDG ZIP")
|
||||
|
||||
track.final_karaoke_cdg_zip = cdg_zip_file
|
||||
return track
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to create CDG ZIP file: {str(e)}")
|
||||
raise DistributionError(f"Failed to create CDG ZIP file: {str(e)}")
|
||||
@@ -0,0 +1,285 @@
|
||||
"""
|
||||
Notification functionality for the distribution service.
|
||||
"""
|
||||
|
||||
import os
|
||||
import pickle
|
||||
import logging
|
||||
import base64
|
||||
import requests
|
||||
from typing import Optional, Dict, Any
|
||||
from email.mime.text import MIMEText
|
||||
|
||||
from google_auth_oauthlib.flow import InstalledAppFlow
|
||||
from google.auth.transport.requests import Request
|
||||
from googleapiclient.discovery import build
|
||||
from google.oauth2.credentials import Credentials
|
||||
|
||||
from karaoke_gen.core.project import ProjectConfig
|
||||
from karaoke_gen.core.track import Track
|
||||
from karaoke_gen.core.exceptions import DistributionError
|
||||
|
||||
|
||||
class Notifier:
|
||||
"""
|
||||
Class for handling notifications.
|
||||
"""
|
||||
|
||||
def __init__(self, config: ProjectConfig):
|
||||
"""
|
||||
Initialize the notifier.
|
||||
|
||||
Args:
|
||||
config: The project configuration
|
||||
"""
|
||||
self.config = config
|
||||
self.logger = config.logger or logging.getLogger(__name__)
|
||||
self.gmail_token_file = "/tmp/karaoke-finalise-gmail-token.pickle"
|
||||
self.gmail_service = None
|
||||
|
||||
def post_discord_message(self, message: str, webhook_url: str) -> None:
|
||||
"""
|
||||
Post a message to a Discord channel via webhook.
|
||||
|
||||
Args:
|
||||
message: The message to post
|
||||
webhook_url: The Discord webhook URL
|
||||
|
||||
Raises:
|
||||
DistributionError: If posting the message fails
|
||||
"""
|
||||
self.logger.info(f"Posting message to Discord...")
|
||||
|
||||
if self.config.dry_run:
|
||||
self.logger.info(f"DRY RUN: Would post message to Discord: {message}")
|
||||
return
|
||||
|
||||
try:
|
||||
data = {"content": message}
|
||||
response = requests.post(webhook_url, json=data)
|
||||
response.raise_for_status() # This will raise an exception if the request failed
|
||||
self.logger.info("Message posted to Discord")
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to post message to Discord: {str(e)}")
|
||||
raise DistributionError(f"Failed to post message to Discord: {str(e)}")
|
||||
|
||||
def post_discord_notification(self, track: Track, skip_notifications: bool = False) -> None:
|
||||
"""
|
||||
Post a notification to Discord.
|
||||
|
||||
Args:
|
||||
track: The track to notify about
|
||||
skip_notifications: Whether to skip notifications
|
||||
|
||||
Raises:
|
||||
DistributionError: If posting the notification fails
|
||||
"""
|
||||
self.logger.info(f"Posting Discord notification...")
|
||||
|
||||
if not self.config.discord_webhook_url:
|
||||
self.logger.warning("Discord webhook URL not set, cannot post notification")
|
||||
return
|
||||
|
||||
if skip_notifications:
|
||||
self.logger.info(f"Skipping Discord notification as requested")
|
||||
return
|
||||
|
||||
if self.config.dry_run:
|
||||
self.logger.info(
|
||||
f"DRY RUN: Would post Discord notification for YouTube URL {track.youtube_url} using webhook URL: {self.config.discord_webhook_url}"
|
||||
)
|
||||
return
|
||||
|
||||
try:
|
||||
# Create a rich embed for Discord
|
||||
embed = {
|
||||
"title": f"{track.artist} - {track.title}",
|
||||
"description": "New karaoke track available!",
|
||||
"color": 0x00ff00, # Green color
|
||||
"fields": []
|
||||
}
|
||||
|
||||
# Add brand code if available
|
||||
if track.brand_code:
|
||||
embed["fields"].append({
|
||||
"name": "Brand Code",
|
||||
"value": track.brand_code,
|
||||
"inline": True
|
||||
})
|
||||
|
||||
# Add YouTube URL if available
|
||||
if track.youtube_url:
|
||||
embed["fields"].append({
|
||||
"name": "YouTube",
|
||||
"value": track.youtube_url,
|
||||
"inline": True
|
||||
})
|
||||
|
||||
# Add sharing link if available
|
||||
if track.brand_code_dir_sharing_link:
|
||||
embed["fields"].append({
|
||||
"name": "Download",
|
||||
"value": track.brand_code_dir_sharing_link,
|
||||
"inline": True
|
||||
})
|
||||
|
||||
# Create the payload
|
||||
payload = {
|
||||
"embeds": [embed]
|
||||
}
|
||||
|
||||
# Post to Discord
|
||||
response = requests.post(self.config.discord_webhook_url, json=payload)
|
||||
response.raise_for_status()
|
||||
|
||||
self.logger.info("Discord notification posted successfully")
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to post Discord notification: {str(e)}")
|
||||
raise DistributionError(f"Failed to post Discord notification: {str(e)}")
|
||||
|
||||
def authenticate_gmail(self) -> Any:
|
||||
"""
|
||||
Authenticate and return a Gmail service object.
|
||||
|
||||
Returns:
|
||||
The authenticated Gmail service
|
||||
|
||||
Raises:
|
||||
DistributionError: If authentication fails
|
||||
"""
|
||||
self.logger.info("Authenticating with Gmail...")
|
||||
|
||||
if self.config.dry_run:
|
||||
self.logger.info("DRY RUN: Would authenticate with Gmail")
|
||||
return None
|
||||
|
||||
try:
|
||||
creds = None
|
||||
|
||||
# Token file stores the user's access and refresh tokens for Gmail.
|
||||
if os.path.exists(self.gmail_token_file):
|
||||
with open(self.gmail_token_file, "rb") as token:
|
||||
creds = pickle.load(token)
|
||||
|
||||
# If there are no valid credentials, let the user log in.
|
||||
if not creds or not creds.valid:
|
||||
if creds and creds.expired and creds.refresh_token:
|
||||
creds.refresh(Request())
|
||||
else:
|
||||
flow = InstalledAppFlow.from_client_secrets_file(
|
||||
self.config.youtube_client_secrets_file, # Reuse the YouTube client secrets file
|
||||
["https://www.googleapis.com/auth/gmail.compose"]
|
||||
)
|
||||
creds = flow.run_local_server(port=0)
|
||||
|
||||
# Save the credentials for the next run
|
||||
with open(self.gmail_token_file, "wb") as token:
|
||||
pickle.dump(creds, token)
|
||||
|
||||
return build("gmail", "v1", credentials=creds)
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to authenticate with Gmail: {str(e)}")
|
||||
raise DistributionError(f"Failed to authenticate with Gmail: {str(e)}")
|
||||
|
||||
def draft_completion_email(self, track: Track) -> None:
|
||||
"""
|
||||
Draft a completion email.
|
||||
|
||||
Args:
|
||||
track: The track to draft an email for
|
||||
|
||||
Raises:
|
||||
DistributionError: If drafting the email fails
|
||||
"""
|
||||
self.logger.info(f"Drafting completion email...")
|
||||
|
||||
if not self.config.email_template_file:
|
||||
self.logger.info("Email template file not provided, skipping email draft creation.")
|
||||
return
|
||||
|
||||
if not track.youtube_url or not track.brand_code_dir_sharing_link:
|
||||
self.logger.warning("YouTube URL or sharing link not available, cannot draft completion email")
|
||||
return
|
||||
|
||||
if self.config.dry_run:
|
||||
self.logger.info(f"DRY RUN: Would draft completion email for {track.artist} - {track.title}")
|
||||
return
|
||||
|
||||
try:
|
||||
# Read the email template
|
||||
with open(self.config.email_template_file, "r", encoding="utf-8") as f:
|
||||
template = f.read()
|
||||
|
||||
# Format the email body
|
||||
email_body = template.format(
|
||||
youtube_url=track.youtube_url,
|
||||
dropbox_url=track.brand_code_dir_sharing_link,
|
||||
artist=track.artist,
|
||||
title=track.title,
|
||||
brand_code=track.brand_code
|
||||
)
|
||||
|
||||
# Create the email subject
|
||||
subject = f"{track.brand_code}: {track.artist} - {track.title}"
|
||||
|
||||
# Create the email message
|
||||
message = MIMEText(email_body)
|
||||
message["subject"] = subject
|
||||
|
||||
# Encode the message
|
||||
raw_message = base64.urlsafe_b64encode(message.as_bytes()).decode("utf-8")
|
||||
|
||||
# Get the Gmail service
|
||||
if not self.gmail_service:
|
||||
self.gmail_service = self.authenticate_gmail()
|
||||
|
||||
# Create the draft
|
||||
draft = self.gmail_service.users().drafts().create(
|
||||
userId="me",
|
||||
body={"message": {"raw": raw_message}}
|
||||
).execute()
|
||||
|
||||
self.logger.info(f"Email draft created with ID: {draft['id']}")
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to draft completion email: {str(e)}")
|
||||
raise DistributionError(f"Failed to draft completion email: {str(e)}")
|
||||
|
||||
def test_email_template(self) -> None:
|
||||
"""
|
||||
Test the email template by creating a draft with fake data.
|
||||
|
||||
Raises:
|
||||
DistributionError: If testing the email template fails
|
||||
"""
|
||||
self.logger.info(f"Testing email template...")
|
||||
|
||||
if not self.config.email_template_file:
|
||||
self.logger.error("Email template file not provided. Use --email_template_file to specify the file path.")
|
||||
return
|
||||
|
||||
if self.config.dry_run:
|
||||
self.logger.info(f"DRY RUN: Would test email template")
|
||||
return
|
||||
|
||||
try:
|
||||
# Create a fake track
|
||||
fake_track = Track(
|
||||
artist="Test Artist",
|
||||
title="Test Song",
|
||||
brand_code="TEST-0001",
|
||||
youtube_url="https://www.youtube.com/watch?v=dQw4w9WgXcQ",
|
||||
brand_code_dir_sharing_link="https://www.dropbox.com/sh/fake/folder/link"
|
||||
)
|
||||
|
||||
# Draft the email
|
||||
self.draft_completion_email(fake_track)
|
||||
|
||||
self.logger.info("Email template test complete. Check your Gmail drafts for the test email.")
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to test email template: {str(e)}")
|
||||
raise DistributionError(f"Failed to test email template: {str(e)}")
|
||||
@@ -0,0 +1,329 @@
|
||||
"""
|
||||
File organization functionality for the distribution service.
|
||||
"""
|
||||
|
||||
import os
|
||||
import re
|
||||
import shutil
|
||||
import subprocess
|
||||
import time
|
||||
import logging
|
||||
import shlex
|
||||
from typing import Optional, Dict, Any, List
|
||||
|
||||
from karaoke_gen.core.project import ProjectConfig
|
||||
from karaoke_gen.core.track import Track
|
||||
from karaoke_gen.core.exceptions import DistributionError
|
||||
|
||||
|
||||
class FileOrganizer:
|
||||
"""
|
||||
Class for handling file organization operations.
|
||||
"""
|
||||
|
||||
def __init__(self, config: ProjectConfig):
|
||||
"""
|
||||
Initialize the file organizer.
|
||||
|
||||
Args:
|
||||
config: The project configuration
|
||||
"""
|
||||
self.config = config
|
||||
self.logger = config.logger or logging.getLogger(__name__)
|
||||
|
||||
def get_next_brand_code(self) -> str:
|
||||
"""
|
||||
Calculate the next sequence number based on existing directories in the organised_dir.
|
||||
Assumes directories are named with the format: BRAND-XXXX Artist - Title
|
||||
|
||||
Returns:
|
||||
The next brand code
|
||||
|
||||
Raises:
|
||||
DistributionError: If the target directory does not exist
|
||||
"""
|
||||
self.logger.info(f"Getting next brand code for prefix {self.config.brand_prefix}")
|
||||
|
||||
if not self.config.brand_prefix or not self.config.organised_dir:
|
||||
self.logger.warning("Brand prefix or organised directory not set, cannot get next brand code")
|
||||
return None
|
||||
|
||||
if not os.path.isdir(self.config.organised_dir):
|
||||
raise DistributionError(f"Target directory does not exist: {self.config.organised_dir}")
|
||||
|
||||
max_num = 0
|
||||
pattern = re.compile(rf"^{re.escape(self.config.brand_prefix)}-(\d{{4}})")
|
||||
|
||||
for dir_name in os.listdir(self.config.organised_dir):
|
||||
match = pattern.match(dir_name)
|
||||
if match:
|
||||
num = int(match.group(1))
|
||||
max_num = max(max_num, num)
|
||||
|
||||
self.logger.info(f"Next sequence number for brand {self.config.brand_prefix} calculated as: {max_num + 1}")
|
||||
next_seq_number = max_num + 1
|
||||
|
||||
return f"{self.config.brand_prefix}-{next_seq_number:04d}"
|
||||
|
||||
def get_existing_brand_code(self, track: Track) -> str:
|
||||
"""
|
||||
Extract brand code from current directory name.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The existing brand code
|
||||
|
||||
Raises:
|
||||
DistributionError: If the current directory name does not match the expected format
|
||||
"""
|
||||
self.logger.info("Getting existing brand code from current directory")
|
||||
|
||||
if not self.config.brand_prefix:
|
||||
self.logger.warning("Brand prefix not set, cannot get existing brand code")
|
||||
return None
|
||||
|
||||
current_dir = os.path.basename(track.track_output_dir)
|
||||
|
||||
if " - " not in current_dir:
|
||||
raise DistributionError(f"Current directory '{current_dir}' does not match expected format 'BRAND-XXXX - Artist - Title'")
|
||||
|
||||
brand_code = current_dir.split(" - ")[0]
|
||||
if not brand_code or "-" not in brand_code:
|
||||
raise DistributionError(f"Could not extract valid brand code from directory name '{current_dir}'")
|
||||
|
||||
self.logger.info(f"Using existing brand code: {brand_code}")
|
||||
return brand_code
|
||||
|
||||
def move_files_to_brand_code_folder(self, track: Track, brand_code: str) -> Track:
|
||||
"""
|
||||
Move files to a brand code folder.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
brand_code: The brand code to use
|
||||
|
||||
Returns:
|
||||
The track with updated file paths
|
||||
|
||||
Raises:
|
||||
DistributionError: If moving the files fails
|
||||
"""
|
||||
self.logger.info(f"Moving files to new brand-prefixed directory...")
|
||||
|
||||
if not brand_code:
|
||||
self.logger.warning("Brand code not set, cannot move files")
|
||||
return track
|
||||
|
||||
new_brand_code_dir = f"{brand_code} - {track.artist} - {track.title}"
|
||||
new_brand_code_dir_path = os.path.join(self.config.organised_dir, new_brand_code_dir)
|
||||
|
||||
# Store the new directory path in the track
|
||||
track.new_brand_code_dir_path = new_brand_code_dir_path
|
||||
|
||||
if self.config.dry_run:
|
||||
self.logger.info(f"DRY RUN: Would move original directory {track.track_output_dir} to: {new_brand_code_dir_path}")
|
||||
return track
|
||||
|
||||
try:
|
||||
# Create the parent directory if it doesn't exist
|
||||
os.makedirs(os.path.dirname(new_brand_code_dir_path), exist_ok=True)
|
||||
|
||||
# Move the directory
|
||||
shutil.move(track.track_output_dir, new_brand_code_dir_path)
|
||||
|
||||
# Update the track's output directory
|
||||
track.track_output_dir = new_brand_code_dir_path
|
||||
|
||||
# Update file paths
|
||||
if track.final_video:
|
||||
track.final_video = os.path.join(new_brand_code_dir_path, os.path.basename(track.final_video))
|
||||
|
||||
if track.final_video_mkv:
|
||||
track.final_video_mkv = os.path.join(new_brand_code_dir_path, os.path.basename(track.final_video_mkv))
|
||||
|
||||
if track.final_video_lossy:
|
||||
track.final_video_lossy = os.path.join(new_brand_code_dir_path, os.path.basename(track.final_video_lossy))
|
||||
|
||||
if track.final_video_720p:
|
||||
track.final_video_720p = os.path.join(new_brand_code_dir_path, os.path.basename(track.final_video_720p))
|
||||
|
||||
if track.final_karaoke_cdg_zip:
|
||||
track.final_karaoke_cdg_zip = os.path.join(new_brand_code_dir_path, os.path.basename(track.final_karaoke_cdg_zip))
|
||||
|
||||
if track.final_karaoke_txt_zip:
|
||||
track.final_karaoke_txt_zip = os.path.join(new_brand_code_dir_path, os.path.basename(track.final_karaoke_txt_zip))
|
||||
|
||||
return track
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to move files to brand code folder: {str(e)}")
|
||||
raise DistributionError(f"Failed to move files to brand code folder: {str(e)}")
|
||||
|
||||
def copy_final_files_to_public_share_dirs(self, track: Track, brand_code: str) -> Track:
|
||||
"""
|
||||
Copy final files to public share directories.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
brand_code: The brand code to use
|
||||
|
||||
Returns:
|
||||
The track with updated file paths
|
||||
|
||||
Raises:
|
||||
DistributionError: If copying the files fails
|
||||
"""
|
||||
self.logger.info(f"Copying final MP4, 720p MP4, and ZIP to public share directory...")
|
||||
|
||||
if not self.config.public_share_dir:
|
||||
self.logger.warning("Public share directory not set, cannot copy files")
|
||||
return track
|
||||
|
||||
if not brand_code:
|
||||
raise DistributionError(f"Brand code not set, refusing to copy to public share directory")
|
||||
|
||||
# Validate public_share_dir is a valid folder with MP4, MP4-720p, and CDG subdirectories
|
||||
if not os.path.isdir(self.config.public_share_dir):
|
||||
raise DistributionError(f"Public share directory does not exist: {self.config.public_share_dir}")
|
||||
|
||||
dest_mp4_dir = os.path.join(self.config.public_share_dir, "MP4")
|
||||
dest_720p_dir = os.path.join(self.config.public_share_dir, "MP4-720p")
|
||||
dest_cdg_dir = os.path.join(self.config.public_share_dir, "CDG")
|
||||
|
||||
# Create directories if they don't exist
|
||||
for dir_path in [dest_mp4_dir, dest_720p_dir, dest_cdg_dir]:
|
||||
if not os.path.isdir(dir_path):
|
||||
if self.config.dry_run:
|
||||
self.logger.info(f"DRY RUN: Would create directory: {dir_path}")
|
||||
else:
|
||||
os.makedirs(dir_path, exist_ok=True)
|
||||
|
||||
# Prepare destination file paths
|
||||
dest_mp4_file = os.path.join(dest_mp4_dir, f"{brand_code} - {track.base_name}.mp4")
|
||||
dest_720p_mp4_file = os.path.join(dest_720p_dir, f"{brand_code} - {track.base_name}.mp4")
|
||||
dest_zip_file = os.path.join(dest_cdg_dir, f"{brand_code} - {track.base_name}.zip")
|
||||
|
||||
if self.config.dry_run:
|
||||
self.logger.info(
|
||||
f"DRY RUN: Would copy final MP4, 720p MP4, and ZIP to {dest_mp4_file}, {dest_720p_mp4_file}, and {dest_zip_file}"
|
||||
)
|
||||
return track
|
||||
|
||||
try:
|
||||
# Copy files
|
||||
if track.final_video_lossy and os.path.isfile(track.final_video_lossy):
|
||||
shutil.copy2(track.final_video_lossy, dest_mp4_file)
|
||||
|
||||
if track.final_video_720p and os.path.isfile(track.final_video_720p):
|
||||
shutil.copy2(track.final_video_720p, dest_720p_mp4_file)
|
||||
|
||||
if track.final_karaoke_cdg_zip and os.path.isfile(track.final_karaoke_cdg_zip):
|
||||
shutil.copy2(track.final_karaoke_cdg_zip, dest_zip_file)
|
||||
|
||||
self.logger.info(f"Copied final files to public share directory")
|
||||
return track
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to copy files to public share directory: {str(e)}")
|
||||
raise DistributionError(f"Failed to copy files to public share directory: {str(e)}")
|
||||
|
||||
def sync_public_share_dir_to_rclone_destination(self) -> None:
|
||||
"""
|
||||
Sync public share directory to rclone destination.
|
||||
|
||||
Raises:
|
||||
DistributionError: If syncing fails
|
||||
"""
|
||||
self.logger.info(f"Syncing public share directory to rclone destination...")
|
||||
|
||||
if not self.config.rclone_destination or not self.config.public_share_dir:
|
||||
self.logger.warning("Rclone destination or public share directory not set, cannot sync")
|
||||
return
|
||||
|
||||
if self.config.dry_run:
|
||||
self.logger.info(f"DRY RUN: Would sync {self.config.public_share_dir} to {self.config.rclone_destination}")
|
||||
return
|
||||
|
||||
try:
|
||||
# Delete .DS_Store files recursively before syncing
|
||||
for root, dirs, files in os.walk(self.config.public_share_dir):
|
||||
for file in files:
|
||||
if file == ".DS_Store":
|
||||
file_path = os.path.join(root, file)
|
||||
os.remove(file_path)
|
||||
self.logger.info(f"Deleted .DS_Store file: {file_path}")
|
||||
|
||||
# Build the rclone command
|
||||
rclone_cmd = f"rclone sync -v '{self.config.public_share_dir}' '{self.config.rclone_destination}'"
|
||||
|
||||
# Execute the command
|
||||
self.logger.info(f"Running command: {rclone_cmd}")
|
||||
process = subprocess.run(rclone_cmd, shell=True, check=True, capture_output=True, text=True)
|
||||
|
||||
if process.returncode != 0:
|
||||
raise DistributionError(f"rclone sync failed: {process.stderr}")
|
||||
|
||||
self.logger.info(f"Successfully synced public share directory to rclone destination")
|
||||
|
||||
except subprocess.CalledProcessError as e:
|
||||
self.logger.error(f"Failed to sync to rclone destination. Exit code: {e.returncode}")
|
||||
self.logger.error(f"Command output (stdout): {e.stdout}")
|
||||
self.logger.error(f"Command output (stderr): {e.stderr}")
|
||||
raise DistributionError(f"Failed to sync to rclone destination: {e.stderr}")
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to sync to rclone destination: {str(e)}")
|
||||
raise DistributionError(f"Failed to sync to rclone destination: {str(e)}")
|
||||
|
||||
def generate_organised_folder_sharing_link(self, track: Track) -> Optional[str]:
|
||||
"""
|
||||
Generate a sharing link for the organised folder.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The sharing link
|
||||
|
||||
Raises:
|
||||
DistributionError: If generating the link fails
|
||||
"""
|
||||
self.logger.info(f"Getting Organised Folder sharing link for new brand code directory...")
|
||||
|
||||
if not self.config.organised_dir_rclone_root or not track.brand_code or not track.new_brand_code_dir_path:
|
||||
self.logger.warning("Organised directory rclone root, brand code, or new brand code directory path not set, cannot generate sharing link")
|
||||
return None
|
||||
|
||||
if self.config.dry_run:
|
||||
self.logger.info(f"DRY RUN: Would get sharing link for {track.new_brand_code_dir_path}")
|
||||
return "https://file-sharing-service.com/example"
|
||||
|
||||
try:
|
||||
# Build the rclone destination path
|
||||
rclone_dest = f"{self.config.organised_dir_rclone_root}/{os.path.basename(track.new_brand_code_dir_path)}"
|
||||
rclone_link_cmd = f"rclone link {shlex.quote(rclone_dest)}"
|
||||
|
||||
# Add a 5-second delay to allow the service to index the folder before generating a link
|
||||
self.logger.info("Waiting 5 seconds before generating link...")
|
||||
time.sleep(5)
|
||||
|
||||
# Execute the command
|
||||
self.logger.info(f"Running command: {rclone_link_cmd}")
|
||||
result = subprocess.run(rclone_link_cmd, shell=True, check=True, capture_output=True, text=True)
|
||||
|
||||
sharing_link = result.stdout.strip()
|
||||
self.logger.info(f"Got organised folder sharing link: {sharing_link}")
|
||||
|
||||
return sharing_link
|
||||
|
||||
except subprocess.CalledProcessError as e:
|
||||
self.logger.error(f"Failed to get organised folder sharing link. Exit code: {e.returncode}")
|
||||
self.logger.error(f"Command output (stdout): {e.stdout}")
|
||||
self.logger.error(f"Command output (stderr): {e.stderr}")
|
||||
raise DistributionError(f"Failed to get organised folder sharing link: {e.stderr}")
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to get organised folder sharing link: {str(e)}")
|
||||
raise DistributionError(f"Failed to get organised folder sharing link: {str(e)}")
|
||||
@@ -0,0 +1,312 @@
|
||||
from karaoke_gen.core.project import ProjectConfig
|
||||
from karaoke_gen.core.track import Track
|
||||
from karaoke_gen.core.exceptions import DistributionError, YouTubeError
|
||||
|
||||
from karaoke_gen.services.distribution.youtube import YouTubeUploader
|
||||
from karaoke_gen.services.distribution.organizer import FileOrganizer
|
||||
from karaoke_gen.services.distribution.cdg import CDGGenerator
|
||||
from karaoke_gen.services.distribution.txt import TXTGenerator
|
||||
from karaoke_gen.services.distribution.notifier import Notifier
|
||||
|
||||
import logging
|
||||
import os
|
||||
import asyncio
|
||||
import shutil
|
||||
import glob
|
||||
import re
|
||||
import subprocess
|
||||
from typing import Dict, Any, Optional, List, Tuple
|
||||
|
||||
|
||||
class DistributionService:
|
||||
"""
|
||||
Service for distribution operations including file organization, YouTube uploading, and notifications.
|
||||
"""
|
||||
|
||||
def __init__(self, config: ProjectConfig):
|
||||
"""
|
||||
Initialize the distribution service.
|
||||
|
||||
Args:
|
||||
config: The project configuration
|
||||
"""
|
||||
self.config = config
|
||||
self.logger = config.logger or logging.getLogger(__name__)
|
||||
|
||||
# Initialize components
|
||||
self.youtube_uploader = YouTubeUploader(config)
|
||||
self.file_organizer = FileOrganizer(config)
|
||||
self.cdg_generator = CDGGenerator(config)
|
||||
self.txt_generator = TXTGenerator(config)
|
||||
self.notifier = Notifier(config)
|
||||
|
||||
# Detect best available AAC codec
|
||||
self.aac_codec = self._detect_best_aac_codec()
|
||||
|
||||
async def distribute(self, track: Track, replace_existing: bool = False) -> Track:
|
||||
"""
|
||||
Distribute the track.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
replace_existing: Whether to replace existing files
|
||||
|
||||
Returns:
|
||||
The track with updated distribution information
|
||||
"""
|
||||
self.logger.info(f"Distributing {track.base_name}")
|
||||
|
||||
# Remux and encode output video files
|
||||
track = await self._remux_and_encode_output_video_files(track)
|
||||
|
||||
# Create CDG zip file if enabled
|
||||
if self.config.enable_cdg:
|
||||
track = self.cdg_generator.create_cdg_zip_file(track)
|
||||
|
||||
# Create TXT zip file if enabled
|
||||
if self.config.enable_txt:
|
||||
track = self.txt_generator.create_txt_zip_file(track)
|
||||
|
||||
# Get brand code
|
||||
if self.config.keep_brand_code:
|
||||
track.brand_code = self.file_organizer.get_existing_brand_code(track)
|
||||
else:
|
||||
track.brand_code = self.file_organizer.get_next_brand_code()
|
||||
|
||||
# Move files to brand code folder
|
||||
if track.brand_code and self.config.organised_dir:
|
||||
track = self.file_organizer.move_files_to_brand_code_folder(track, track.brand_code)
|
||||
|
||||
# Copy final files to public share directory
|
||||
if self.config.public_share_dir and track.brand_code:
|
||||
track = self.file_organizer.copy_final_files_to_public_share_dirs(track, track.brand_code)
|
||||
|
||||
# Sync public share directory to rclone destination
|
||||
if self.config.rclone_destination and self.config.public_share_dir:
|
||||
self.file_organizer.sync_public_share_dir_to_rclone_destination()
|
||||
|
||||
# Upload to YouTube
|
||||
if self.config.youtube_client_secrets_file and track.final_video_mkv:
|
||||
thumbnail_file = os.path.join(track.track_output_dir, f"{track.base_name} (Title).jpg")
|
||||
if not os.path.isfile(thumbnail_file):
|
||||
thumbnail_file = None
|
||||
|
||||
track.youtube_url = self.youtube_uploader.upload_video(
|
||||
video_file=track.final_video_mkv,
|
||||
thumbnail_file=thumbnail_file,
|
||||
artist=track.artist,
|
||||
title=track.title,
|
||||
replace_existing=replace_existing
|
||||
)
|
||||
|
||||
# Generate sharing link
|
||||
if self.config.organised_dir_rclone_root and track.brand_code and track.new_brand_code_dir_path:
|
||||
track.brand_code_dir_sharing_link = self.file_organizer.generate_organised_folder_sharing_link(track)
|
||||
|
||||
# Post Discord notification
|
||||
if self.config.discord_webhook_url and track.youtube_url:
|
||||
self.notifier.post_discord_notification(track)
|
||||
|
||||
# Draft completion email
|
||||
if self.config.email_template_file and track.youtube_url and track.brand_code_dir_sharing_link:
|
||||
self.notifier.draft_completion_email(track)
|
||||
|
||||
return track
|
||||
|
||||
async def _remux_and_encode_output_video_files(self, track: Track) -> Track:
|
||||
"""
|
||||
Remux and encode output video files.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated video file information
|
||||
"""
|
||||
self.logger.info(f"Remuxing and encoding output video files for {track.base_name}")
|
||||
|
||||
if not track.video_with_lyrics or not track.instrumental:
|
||||
self.logger.warning("No video with lyrics or instrumental audio available, cannot remux/encode")
|
||||
return track
|
||||
|
||||
# Determine output file paths
|
||||
final_video = os.path.join(track.track_output_dir, f"{track.base_name} (Final Karaoke Lossless 4k).mp4")
|
||||
final_video_mkv = os.path.join(track.track_output_dir, f"{track.base_name} (Final Karaoke Lossless 4k).mkv")
|
||||
final_video_lossy = os.path.join(track.track_output_dir, f"{track.base_name} (Final Karaoke Lossy 4k).mp4")
|
||||
final_video_720p = os.path.join(track.track_output_dir, f"{track.base_name} (Final Karaoke Lossy 720p).mp4")
|
||||
|
||||
# Check if output files already exist
|
||||
if os.path.isfile(final_video) and os.path.isfile(final_video_mkv):
|
||||
if self.config.non_interactive:
|
||||
self.logger.info(f"Non-interactive mode, automatically overwriting existing final video files")
|
||||
else:
|
||||
from karaoke_gen.utils.validation import prompt_user_bool
|
||||
if not prompt_user_bool(
|
||||
f"Found existing Final Karaoke output files. Overwrite (y) or skip (n)?",
|
||||
):
|
||||
self.logger.info(f"Skipping Karaoke MP4 remux and Final video renders, existing files will be used.")
|
||||
track.final_video = final_video
|
||||
track.final_video_mkv = final_video_mkv
|
||||
track.final_video_lossy = final_video_lossy
|
||||
track.final_video_720p = final_video_720p
|
||||
return track
|
||||
|
||||
if self.config.dry_run:
|
||||
self.logger.info(f"DRY RUN: Would remux and encode output video files")
|
||||
track.final_video = final_video
|
||||
track.final_video_mkv = final_video_mkv
|
||||
track.final_video_lossy = final_video_lossy
|
||||
track.final_video_720p = final_video_720p
|
||||
return track
|
||||
|
||||
try:
|
||||
# MP4 output flags for better compatibility and streaming
|
||||
mp4_flags = "-pix_fmt yuv420p -movflags +faststart+frag_keyframe+empty_moov"
|
||||
|
||||
# Path to ffmpeg
|
||||
ffmpeg_path = "ffmpeg"
|
||||
|
||||
# Base ffmpeg command
|
||||
ffmpeg_base_command = f"{ffmpeg_path} -hide_banner -nostats"
|
||||
|
||||
if self.logger.level == logging.DEBUG:
|
||||
ffmpeg_base_command += " -loglevel verbose"
|
||||
else:
|
||||
ffmpeg_base_command += " -loglevel fatal"
|
||||
|
||||
# Add -y if non-interactive
|
||||
if self.config.non_interactive:
|
||||
ffmpeg_base_command += " -y"
|
||||
|
||||
# Create karaoke version with instrumental audio
|
||||
karaoke_mp4 = os.path.join(track.track_output_dir, f"{track.base_name} (Karaoke).mp4")
|
||||
|
||||
# Remux the video with instrumental audio
|
||||
remux_command = (
|
||||
f'{ffmpeg_base_command} -an -i "{track.video_with_lyrics}" '
|
||||
f'-vn -i "{track.instrumental}" -c:v copy -c:a pcm_s16le "{karaoke_mp4}"'
|
||||
)
|
||||
|
||||
self.logger.info(f"Remuxing video with instrumental audio: {remux_command}")
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
remux_command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
await process.communicate()
|
||||
|
||||
# Prepare title and end videos
|
||||
title_video = os.path.join(track.track_output_dir, f"{track.base_name} (Title).mov")
|
||||
end_video = os.path.join(track.track_output_dir, f"{track.base_name} (End).mov")
|
||||
|
||||
# Prepare concat filter for combining videos
|
||||
env_mov_input = ""
|
||||
ffmpeg_filter = '-filter_complex "[0:v:0][0:a:0][1:v:0][1:a:0]concat=n=2:v=1:a=1[outv][outa]"'
|
||||
|
||||
if os.path.isfile(end_video):
|
||||
self.logger.info(f"Found end video: {end_video}, including in final MP4")
|
||||
env_mov_input = f'-i "{end_video}"'
|
||||
ffmpeg_filter = '-filter_complex "[0:v:0][0:a:0][1:v:0][1:a:0][2:v:0][2:a:0]concat=n=3:v=1:a=1[outv][outa]"'
|
||||
|
||||
# Create lossless MP4
|
||||
lossless_mp4_command = (
|
||||
f'{ffmpeg_base_command} -i "{title_video}" -i "{karaoke_mp4}" {env_mov_input} '
|
||||
f'{ffmpeg_filter} -map "[outv]" -map "[outa]" -c:v libx264 -c:a pcm_s16le '
|
||||
f'{mp4_flags} "{final_video}"'
|
||||
)
|
||||
|
||||
self.logger.info(f"Creating MP4 version with PCM audio: {lossless_mp4_command}")
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
lossless_mp4_command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
await process.communicate()
|
||||
|
||||
# Create lossy MP4
|
||||
lossy_mp4_command = (
|
||||
f'{ffmpeg_base_command} -i "{final_video}" '
|
||||
f'-c:v copy -c:a {self.aac_codec} -b:a 320k {mp4_flags} "{final_video_lossy}"'
|
||||
)
|
||||
|
||||
self.logger.info(f"Creating MP4 version with AAC audio: {lossy_mp4_command}")
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
lossy_mp4_command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
await process.communicate()
|
||||
|
||||
# Create MKV with FLAC audio
|
||||
mkv_command = (
|
||||
f'{ffmpeg_base_command} -i "{final_video}" '
|
||||
f'-c:v copy -c:a flac "{final_video_mkv}"'
|
||||
)
|
||||
|
||||
self.logger.info(f"Creating MKV version with FLAC audio: {mkv_command}")
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
mkv_command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
await process.communicate()
|
||||
|
||||
# Create 720p MP4
|
||||
mp4_720p_command = (
|
||||
f'{ffmpeg_base_command} -i "{final_video}" '
|
||||
f'-c:v libx264 -vf "scale=1280:720" -b:v 200k -preset medium -tune animation '
|
||||
f'-c:a {self.aac_codec} -b:a 128k {mp4_flags} "{final_video_720p}"'
|
||||
)
|
||||
|
||||
self.logger.info(f"Creating 720p version: {mp4_720p_command}")
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
mp4_720p_command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
await process.communicate()
|
||||
|
||||
# Update track with file paths
|
||||
track.final_video = final_video
|
||||
track.final_video_mkv = final_video_mkv
|
||||
track.final_video_lossy = final_video_lossy
|
||||
track.final_video_720p = final_video_720p
|
||||
|
||||
return track
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to remux and encode output video files: {str(e)}")
|
||||
raise DistributionError(f"Failed to remux and encode output video files: {str(e)}")
|
||||
|
||||
def _detect_best_aac_codec(self) -> str:
|
||||
"""
|
||||
Detect the best available AAC codec (aac_at > libfdk_aac > aac).
|
||||
|
||||
Returns:
|
||||
The best available AAC codec
|
||||
"""
|
||||
self.logger.info("Detecting best available AAC codec...")
|
||||
|
||||
if self.config.dry_run:
|
||||
self.logger.info("DRY RUN: Would detect best available AAC codec")
|
||||
return "aac"
|
||||
|
||||
try:
|
||||
# Run ffmpeg -codecs to get available codecs
|
||||
codec_check_command = "ffmpeg -codecs"
|
||||
result = subprocess.run(codec_check_command, shell=True, capture_output=True, text=True)
|
||||
output = result.stdout
|
||||
|
||||
if "aac_at" in output:
|
||||
self.logger.info("Using aac_at codec (best quality)")
|
||||
return "aac_at"
|
||||
elif "libfdk_aac" in output:
|
||||
self.logger.info("Using libfdk_aac codec (good quality)")
|
||||
return "libfdk_aac"
|
||||
else:
|
||||
self.logger.info("Using built-in aac codec (basic quality)")
|
||||
return "aac"
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to detect best AAC codec: {str(e)}")
|
||||
return "aac"
|
||||
@@ -0,0 +1,116 @@
|
||||
"""
|
||||
TXT file generation functionality for the distribution service.
|
||||
"""
|
||||
|
||||
import os
|
||||
import zipfile
|
||||
import logging
|
||||
from typing import Optional, Dict, Any
|
||||
|
||||
from lyrics_converter import LyricsConverter
|
||||
|
||||
from karaoke_gen.core.project import ProjectConfig
|
||||
from karaoke_gen.core.track import Track
|
||||
from karaoke_gen.core.exceptions import DistributionError
|
||||
|
||||
|
||||
class TXTGenerator:
|
||||
"""
|
||||
Class for handling TXT file generation.
|
||||
"""
|
||||
|
||||
def __init__(self, config: ProjectConfig):
|
||||
"""
|
||||
Initialize the TXT generator.
|
||||
|
||||
Args:
|
||||
config: The project configuration
|
||||
"""
|
||||
self.config = config
|
||||
self.logger = config.logger or logging.getLogger(__name__)
|
||||
|
||||
def create_txt_zip_file(self, track: Track) -> Track:
|
||||
"""
|
||||
Create a TXT zip file for the track.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated TXT zip file information
|
||||
|
||||
Raises:
|
||||
DistributionError: If creating the TXT zip file fails
|
||||
"""
|
||||
self.logger.info(f"Creating TXT ZIP file...")
|
||||
|
||||
if not self.config.enable_txt:
|
||||
self.logger.warning("TXT generation not enabled, skipping")
|
||||
return track
|
||||
|
||||
if not track.processed_lyrics:
|
||||
self.logger.warning("No processed lyrics available, cannot create TXT file")
|
||||
return track
|
||||
|
||||
# Determine the output file paths
|
||||
txt_zip_file = os.path.join(track.track_output_dir, f"{track.base_name} (Final Karaoke TXT).zip")
|
||||
txt_file = os.path.join(track.track_output_dir, f"{track.base_name} (Karaoke).txt")
|
||||
mp3_file = os.path.join(track.track_output_dir, f"{track.base_name} (Karaoke).mp3")
|
||||
lrc_file = os.path.join(track.track_output_dir, f"{track.base_name} (Karaoke).lrc")
|
||||
|
||||
# Check if TXT file already exists, if so, ask user to overwrite or skip
|
||||
if os.path.isfile(txt_zip_file):
|
||||
if self.config.non_interactive:
|
||||
self.logger.info(f"Non-interactive mode, automatically overwriting existing TXT ZIP file: {txt_zip_file}")
|
||||
else:
|
||||
from karaoke_gen.utils.validation import prompt_user_bool
|
||||
if not prompt_user_bool(
|
||||
f"Found existing TXT ZIP file: {txt_zip_file}. Overwrite (y) or skip (n)?",
|
||||
):
|
||||
self.logger.info(f"Skipping TXT ZIP file creation, existing file will be used.")
|
||||
track.final_karaoke_txt_zip = txt_zip_file
|
||||
return track
|
||||
|
||||
if self.config.dry_run:
|
||||
self.logger.info(f"DRY RUN: Would create TXT ZIP file: {txt_zip_file}")
|
||||
track.final_karaoke_txt_zip = txt_zip_file
|
||||
return track
|
||||
|
||||
try:
|
||||
# Create the LRC file if it doesn't exist
|
||||
if not os.path.isfile(lrc_file) and track.processed_lyrics:
|
||||
with open(lrc_file, "w", encoding="utf-8") as f:
|
||||
f.write(track.processed_lyrics)
|
||||
|
||||
# Convert LRC to TXT format
|
||||
self.logger.info(f"Running karaoke-converter to convert MidiCo LRC file {lrc_file} to TXT format")
|
||||
txt_converter = LyricsConverter(output_format="txt", filepath=lrc_file)
|
||||
converted_txt = txt_converter.convert_file()
|
||||
|
||||
# Write the TXT file
|
||||
with open(txt_file, "w", encoding="utf-8") as txt_file_handle:
|
||||
txt_file_handle.write(converted_txt)
|
||||
self.logger.info(f"TXT file written: {txt_file}")
|
||||
|
||||
# Ensure the MP3 file exists
|
||||
if not os.path.isfile(mp3_file):
|
||||
self.logger.warning(f"MP3 file not found: {mp3_file}, cannot create TXT ZIP file")
|
||||
return track
|
||||
|
||||
# Create the ZIP file containing the MP3 and TXT files
|
||||
self.logger.info(f"Creating ZIP file containing {mp3_file} and {txt_file}")
|
||||
with zipfile.ZipFile(txt_zip_file, "w") as zipf:
|
||||
zipf.write(mp3_file, os.path.basename(mp3_file))
|
||||
zipf.write(txt_file, os.path.basename(txt_file))
|
||||
|
||||
# Verify the TXT ZIP file was created
|
||||
if not os.path.isfile(txt_zip_file):
|
||||
raise DistributionError(f"Failed to create TXT ZIP file: {txt_zip_file}")
|
||||
|
||||
self.logger.info(f"TXT ZIP file created: {txt_zip_file}")
|
||||
track.final_karaoke_txt_zip = txt_zip_file
|
||||
return track
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to create TXT ZIP file: {str(e)}")
|
||||
raise DistributionError(f"Failed to create TXT ZIP file: {str(e)}")
|
||||
@@ -0,0 +1,327 @@
|
||||
"""
|
||||
YouTube uploading functionality for the distribution service.
|
||||
"""
|
||||
|
||||
import os
|
||||
import pickle
|
||||
import logging
|
||||
from typing import Optional, Dict, Any, List, Tuple
|
||||
|
||||
from google_auth_oauthlib.flow import InstalledAppFlow
|
||||
from google.auth.transport.requests import Request
|
||||
from googleapiclient.discovery import build
|
||||
from googleapiclient.http import MediaFileUpload
|
||||
from google.oauth2.credentials import Credentials
|
||||
from thefuzz import fuzz
|
||||
|
||||
from karaoke_gen.core.project import ProjectConfig
|
||||
from karaoke_gen.core.exceptions import YouTubeError
|
||||
|
||||
|
||||
class YouTubeUploader:
|
||||
"""
|
||||
Class for handling YouTube uploads and related operations.
|
||||
"""
|
||||
|
||||
def __init__(self, config: ProjectConfig):
|
||||
"""
|
||||
Initialize the YouTube uploader.
|
||||
|
||||
Args:
|
||||
config: The project configuration
|
||||
"""
|
||||
self.config = config
|
||||
self.logger = config.logger or logging.getLogger(__name__)
|
||||
self.youtube_url_prefix = "https://www.youtube.com/watch?v="
|
||||
self.youtube_token_file = "/tmp/karaoke-finalise-youtube-token.pickle"
|
||||
|
||||
def authenticate_youtube(self) -> Any:
|
||||
"""
|
||||
Authenticate and return a YouTube service object.
|
||||
|
||||
Returns:
|
||||
The authenticated YouTube service
|
||||
|
||||
Raises:
|
||||
YouTubeError: If authentication fails
|
||||
"""
|
||||
self.logger.info("Authenticating with YouTube...")
|
||||
|
||||
if self.config.dry_run:
|
||||
self.logger.info("DRY RUN: Would authenticate with YouTube")
|
||||
return None
|
||||
|
||||
try:
|
||||
credentials = None
|
||||
|
||||
# Token file stores the user's access and refresh tokens for YouTube.
|
||||
if os.path.exists(self.youtube_token_file):
|
||||
with open(self.youtube_token_file, "rb") as token:
|
||||
credentials = pickle.load(token)
|
||||
|
||||
# If there are no valid credentials, let the user log in.
|
||||
if not credentials or not credentials.valid:
|
||||
if credentials and credentials.expired and credentials.refresh_token:
|
||||
credentials.refresh(Request())
|
||||
else:
|
||||
flow = InstalledAppFlow.from_client_secrets_file(
|
||||
self.config.youtube_client_secrets_file,
|
||||
scopes=["https://www.googleapis.com/auth/youtube"]
|
||||
)
|
||||
credentials = flow.run_local_server(port=0) # This will open a browser for authentication
|
||||
|
||||
# Save the credentials for the next run
|
||||
with open(self.youtube_token_file, "wb") as token:
|
||||
pickle.dump(credentials, token)
|
||||
|
||||
return build("youtube", "v3", credentials=credentials)
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to authenticate with YouTube: {str(e)}")
|
||||
raise YouTubeError(f"Failed to authenticate with YouTube: {str(e)}")
|
||||
|
||||
def get_channel_id(self) -> Optional[str]:
|
||||
"""
|
||||
Get the authenticated user's channel ID.
|
||||
|
||||
Returns:
|
||||
The channel ID or None if not found
|
||||
|
||||
Raises:
|
||||
YouTubeError: If getting the channel ID fails
|
||||
"""
|
||||
self.logger.info("Getting YouTube channel ID...")
|
||||
|
||||
if self.config.dry_run:
|
||||
self.logger.info("DRY RUN: Would get YouTube channel ID")
|
||||
return "DUMMY_CHANNEL_ID"
|
||||
|
||||
try:
|
||||
youtube = self.authenticate_youtube()
|
||||
|
||||
# Get the authenticated user's channel
|
||||
request = youtube.channels().list(part="snippet", mine=True)
|
||||
response = request.execute()
|
||||
|
||||
# Extract the channel ID
|
||||
if "items" in response:
|
||||
channel_id = response["items"][0]["id"]
|
||||
self.logger.info(f"Found YouTube channel ID: {channel_id}")
|
||||
return channel_id
|
||||
else:
|
||||
self.logger.warning("No YouTube channel found for the authenticated user")
|
||||
return None
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to get YouTube channel ID: {str(e)}")
|
||||
raise YouTubeError(f"Failed to get YouTube channel ID: {str(e)}")
|
||||
|
||||
def check_if_video_title_exists(self, youtube_title: str) -> Tuple[bool, Optional[str]]:
|
||||
"""
|
||||
Check if a video with the given title already exists on the authenticated user's channel.
|
||||
|
||||
Args:
|
||||
youtube_title: The title to check
|
||||
|
||||
Returns:
|
||||
A tuple of (exists, video_id) where exists is True if the video exists and video_id is the ID of the video
|
||||
|
||||
Raises:
|
||||
YouTubeError: If checking for the video fails
|
||||
"""
|
||||
self.logger.info(f"Checking if video with title '{youtube_title}' exists on YouTube channel...")
|
||||
|
||||
if self.config.dry_run:
|
||||
self.logger.info(f"DRY RUN: Would check if video with title '{youtube_title}' exists on YouTube channel")
|
||||
return False, None
|
||||
|
||||
try:
|
||||
youtube = self.authenticate_youtube()
|
||||
channel_id = self.get_channel_id()
|
||||
|
||||
if not channel_id:
|
||||
self.logger.warning("No YouTube channel ID found, cannot check for existing videos")
|
||||
return False, None
|
||||
|
||||
self.logger.info(f"Searching YouTube channel {channel_id} for title: {youtube_title}")
|
||||
request = youtube.search().list(
|
||||
part="snippet",
|
||||
channelId=channel_id,
|
||||
q=youtube_title,
|
||||
type="video",
|
||||
maxResults=10
|
||||
)
|
||||
response = request.execute()
|
||||
|
||||
# Check if any videos were found
|
||||
if "items" in response and len(response["items"]) > 0:
|
||||
for item in response["items"]:
|
||||
found_title = item["snippet"]["title"]
|
||||
similarity_score = fuzz.ratio(youtube_title.lower(), found_title.lower())
|
||||
if similarity_score >= 70: # 70% similarity
|
||||
found_id = item["id"]["videoId"]
|
||||
self.logger.info(
|
||||
f"Potential match found on YouTube channel with ID: {found_id} and title: {found_title} (similarity: {similarity_score}%)"
|
||||
)
|
||||
|
||||
# In non-interactive mode, automatically confirm if similarity is high enough
|
||||
if self.config.non_interactive:
|
||||
self.logger.info(f"Non-interactive mode, automatically confirming match with similarity score {similarity_score}%")
|
||||
return True, found_id
|
||||
|
||||
confirmation = input(f"Is '{found_title}' the video you are finalising? (y/n): ").strip().lower()
|
||||
if confirmation == "y":
|
||||
return True, found_id
|
||||
|
||||
self.logger.info(f"No matching video found with title: {youtube_title}")
|
||||
return False, None
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to check if video exists on YouTube: {str(e)}")
|
||||
raise YouTubeError(f"Failed to check if video exists on YouTube: {str(e)}")
|
||||
|
||||
def delete_youtube_video(self, video_id: str) -> bool:
|
||||
"""
|
||||
Delete a YouTube video by its ID.
|
||||
|
||||
Args:
|
||||
video_id: The YouTube video ID to delete
|
||||
|
||||
Returns:
|
||||
True if successful, False otherwise
|
||||
|
||||
Raises:
|
||||
YouTubeError: If deleting the video fails
|
||||
"""
|
||||
self.logger.info(f"Deleting YouTube video with ID: {video_id}")
|
||||
|
||||
if self.config.dry_run:
|
||||
self.logger.info(f"DRY RUN: Would delete YouTube video with ID: {video_id}")
|
||||
return True
|
||||
|
||||
try:
|
||||
youtube = self.authenticate_youtube()
|
||||
youtube.videos().delete(id=video_id).execute()
|
||||
self.logger.info(f"Successfully deleted YouTube video with ID: {video_id}")
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to delete YouTube video with ID {video_id}: {e}")
|
||||
return False
|
||||
|
||||
def truncate_to_nearest_word(self, title: str, max_length: int) -> str:
|
||||
"""
|
||||
Truncate a string to the nearest word within the maximum length.
|
||||
|
||||
Args:
|
||||
title: The string to truncate
|
||||
max_length: The maximum length
|
||||
|
||||
Returns:
|
||||
The truncated string
|
||||
"""
|
||||
if len(title) <= max_length:
|
||||
return title
|
||||
|
||||
truncated_title = title[:max_length].rsplit(" ", 1)[0]
|
||||
if len(truncated_title) < max_length:
|
||||
truncated_title += " ..."
|
||||
|
||||
return truncated_title
|
||||
|
||||
def upload_video(
|
||||
self,
|
||||
video_file: str,
|
||||
thumbnail_file: Optional[str],
|
||||
artist: str,
|
||||
title: str,
|
||||
replace_existing: bool = False
|
||||
) -> Optional[str]:
|
||||
"""
|
||||
Upload a video to YouTube with the given title and thumbnail.
|
||||
|
||||
Args:
|
||||
video_file: The path to the video file
|
||||
thumbnail_file: The path to the thumbnail file
|
||||
artist: The artist name
|
||||
title: The track title
|
||||
replace_existing: Whether to replace an existing video
|
||||
|
||||
Returns:
|
||||
The YouTube URL of the uploaded video or None if upload failed
|
||||
|
||||
Raises:
|
||||
YouTubeError: If uploading the video fails
|
||||
"""
|
||||
self.logger.info(f"Uploading video to YouTube: {video_file}")
|
||||
|
||||
if self.config.dry_run:
|
||||
self.logger.info(f"DRY RUN: Would upload {video_file} to YouTube with thumbnail {thumbnail_file}")
|
||||
return f"{self.youtube_url_prefix}DUMMY_VIDEO_ID"
|
||||
|
||||
try:
|
||||
youtube_title = f"{artist} - {title} (Karaoke)"
|
||||
|
||||
# Truncate title to the nearest whole word and add ellipsis if needed
|
||||
max_length = 95
|
||||
youtube_title = self.truncate_to_nearest_word(youtube_title, max_length)
|
||||
|
||||
# Check if video already exists
|
||||
exists, video_id = self.check_if_video_title_exists(youtube_title)
|
||||
if exists:
|
||||
if replace_existing:
|
||||
self.logger.info(f"Video already exists on YouTube, deleting before re-upload: {self.youtube_url_prefix}{video_id}")
|
||||
if self.delete_youtube_video(video_id):
|
||||
self.logger.info(f"Successfully deleted existing video, proceeding with upload")
|
||||
else:
|
||||
self.logger.error(f"Failed to delete existing video, aborting upload")
|
||||
return None
|
||||
else:
|
||||
self.logger.warning(f"Video already exists on YouTube, skipping upload: {self.youtube_url_prefix}{video_id}")
|
||||
return f"{self.youtube_url_prefix}{video_id}"
|
||||
|
||||
# Load description from file if available
|
||||
youtube_description = f"Karaoke version of {artist} - {title} created using karaoke-gen python package."
|
||||
if self.config.youtube_description_file and os.path.isfile(self.config.youtube_description_file):
|
||||
with open(self.config.youtube_description_file, "r") as f:
|
||||
youtube_description = f.read()
|
||||
|
||||
youtube_category_id = "10" # Category ID for Music
|
||||
youtube_keywords = ["karaoke", "music", "singing", "instrumental", "lyrics", artist, title]
|
||||
|
||||
self.logger.info(f"Authenticating with YouTube...")
|
||||
youtube = self.authenticate_youtube()
|
||||
|
||||
body = {
|
||||
"snippet": {
|
||||
"title": youtube_title,
|
||||
"description": youtube_description,
|
||||
"tags": youtube_keywords,
|
||||
"categoryId": youtube_category_id,
|
||||
},
|
||||
"status": {"privacyStatus": "public"},
|
||||
}
|
||||
|
||||
# Use MediaFileUpload to handle the video file
|
||||
media_file = MediaFileUpload(video_file, resumable=True)
|
||||
|
||||
# Call the API's videos.insert method to create and upload the video.
|
||||
self.logger.info(f"Uploading video to YouTube...")
|
||||
request = youtube.videos().insert(part="snippet,status", body=body, media_body=media_file)
|
||||
response = request.execute()
|
||||
|
||||
video_id = response.get("id")
|
||||
youtube_url = f"{self.youtube_url_prefix}{video_id}"
|
||||
self.logger.info(f"Uploaded video to YouTube: {youtube_url}")
|
||||
|
||||
# Uploading the thumbnail
|
||||
if thumbnail_file and os.path.isfile(thumbnail_file):
|
||||
media_thumbnail = MediaFileUpload(thumbnail_file, mimetype="image/jpeg")
|
||||
youtube.thumbnails().set(videoId=video_id, media_body=media_thumbnail).execute()
|
||||
self.logger.info(f"Uploaded thumbnail for video ID {video_id}")
|
||||
|
||||
return youtube_url
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to upload video to YouTube: {str(e)}")
|
||||
raise YouTubeError(f"Failed to upload video to YouTube: {str(e)}")
|
||||
@@ -0,0 +1,3 @@
|
||||
from karaoke_gen.services.lyrics.service import LyricsService
|
||||
from karaoke_gen.services.lyrics.transcriber import LyricsTranscriber
|
||||
from karaoke_gen.services.lyrics.formatter import LyricsFormatter
|
||||
@@ -0,0 +1,162 @@
|
||||
import os
|
||||
import glob
|
||||
import shutil
|
||||
import datetime
|
||||
from karaoke_gen.core.track import Track
|
||||
from karaoke_gen.core.exceptions import FormattingError
|
||||
|
||||
|
||||
class LyricsFormatter:
|
||||
"""
|
||||
Handles lyrics formatting and backup operations.
|
||||
"""
|
||||
|
||||
def __init__(self, config):
|
||||
"""
|
||||
Initialize the lyrics formatter.
|
||||
|
||||
Args:
|
||||
config: The project configuration
|
||||
"""
|
||||
self.config = config
|
||||
self.logger = config.logger
|
||||
|
||||
async def format_lyrics(self, track):
|
||||
"""
|
||||
Format lyrics for a track.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated formatting information
|
||||
"""
|
||||
self.logger.info(f"Formatting lyrics for {track.base_name}")
|
||||
|
||||
# Skip if no lyrics
|
||||
if not track.lyrics:
|
||||
self.logger.warning("No lyrics found, cannot format")
|
||||
return track
|
||||
|
||||
# Skip if already formatted
|
||||
if track.processed_lyrics and track.processed_lyrics.get("formatted_lyrics"):
|
||||
self.logger.info(f"Lyrics already formatted")
|
||||
return track
|
||||
|
||||
try:
|
||||
# Read lyrics file
|
||||
if isinstance(track.lyrics, str) and os.path.isfile(track.lyrics):
|
||||
with open(track.lyrics, "r", encoding="utf-8") as f:
|
||||
lyrics_text = f.read()
|
||||
else:
|
||||
lyrics_text = track.lyrics
|
||||
|
||||
# Format lyrics
|
||||
formatted_lyrics = self._format_lyrics_text(lyrics_text)
|
||||
|
||||
# Save formatted lyrics
|
||||
formatted_lyrics_file = os.path.join(track.track_output_dir, f"{track.base_name} (Formatted Lyrics).txt")
|
||||
if not self.config.dry_run:
|
||||
with open(formatted_lyrics_file, "w", encoding="utf-8") as f:
|
||||
f.write(formatted_lyrics)
|
||||
|
||||
# Update track
|
||||
if not track.processed_lyrics:
|
||||
track.processed_lyrics = {}
|
||||
|
||||
track.processed_lyrics["formatted_lyrics"] = formatted_lyrics
|
||||
track.processed_lyrics["formatted_lyrics_file"] = formatted_lyrics_file
|
||||
|
||||
return track
|
||||
|
||||
except Exception as e:
|
||||
raise FormattingError(f"Failed to format lyrics: {str(e)}") from e
|
||||
|
||||
def _format_lyrics_text(self, lyrics_text):
|
||||
"""
|
||||
Format lyrics text.
|
||||
|
||||
Args:
|
||||
lyrics_text: The lyrics text to format
|
||||
|
||||
Returns:
|
||||
The formatted lyrics text
|
||||
"""
|
||||
# Remove extra whitespace
|
||||
formatted_text = lyrics_text.strip()
|
||||
|
||||
# Split into lines
|
||||
lines = formatted_text.split("\n")
|
||||
|
||||
# Remove empty lines at the beginning and end
|
||||
while lines and not lines[0].strip():
|
||||
lines.pop(0)
|
||||
|
||||
while lines and not lines[-1].strip():
|
||||
lines.pop()
|
||||
|
||||
# Remove duplicate empty lines
|
||||
formatted_lines = []
|
||||
prev_empty = False
|
||||
for line in lines:
|
||||
is_empty = not line.strip()
|
||||
if not (is_empty and prev_empty):
|
||||
formatted_lines.append(line)
|
||||
prev_empty = is_empty
|
||||
|
||||
# Join lines
|
||||
formatted_text = "\n".join(formatted_lines)
|
||||
|
||||
return formatted_text
|
||||
|
||||
async def backup_existing_outputs(self, track):
|
||||
"""
|
||||
Backup existing outputs for a track.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated backup information
|
||||
"""
|
||||
self.logger.info(f"Backing up existing outputs for {track.base_name}")
|
||||
|
||||
# Create backup directory
|
||||
backup_dir = os.path.join(track.track_output_dir, "backup_" + self._get_timestamp())
|
||||
if not self.config.dry_run:
|
||||
os.makedirs(backup_dir, exist_ok=True)
|
||||
|
||||
# Find existing files to backup
|
||||
files_to_backup = []
|
||||
|
||||
# Lyrics files
|
||||
lyrics_files = glob.glob(os.path.join(track.track_output_dir, "*.lrc"))
|
||||
files_to_backup.extend(lyrics_files)
|
||||
|
||||
# Video files
|
||||
video_files = glob.glob(os.path.join(track.track_output_dir, "*.mkv"))
|
||||
video_files.extend(glob.glob(os.path.join(track.track_output_dir, "*.mp4")))
|
||||
files_to_backup.extend(video_files)
|
||||
|
||||
# Subtitle files
|
||||
subtitle_files = glob.glob(os.path.join(track.track_output_dir, "*.srt"))
|
||||
subtitle_files.extend(glob.glob(os.path.join(track.track_output_dir, "*.ass")))
|
||||
files_to_backup.extend(subtitle_files)
|
||||
|
||||
# Backup files
|
||||
for file_path in files_to_backup:
|
||||
if os.path.exists(file_path) and not self.config.dry_run:
|
||||
backup_path = os.path.join(backup_dir, os.path.basename(file_path))
|
||||
shutil.copy2(file_path, backup_path)
|
||||
self.logger.info(f"Backed up {file_path} to {backup_path}")
|
||||
|
||||
return track
|
||||
|
||||
def _get_timestamp(self):
|
||||
"""
|
||||
Get a timestamp string.
|
||||
|
||||
Returns:
|
||||
A timestamp string
|
||||
"""
|
||||
return datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
|
||||
@@ -0,0 +1,239 @@
|
||||
import logging
|
||||
import os
|
||||
import glob
|
||||
import shutil
|
||||
from typing import Dict, Any, Optional
|
||||
from karaoke_gen.core.project import ProjectConfig
|
||||
from karaoke_gen.core.track import Track
|
||||
from karaoke_gen.core.exceptions import LyricsError
|
||||
from karaoke_gen.services.lyrics.transcriber import LyricsTranscriber
|
||||
from karaoke_gen.services.lyrics.formatter import LyricsFormatter
|
||||
import datetime
|
||||
|
||||
|
||||
class LyricsService:
|
||||
"""
|
||||
Service for lyrics processing operations including transcription.
|
||||
"""
|
||||
|
||||
def __init__(self, config: ProjectConfig):
|
||||
"""
|
||||
Initialize the lyrics service.
|
||||
|
||||
Args:
|
||||
config: The project configuration
|
||||
"""
|
||||
self.config = config
|
||||
self.logger = config.logger or logging.getLogger(__name__)
|
||||
|
||||
# Initialize components
|
||||
self.transcriber = LyricsTranscriber(config)
|
||||
self.formatter = LyricsFormatter(config)
|
||||
|
||||
async def process_lyrics(self, track: Track) -> Track:
|
||||
"""
|
||||
Process lyrics for the track.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated lyrics information
|
||||
"""
|
||||
if self.config.skip_lyrics:
|
||||
self.logger.info(f"Skipping lyrics processing for {track.base_name}")
|
||||
return track
|
||||
|
||||
self.logger.info(f"Processing lyrics for {track.base_name}")
|
||||
|
||||
# Check for existing lyrics files
|
||||
track = await self._check_existing_lyrics(track)
|
||||
if track.processed_lyrics:
|
||||
self.logger.info("Found existing lyrics files, skipping transcription")
|
||||
return track
|
||||
|
||||
# The LyricsTranscriber library handles both fetching lyrics and transcribing,
|
||||
# so we don't need to do the fetching separately
|
||||
if not self.config.skip_transcription:
|
||||
track = await self.transcriber.transcribe_lyrics(track)
|
||||
|
||||
return track
|
||||
|
||||
async def _check_existing_lyrics(self, track: Track) -> Track:
|
||||
"""
|
||||
Check for existing lyrics files.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated lyrics information if existing files are found
|
||||
"""
|
||||
self.logger.info(f"Checking for existing lyrics files for {track.base_name}")
|
||||
|
||||
# Check for existing files in parent directory
|
||||
parent_video_path = os.path.join(track.track_output_dir, f"{track.base_name} (With Vocals).mkv")
|
||||
parent_lrc_path = os.path.join(track.track_output_dir, f"{track.base_name} (Karaoke).lrc")
|
||||
|
||||
# Check lyrics directory for existing files
|
||||
lyrics_dir = os.path.join(track.track_output_dir, "lyrics")
|
||||
lyrics_video_path = os.path.join(lyrics_dir, f"{track.base_name} (With Vocals).mkv")
|
||||
lyrics_lrc_path = os.path.join(lyrics_dir, f"{track.base_name} (Karaoke).lrc")
|
||||
|
||||
# If files exist in parent directory, use them
|
||||
if os.path.exists(parent_video_path) and os.path.exists(parent_lrc_path):
|
||||
self.logger.info(f"Found existing video and LRC files in parent directory")
|
||||
track.processed_lyrics = {
|
||||
"lrc_filepath": parent_lrc_path,
|
||||
"ass_filepath": parent_video_path,
|
||||
}
|
||||
return track
|
||||
|
||||
# If files exist in lyrics directory, copy to parent and use them
|
||||
if os.path.exists(lyrics_video_path) and os.path.exists(lyrics_lrc_path):
|
||||
self.logger.info(f"Found existing video and LRC files in lyrics directory, copying to parent")
|
||||
os.makedirs(track.track_output_dir, exist_ok=True)
|
||||
|
||||
# Copy files to parent directory
|
||||
shutil.copy2(lyrics_video_path, parent_video_path)
|
||||
shutil.copy2(lyrics_lrc_path, parent_lrc_path)
|
||||
|
||||
track.processed_lyrics = {
|
||||
"lrc_filepath": parent_lrc_path,
|
||||
"ass_filepath": parent_video_path,
|
||||
}
|
||||
return track
|
||||
|
||||
return track
|
||||
|
||||
async def backup_and_prepare_for_edit(self, track: Track) -> Track:
|
||||
"""
|
||||
Backup existing outputs and prepare for lyrics editing.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated backup information
|
||||
"""
|
||||
self.logger.info(f"Backing up and preparing for lyrics editing for {track.base_name}")
|
||||
|
||||
# Create backup directory
|
||||
backup_dir = os.path.join(track.track_output_dir, "backups")
|
||||
if not os.path.exists(backup_dir):
|
||||
os.makedirs(backup_dir)
|
||||
|
||||
# Create versioned backup directory
|
||||
timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
|
||||
version_dir = os.path.join(backup_dir, f"version_{timestamp}")
|
||||
os.makedirs(version_dir)
|
||||
|
||||
# Backup existing files
|
||||
files_to_backup = []
|
||||
|
||||
# Backup processed lyrics
|
||||
if track.processed_lyrics:
|
||||
for key, value in track.processed_lyrics.items():
|
||||
if isinstance(value, str) and os.path.isfile(value):
|
||||
files_to_backup.append(value)
|
||||
|
||||
# Backup videos
|
||||
for video_attr in ["video_with_lyrics", "final_video"]:
|
||||
video_path = getattr(track, video_attr, None)
|
||||
if video_path and os.path.isfile(video_path):
|
||||
files_to_backup.append(video_path)
|
||||
|
||||
# Copy files to backup directory
|
||||
for file_path in files_to_backup:
|
||||
backup_path = os.path.join(version_dir, os.path.basename(file_path))
|
||||
shutil.copy2(file_path, backup_path)
|
||||
self.logger.info(f"Backed up {file_path} to {backup_path}")
|
||||
|
||||
# Prepare input audio file for editing
|
||||
if track.instrumental and os.path.isfile(track.instrumental):
|
||||
edit_audio = os.path.join(track.track_output_dir, f"{track.base_name} (Edit).wav")
|
||||
shutil.copy2(track.instrumental, edit_audio)
|
||||
track.metadata["edit_audio"] = edit_audio
|
||||
self.logger.info(f"Prepared audio for editing: {edit_audio}")
|
||||
|
||||
# Store backup information
|
||||
track.metadata["backup_dir"] = backup_dir
|
||||
track.metadata["last_backup"] = version_dir
|
||||
|
||||
return track
|
||||
|
||||
async def cleanup(self):
|
||||
"""
|
||||
Perform cleanup operations for the lyrics service.
|
||||
"""
|
||||
self.logger.info("Cleaning up lyrics service resources")
|
||||
|
||||
# Close any open resources
|
||||
if hasattr(self, 'transcriber') and self.transcriber:
|
||||
await self.transcriber.cleanup()
|
||||
|
||||
if hasattr(self, 'formatter') and self.formatter:
|
||||
await self.formatter.cleanup()
|
||||
|
||||
self.logger.info("Lyrics service cleanup complete")
|
||||
|
||||
async def _find_input_audio_file(self, track: Track) -> Track:
|
||||
"""
|
||||
Find the input audio file for lyrics editing.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated input audio information
|
||||
"""
|
||||
self.logger.info(f"Finding input audio file for {track.base_name}")
|
||||
|
||||
# Look for WAV file
|
||||
wav_files = glob.glob(os.path.join(track.track_output_dir, "*.wav"))
|
||||
if wav_files:
|
||||
track.input_audio_wav = wav_files[0]
|
||||
self.logger.info(f"Found input audio file: {track.input_audio_wav}")
|
||||
return track
|
||||
|
||||
# Look for other audio files
|
||||
audio_extensions = ['.mp3', '.flac', '.ogg', '.m4a', '.aac']
|
||||
for ext in audio_extensions:
|
||||
audio_files = glob.glob(os.path.join(track.track_output_dir, f"*{ext}"))
|
||||
if audio_files:
|
||||
# Convert to WAV
|
||||
from karaoke_gen.services.audio.converter import AudioConverter
|
||||
converter = AudioConverter(self.config)
|
||||
track.input_media = audio_files[0]
|
||||
track = await converter.convert_to_wav(track)
|
||||
self.logger.info(f"Converted audio file to WAV: {track.input_audio_wav}")
|
||||
return track
|
||||
|
||||
self.logger.warning(f"No input audio file found for {track.base_name}")
|
||||
return track
|
||||
|
||||
def _get_timestamp(self) -> str:
|
||||
"""
|
||||
Get a timestamp string for backup directory naming.
|
||||
|
||||
Returns:
|
||||
A timestamp string
|
||||
"""
|
||||
return datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
|
||||
|
||||
def _sanitize_filename(self, filename: str) -> str:
|
||||
"""
|
||||
Sanitize a filename by removing invalid characters.
|
||||
|
||||
Args:
|
||||
filename: The filename to sanitize
|
||||
|
||||
Returns:
|
||||
The sanitized filename
|
||||
"""
|
||||
# Replace problematic characters with underscores
|
||||
for char in ["\\", "/", ":", "*", "?", '"', "<", ">", "|"]:
|
||||
filename = filename.replace(char, "_")
|
||||
# Remove any trailing periods or spaces
|
||||
filename = filename.rstrip(". ")
|
||||
return filename
|
||||
@@ -0,0 +1,177 @@
|
||||
import os
|
||||
import shutil
|
||||
from dotenv import load_dotenv
|
||||
from lyrics_transcriber import LyricsTranscriber as LyricsTranscriberLib
|
||||
from lyrics_transcriber import OutputConfig, TranscriberConfig, LyricsConfig
|
||||
from lyrics_transcriber.core.controller import LyricsControllerResult
|
||||
from karaoke_gen.core.track import Track
|
||||
from karaoke_gen.core.exceptions import TranscriptionError
|
||||
|
||||
|
||||
class LyricsTranscriber:
|
||||
"""
|
||||
Handles lyrics transcription and synchronization.
|
||||
"""
|
||||
|
||||
def __init__(self, config):
|
||||
"""
|
||||
Initialize the lyrics transcriber.
|
||||
|
||||
Args:
|
||||
config: The project configuration
|
||||
"""
|
||||
self.config = config
|
||||
self.logger = config.logger
|
||||
|
||||
async def transcribe_lyrics(self, track):
|
||||
"""
|
||||
Transcribe lyrics for a track.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated transcription information
|
||||
"""
|
||||
self.logger.info(f"Transcribing lyrics for {track.base_name}")
|
||||
|
||||
if not track.input_audio_wav or not os.path.exists(track.input_audio_wav):
|
||||
self.logger.warning("No input audio file found, cannot transcribe")
|
||||
return track
|
||||
|
||||
try:
|
||||
# Check for existing files first using sanitized names
|
||||
parent_video_path = os.path.join(track.track_output_dir, f"{track.base_name} (With Vocals).mkv")
|
||||
parent_lrc_path = os.path.join(track.track_output_dir, f"{track.base_name} (Karaoke).lrc")
|
||||
|
||||
# Check lyrics directory for existing files
|
||||
lyrics_dir = os.path.join(track.track_output_dir, "lyrics")
|
||||
lyrics_video_path = os.path.join(lyrics_dir, f"{track.base_name} (With Vocals).mkv")
|
||||
lyrics_lrc_path = os.path.join(lyrics_dir, f"{track.base_name} (Karaoke).lrc")
|
||||
|
||||
# If files exist in parent directory, return early
|
||||
if os.path.exists(parent_video_path) and os.path.exists(parent_lrc_path):
|
||||
self.logger.info(f"Found existing video and LRC files in parent directory, skipping transcription")
|
||||
track.processed_lyrics = {
|
||||
"lrc_filepath": parent_lrc_path,
|
||||
"ass_filepath": parent_video_path,
|
||||
}
|
||||
return track
|
||||
|
||||
# If files exist in lyrics directory, copy to parent and return
|
||||
if os.path.exists(lyrics_video_path) and os.path.exists(lyrics_lrc_path):
|
||||
self.logger.info(f"Found existing video and LRC files in lyrics directory, copying to parent")
|
||||
os.makedirs(track.track_output_dir, exist_ok=True)
|
||||
shutil.copy2(lyrics_video_path, parent_video_path)
|
||||
shutil.copy2(lyrics_lrc_path, parent_lrc_path)
|
||||
track.processed_lyrics = {
|
||||
"lrc_filepath": parent_lrc_path,
|
||||
"ass_filepath": parent_video_path,
|
||||
}
|
||||
return track
|
||||
|
||||
# Create lyrics subdirectory for new transcription
|
||||
os.makedirs(lyrics_dir, exist_ok=True)
|
||||
self.logger.info(f"Created lyrics directory: {lyrics_dir}")
|
||||
|
||||
# Load environment variables
|
||||
load_dotenv()
|
||||
env_config = {
|
||||
"audioshake_api_token": os.getenv("AUDIOSHAKE_API_TOKEN"),
|
||||
"genius_api_token": os.getenv("GENIUS_API_TOKEN"),
|
||||
"spotify_cookie": os.getenv("SPOTIFY_COOKIE_SP_DC"),
|
||||
"runpod_api_key": os.getenv("RUNPOD_API_KEY"),
|
||||
"whisper_runpod_id": os.getenv("WHISPER_RUNPOD_ID"),
|
||||
}
|
||||
|
||||
# Create config objects for LyricsTranscriber
|
||||
transcriber_config = TranscriberConfig(
|
||||
audioshake_api_token=env_config.get("audioshake_api_token"),
|
||||
)
|
||||
|
||||
# Get lyrics artist and title from config if specified
|
||||
lyrics_artist = self.config.lyrics_artist or track.artist
|
||||
lyrics_title = self.config.lyrics_title or track.title
|
||||
|
||||
lyrics_config = LyricsConfig(
|
||||
genius_api_token=env_config.get("genius_api_token"),
|
||||
spotify_cookie=env_config.get("spotify_cookie"),
|
||||
lyrics_file=self.config.lyrics_file,
|
||||
)
|
||||
|
||||
output_config = OutputConfig(
|
||||
output_styles_json=self.config.style_params_json,
|
||||
output_dir=lyrics_dir,
|
||||
render_video=self.config.render_video,
|
||||
fetch_lyrics=True,
|
||||
run_transcription=not self.config.skip_transcription,
|
||||
run_correction=True,
|
||||
generate_plain_text=True,
|
||||
generate_lrc=True,
|
||||
generate_cdg=True,
|
||||
video_resolution="4k",
|
||||
enable_review=not self.config.skip_transcription_review,
|
||||
subtitle_offset_ms=self.config.subtitle_offset_ms,
|
||||
)
|
||||
|
||||
# Add this log entry to debug the OutputConfig
|
||||
self.logger.info(f"Instantiating LyricsTranscriber with OutputConfig: {output_config}")
|
||||
|
||||
# Initialize transcriber with new config objects
|
||||
transcriber = LyricsTranscriberLib(
|
||||
audio_filepath=track.input_audio_wav,
|
||||
artist=lyrics_artist,
|
||||
title=lyrics_title,
|
||||
transcriber_config=transcriber_config,
|
||||
lyrics_config=lyrics_config,
|
||||
output_config=output_config,
|
||||
logger=self.logger,
|
||||
)
|
||||
|
||||
# Process and get results
|
||||
results: LyricsControllerResult = transcriber.process()
|
||||
self.logger.info(f"Transcriber Results Filepaths:")
|
||||
for key, value in results.__dict__.items():
|
||||
if key.endswith("_filepath"):
|
||||
self.logger.info(f" {key}: {value}")
|
||||
|
||||
# Build output dictionary
|
||||
transcriber_outputs = {}
|
||||
if results.lrc_filepath:
|
||||
transcriber_outputs["lrc_filepath"] = results.lrc_filepath
|
||||
self.logger.info(f"Moving LRC file from {results.lrc_filepath} to {parent_lrc_path}")
|
||||
shutil.copy2(results.lrc_filepath, parent_lrc_path)
|
||||
|
||||
if results.video_filepath:
|
||||
transcriber_outputs["video_filepath"] = results.video_filepath
|
||||
self.logger.info(f"Moving video file from {results.video_filepath} to {parent_video_path}")
|
||||
shutil.copy2(results.video_filepath, parent_video_path)
|
||||
|
||||
if results.ass_filepath:
|
||||
transcriber_outputs["ass_filepath"] = results.ass_filepath
|
||||
|
||||
if results.transcription_corrected:
|
||||
transcriber_outputs["corrected_lyrics_text"] = "\n".join(
|
||||
segment.text for segment in results.transcription_corrected.corrected_segments
|
||||
)
|
||||
transcriber_outputs["corrected_lyrics_text_filepath"] = results.corrected_txt
|
||||
|
||||
if transcriber_outputs:
|
||||
self.logger.info(f"*** Transcriber Filepath Outputs: ***")
|
||||
for key, value in transcriber_outputs.items():
|
||||
if key.endswith("_filepath"):
|
||||
self.logger.info(f" {key}: {value}")
|
||||
|
||||
track.processed_lyrics = transcriber_outputs
|
||||
return track
|
||||
|
||||
except Exception as e:
|
||||
raise TranscriptionError(f"Failed to transcribe lyrics: {str(e)}") from e
|
||||
|
||||
async def cleanup(self):
|
||||
"""
|
||||
Perform cleanup operations for the transcriber.
|
||||
"""
|
||||
self.logger.info("Cleaning up transcriber resources")
|
||||
# No resources to clean up currently
|
||||
pass
|
||||
@@ -0,0 +1,152 @@
|
||||
import os
|
||||
import asyncio
|
||||
import logging
|
||||
from typing import List, Optional
|
||||
from karaoke_gen.core.track import Track
|
||||
from karaoke_gen.services.audio.service import AudioService
|
||||
from karaoke_gen.services.lyrics.service import LyricsService
|
||||
from karaoke_gen.services.video.service import VideoService
|
||||
|
||||
|
||||
class MainService:
|
||||
"""
|
||||
Main service for orchestrating the entire karaoke preparation process.
|
||||
"""
|
||||
|
||||
def __init__(self, config):
|
||||
"""
|
||||
Initialize the karaoke service.
|
||||
|
||||
Args:
|
||||
config: The project configuration
|
||||
"""
|
||||
self.config = config
|
||||
self.logger = config.logger
|
||||
|
||||
# Initialize component services
|
||||
self.audio_service = AudioService(config)
|
||||
self.lyrics_service = LyricsService(config)
|
||||
self.video_service = VideoService(config)
|
||||
|
||||
async def process_track(self, track: Track) -> Track:
|
||||
"""
|
||||
Process a single track through the entire karaoke preparation pipeline.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The processed track
|
||||
"""
|
||||
self.logger.info(f"Processing track: {track.base_name}")
|
||||
|
||||
try:
|
||||
# Create output directory if it doesn't exist
|
||||
if not os.path.exists(track.track_output_dir):
|
||||
os.makedirs(track.track_output_dir)
|
||||
|
||||
# Process audio
|
||||
track = await self.audio_service.process_audio(track)
|
||||
|
||||
# Process lyrics
|
||||
track = await self.lyrics_service.process_lyrics(track)
|
||||
|
||||
# Process video
|
||||
track = await self.video_service.process_video(track)
|
||||
|
||||
self.logger.info(f"Successfully processed track: {track.base_name}")
|
||||
return track
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to process track {track.base_name}: {str(e)}")
|
||||
return track
|
||||
|
||||
async def process_tracks(self, tracks: List[Track]) -> List[Track]:
|
||||
"""
|
||||
Process multiple tracks through the entire karaoke preparation pipeline.
|
||||
|
||||
Args:
|
||||
tracks: The list of tracks to process
|
||||
|
||||
Returns:
|
||||
The list of processed tracks
|
||||
"""
|
||||
self.logger.info(f"Processing {len(tracks)} tracks")
|
||||
|
||||
processed_tracks = []
|
||||
|
||||
# Process tracks sequentially or in parallel based on configuration
|
||||
if self.config.parallel_processing:
|
||||
# Process tracks in parallel with a limit on concurrency
|
||||
semaphore = asyncio.Semaphore(self.config.max_concurrent_tracks)
|
||||
|
||||
async def process_with_semaphore(track):
|
||||
async with semaphore:
|
||||
return await self.process_track(track)
|
||||
|
||||
tasks = [process_with_semaphore(track) for track in tracks]
|
||||
processed_tracks = await asyncio.gather(*tasks)
|
||||
else:
|
||||
# Process tracks sequentially
|
||||
for track in tracks:
|
||||
processed_track = await self.process_track(track)
|
||||
processed_tracks.append(processed_track)
|
||||
|
||||
self.logger.info(f"Finished processing {len(processed_tracks)} tracks")
|
||||
return processed_tracks
|
||||
|
||||
async def cleanup(self):
|
||||
"""
|
||||
Perform cleanup operations after processing is complete.
|
||||
"""
|
||||
self.logger.info("Performing cleanup operations")
|
||||
|
||||
# Cleanup temporary files if configured
|
||||
if self.config.cleanup_temp_files:
|
||||
self.logger.info("Cleaning up temporary files")
|
||||
# Implement cleanup logic here
|
||||
|
||||
# Close any open resources
|
||||
await self.audio_service.cleanup()
|
||||
await self.lyrics_service.cleanup()
|
||||
await self.video_service.cleanup()
|
||||
|
||||
self.logger.info("Cleanup complete")
|
||||
|
||||
def get_summary(self, tracks: List[Track]) -> str:
|
||||
"""
|
||||
Generate a summary of the processed tracks.
|
||||
|
||||
Args:
|
||||
tracks: The list of processed tracks
|
||||
|
||||
Returns:
|
||||
A summary string
|
||||
"""
|
||||
summary = []
|
||||
summary.append(f"Processed {len(tracks)} tracks:")
|
||||
|
||||
for track in tracks:
|
||||
track_summary = f"- {track.base_name}:"
|
||||
|
||||
# Add audio processing summary
|
||||
if track.instrumental:
|
||||
track_summary += " [Audio: ✓]"
|
||||
else:
|
||||
track_summary += " [Audio: ✗]"
|
||||
|
||||
# Add lyrics processing summary
|
||||
if track.processed_lyrics:
|
||||
track_summary += " [Lyrics: ✓]"
|
||||
else:
|
||||
track_summary += " [Lyrics: ✗]"
|
||||
|
||||
# Add video processing summary
|
||||
if track.final_video:
|
||||
track_summary += " [Video: ✓]"
|
||||
else:
|
||||
track_summary += " [Video: ✗]"
|
||||
|
||||
summary.append(track_summary)
|
||||
|
||||
return "\n".join(summary)
|
||||
@@ -0,0 +1,3 @@
|
||||
from karaoke_gen.services.media.service import MediaService
|
||||
from karaoke_gen.services.media.downloader import MediaDownloader
|
||||
from karaoke_gen.services.media.extractor import MediaExtractor
|
||||
@@ -0,0 +1,167 @@
|
||||
import os
|
||||
import asyncio
|
||||
import mimetypes
|
||||
from karaoke_gen.core.track import Track
|
||||
from karaoke_gen.core.exceptions import MediaError
|
||||
|
||||
|
||||
class MediaDetector:
|
||||
"""
|
||||
Handles detecting media types.
|
||||
"""
|
||||
|
||||
def __init__(self, config):
|
||||
"""
|
||||
Initialize the media detector.
|
||||
|
||||
Args:
|
||||
config: The project configuration
|
||||
"""
|
||||
self.config = config
|
||||
self.logger = config.logger
|
||||
|
||||
# Initialize mimetypes
|
||||
mimetypes.init()
|
||||
|
||||
async def detect_media_type(self, file_path):
|
||||
"""
|
||||
Detect the type of a media file.
|
||||
|
||||
Args:
|
||||
file_path: The path to the media file
|
||||
|
||||
Returns:
|
||||
The media type (audio, video, image, or unknown)
|
||||
"""
|
||||
self.logger.debug(f"Detecting media type for {file_path}")
|
||||
|
||||
if not os.path.isfile(file_path):
|
||||
raise MediaError(f"File not found: {file_path}")
|
||||
|
||||
# Get file extension
|
||||
_, ext = os.path.splitext(file_path)
|
||||
ext = ext.lower()
|
||||
|
||||
# Check file extension
|
||||
if ext in ['.mp3', '.wav', '.flac', '.ogg', '.m4a', '.aac']:
|
||||
self.logger.debug(f"Detected audio file by extension: {ext}")
|
||||
return "audio"
|
||||
elif ext in ['.mp4', '.avi', '.mov', '.mkv', '.webm', '.flv', '.wmv', '.m4v']:
|
||||
self.logger.debug(f"Detected video file by extension: {ext}")
|
||||
return "video"
|
||||
elif ext in ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.tiff']:
|
||||
self.logger.debug(f"Detected image file by extension: {ext}")
|
||||
return "image"
|
||||
|
||||
# Check mimetype
|
||||
mime_type, _ = mimetypes.guess_type(file_path)
|
||||
if mime_type:
|
||||
if mime_type.startswith('audio/'):
|
||||
self.logger.debug(f"Detected audio file by mimetype: {mime_type}")
|
||||
return "audio"
|
||||
elif mime_type.startswith('video/'):
|
||||
self.logger.debug(f"Detected video file by mimetype: {mime_type}")
|
||||
return "video"
|
||||
elif mime_type.startswith('image/'):
|
||||
self.logger.debug(f"Detected image file by mimetype: {mime_type}")
|
||||
return "image"
|
||||
|
||||
# Use ffprobe as a fallback
|
||||
media_type = await self._detect_media_type_with_ffprobe(file_path)
|
||||
if media_type:
|
||||
self.logger.debug(f"Detected {media_type} file with ffprobe")
|
||||
return media_type
|
||||
|
||||
self.logger.warning(f"Could not detect media type for {file_path}")
|
||||
return "unknown"
|
||||
|
||||
async def _detect_media_type_with_ffprobe(self, file_path):
|
||||
"""
|
||||
Detect the type of a media file using ffprobe.
|
||||
|
||||
Args:
|
||||
file_path: The path to the media file
|
||||
|
||||
Returns:
|
||||
The media type (audio, video, image, or None if detection failed)
|
||||
"""
|
||||
# Build ffprobe command
|
||||
command = f'ffprobe -v error -show_entries stream=codec_type -of default=noprint_wrappers=1 "{file_path}"'
|
||||
|
||||
try:
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
stdout, stderr = await process.communicate()
|
||||
|
||||
if process.returncode != 0:
|
||||
self.logger.debug(f"ffprobe failed: {stderr.decode()}")
|
||||
return None
|
||||
|
||||
output = stdout.decode()
|
||||
|
||||
if "codec_type=video" in output and "codec_type=audio" in output:
|
||||
return "video"
|
||||
elif "codec_type=audio" in output:
|
||||
return "audio"
|
||||
elif "codec_type=video" in output:
|
||||
# Check if it's a single frame (image) or a video
|
||||
duration_command = f'ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 "{file_path}"'
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
duration_command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
stdout, stderr = await process.communicate()
|
||||
|
||||
if process.returncode == 0:
|
||||
try:
|
||||
duration = float(stdout.decode().strip())
|
||||
if duration < 0.1: # Very short duration, likely an image
|
||||
return "image"
|
||||
else:
|
||||
return "video"
|
||||
except (ValueError, TypeError):
|
||||
pass
|
||||
|
||||
return "video" # Default to video if duration check fails
|
||||
|
||||
return None
|
||||
|
||||
except Exception as e:
|
||||
self.logger.debug(f"Error detecting media type with ffprobe: {str(e)}")
|
||||
return None
|
||||
|
||||
async def detect_media_info(self, track: Track) -> Track:
|
||||
"""
|
||||
Detect media information for the track.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated media information
|
||||
"""
|
||||
self.logger.info(f"Detecting media info for {track.base_name}")
|
||||
|
||||
# Detect media type for input media
|
||||
if track.input_media and os.path.isfile(track.input_media):
|
||||
media_type = await self.detect_media_type(track.input_media)
|
||||
track.input_media_type = media_type
|
||||
self.logger.info(f"Detected input media type: {media_type}")
|
||||
|
||||
# Detect media type for input audio
|
||||
if track.input_audio_wav and os.path.isfile(track.input_audio_wav):
|
||||
media_type = await self.detect_media_type(track.input_audio_wav)
|
||||
track.input_audio_type = media_type
|
||||
self.logger.info(f"Detected input audio type: {media_type}")
|
||||
|
||||
# Detect media type for input still image
|
||||
if track.input_still_image and os.path.isfile(track.input_still_image):
|
||||
media_type = await self.detect_media_type(track.input_still_image)
|
||||
track.input_image_type = media_type
|
||||
self.logger.info(f"Detected input image type: {media_type}")
|
||||
|
||||
return track
|
||||
@@ -0,0 +1,231 @@
|
||||
import os
|
||||
import asyncio
|
||||
import re
|
||||
import yt_dlp
|
||||
from karaoke_gen.core.track import Track
|
||||
from karaoke_gen.core.exceptions import DownloadError
|
||||
|
||||
|
||||
class MediaDownloader:
|
||||
"""
|
||||
Handles downloading media from URLs.
|
||||
"""
|
||||
|
||||
def __init__(self, config):
|
||||
"""
|
||||
Initialize the media downloader.
|
||||
|
||||
Args:
|
||||
config: The project configuration
|
||||
"""
|
||||
self.config = config
|
||||
self.logger = config.logger
|
||||
|
||||
async def download_media(self, track):
|
||||
"""
|
||||
Download media from a URL.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated media information
|
||||
"""
|
||||
self.logger.info(f"Downloading media from {track.input_media}")
|
||||
|
||||
if not track.is_url:
|
||||
self.logger.warning(f"Input media is not a URL: {track.input_media}")
|
||||
return track
|
||||
|
||||
try:
|
||||
# Extract info for online media
|
||||
track = await self._extract_info_for_online_media(track)
|
||||
|
||||
# Download the video with extractor and media_id in the filename
|
||||
output_filename = f"{self._sanitize_filename(track.base_name)} ({track.extractor}"
|
||||
|
||||
# Add media_id if available
|
||||
if track.media_id:
|
||||
output_filename += f" {track.media_id}"
|
||||
|
||||
output_filename += ")"
|
||||
|
||||
output_filename_no_extension = os.path.join(
|
||||
track.track_output_dir,
|
||||
output_filename
|
||||
)
|
||||
|
||||
downloaded_file = await self._download_video(track.input_media, output_filename_no_extension)
|
||||
|
||||
# Update track information
|
||||
track.input_media = downloaded_file
|
||||
|
||||
return track
|
||||
|
||||
except Exception as e:
|
||||
raise DownloadError(f"Failed to download media: {str(e)}") from e
|
||||
|
||||
async def _extract_info_for_online_media(self, track):
|
||||
"""
|
||||
Extract information for online media.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated information
|
||||
"""
|
||||
self.logger.info(f"Extracting info for online media: {track.input_media}")
|
||||
|
||||
# Skip artist and title extraction if already provided
|
||||
extract_metadata = not (track.artist and track.title)
|
||||
|
||||
# Extract info from URL
|
||||
try:
|
||||
ydl_opts = {
|
||||
"quiet": True,
|
||||
"no_warnings": True,
|
||||
"extract_flat": "in_playlist",
|
||||
"skip_download": True,
|
||||
}
|
||||
|
||||
with yt_dlp.YoutubeDL(ydl_opts) as ydl_instance:
|
||||
info = ydl_instance.extract_info(track.input_media, download=False)
|
||||
|
||||
# Handle playlists
|
||||
if "entries" in info:
|
||||
# Get the first video in the playlist
|
||||
if not info["entries"]:
|
||||
raise DownloadError("Playlist is empty")
|
||||
|
||||
info = info["entries"][0]
|
||||
|
||||
# Extract extractor and media_id (always do this)
|
||||
if "extractor_key" in info:
|
||||
track.extractor = info["extractor_key"]
|
||||
elif "ie_key" in info:
|
||||
track.extractor = info["ie_key"]
|
||||
else:
|
||||
self.logger.warning("Could not extract extractor from media info")
|
||||
|
||||
if "id" in info:
|
||||
track.media_id = info["id"]
|
||||
|
||||
# Extract artist and title if needed
|
||||
if extract_metadata:
|
||||
artist, title = self._parse_video_title(info.get("title", ""))
|
||||
|
||||
if not track.artist:
|
||||
track.artist = artist
|
||||
|
||||
if not track.title:
|
||||
track.title = title
|
||||
|
||||
self.logger.info(f"Extracted info - artist: {track.artist}, title: {track.title}, extractor: {track.extractor}, id: {track.media_id}")
|
||||
|
||||
return track
|
||||
|
||||
except Exception as e:
|
||||
raise DownloadError(f"Failed to extract info for online media: {str(e)}") from e
|
||||
|
||||
async def _download_video(self, url, output_filename_no_extension):
|
||||
"""
|
||||
Download a video from a URL.
|
||||
|
||||
Args:
|
||||
url: The URL to download from
|
||||
output_filename_no_extension: The output filename without extension
|
||||
|
||||
Returns:
|
||||
The path to the downloaded file
|
||||
"""
|
||||
self.logger.info(f"Downloading video from {url}")
|
||||
|
||||
# Define output template
|
||||
output_template = f"{output_filename_no_extension}.%(ext)s"
|
||||
|
||||
# Set up yt-dlp options
|
||||
ydl_opts = {
|
||||
"format": "bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best",
|
||||
"outtmpl": output_template,
|
||||
"quiet": self.config.log_level > 10, # Only show output if log level is DEBUG
|
||||
"no_warnings": self.config.log_level > 10,
|
||||
"ignoreerrors": False,
|
||||
"noplaylist": True,
|
||||
}
|
||||
|
||||
if self.config.dry_run:
|
||||
self.logger.info(f"[DRY RUN] Would download video from {url} to {output_template}")
|
||||
return f"{output_filename_no_extension}.mp4"
|
||||
|
||||
try:
|
||||
with yt_dlp.YoutubeDL(ydl_opts) as ydl_instance:
|
||||
info = ydl_instance.extract_info(url, download=True)
|
||||
|
||||
# Get the downloaded file path
|
||||
if info and "requested_downloads" in info:
|
||||
for download in info["requested_downloads"]:
|
||||
if "filepath" in download:
|
||||
downloaded_file = download["filepath"]
|
||||
self.logger.info(f"Successfully downloaded video: {downloaded_file}")
|
||||
return downloaded_file
|
||||
|
||||
# Fallback: try to guess the file path
|
||||
extensions = ["mp4", "webm", "mkv", "m4a", "mp3"]
|
||||
for ext in extensions:
|
||||
possible_path = f"{output_filename_no_extension}.{ext}"
|
||||
if os.path.isfile(possible_path):
|
||||
self.logger.info(f"Found downloaded file: {possible_path}")
|
||||
return possible_path
|
||||
|
||||
raise DownloadError("Failed to determine downloaded file path")
|
||||
|
||||
except Exception as e:
|
||||
raise DownloadError(f"Failed to download video: {str(e)}") from e
|
||||
|
||||
def _parse_video_title(self, video_title):
|
||||
"""
|
||||
Parse artist and title from a video title.
|
||||
|
||||
Args:
|
||||
video_title: The video title
|
||||
|
||||
Returns:
|
||||
Tuple of (artist, title)
|
||||
"""
|
||||
self.logger.debug(f"Parsing video title: {video_title}")
|
||||
|
||||
# Try to match "Artist - Title" pattern
|
||||
match = re.search(r"(.+?)\s*[-–—]\s*(.+)", video_title)
|
||||
if match:
|
||||
artist = match.group(1).strip()
|
||||
title = match.group(2).strip()
|
||||
|
||||
# Clean up title (remove things like "Official Video", etc.)
|
||||
title = re.sub(r"\(Official\s+Video\)", "", title, flags=re.IGNORECASE).strip()
|
||||
title = re.sub(r"\(Official\s+Music\s+Video\)", "", title, flags=re.IGNORECASE).strip()
|
||||
title = re.sub(r"\(Official\s+Lyric\s+Video\)", "", title, flags=re.IGNORECASE).strip()
|
||||
title = re.sub(r"\(Lyric\s+Video\)", "", title, flags=re.IGNORECASE).strip()
|
||||
title = re.sub(r"\(Audio\)", "", title, flags=re.IGNORECASE).strip()
|
||||
title = re.sub(r"\(Official\s+Audio\)", "", title, flags=re.IGNORECASE).strip()
|
||||
|
||||
return artist, title
|
||||
|
||||
# If no match, use the whole title as both artist and title
|
||||
return video_title, video_title
|
||||
|
||||
def _sanitize_filename(self, filename):
|
||||
"""
|
||||
Sanitize a filename by removing invalid characters.
|
||||
|
||||
Args:
|
||||
filename: The filename to sanitize
|
||||
|
||||
Returns:
|
||||
The sanitized filename
|
||||
"""
|
||||
# Replace characters that are invalid in filenames
|
||||
invalid_chars = ['<', '>', ':', '"', '/', '\\', '|', '?', '*']
|
||||
for char in invalid_chars:
|
||||
filename = filename.replace(char, '_')
|
||||
return filename
|
||||
@@ -0,0 +1,322 @@
|
||||
import os
|
||||
import asyncio
|
||||
import shutil
|
||||
from PIL import Image
|
||||
from karaoke_gen.core.track import Track
|
||||
from karaoke_gen.core.exceptions import MediaError
|
||||
|
||||
|
||||
class MediaExtractor:
|
||||
"""
|
||||
Handles extracting content from media files.
|
||||
"""
|
||||
|
||||
def __init__(self, config):
|
||||
"""
|
||||
Initialize the media extractor.
|
||||
|
||||
Args:
|
||||
config: The project configuration
|
||||
"""
|
||||
self.config = config
|
||||
self.logger = config.logger
|
||||
|
||||
# Path to ffmpeg
|
||||
self.ffmpeg_path = "ffmpeg"
|
||||
|
||||
# Set up ffmpeg base command
|
||||
self.ffmpeg_base_command = f"{self.ffmpeg_path} -hide_banner -nostats"
|
||||
|
||||
if self.config.log_level <= 10: # DEBUG
|
||||
self.ffmpeg_base_command += " -loglevel verbose"
|
||||
else:
|
||||
self.ffmpeg_base_command += " -loglevel fatal"
|
||||
|
||||
async def extract_still_image(self, track):
|
||||
"""
|
||||
Extract a still image from a video file.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated media information
|
||||
"""
|
||||
self.logger.info(f"Extracting still image for {track.base_name}")
|
||||
|
||||
# Skip if input is not a video file
|
||||
if not self._is_video_file(track.input_media):
|
||||
self.logger.info(f"Input is not a video file, skipping still image extraction")
|
||||
return track
|
||||
|
||||
# Define output path with (Original) label
|
||||
output_filename_no_extension = os.path.join(
|
||||
track.track_output_dir,
|
||||
f"{track.base_name} (Original)"
|
||||
)
|
||||
output_image = f"{output_filename_no_extension}.jpg"
|
||||
|
||||
# Skip if output already exists
|
||||
if os.path.isfile(output_image):
|
||||
self.logger.info(f"Still image already exists: {output_image}")
|
||||
track.input_still_image = output_image
|
||||
return track
|
||||
|
||||
# Build ffmpeg command
|
||||
command = f'{self.ffmpeg_base_command} -i "{track.input_media}" -vf "select=eq(n\\,0)" -q:v 1 "{output_image}"'
|
||||
|
||||
# Execute command
|
||||
if not self.config.dry_run:
|
||||
try:
|
||||
self.logger.debug(f"Executing command: {command}")
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
stdout, stderr = await process.communicate()
|
||||
|
||||
if process.returncode != 0:
|
||||
error_message = stderr.decode() if stderr else "Unknown error"
|
||||
raise MediaError(f"Failed to extract still image: {error_message}")
|
||||
|
||||
self.logger.info(f"Successfully extracted still image: {output_image}")
|
||||
track.input_still_image = output_image
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to extract still image: {str(e)}")
|
||||
# Continue without still image
|
||||
else:
|
||||
self.logger.info(f"[DRY RUN] Would extract still image: {output_image}")
|
||||
track.input_still_image = output_image
|
||||
|
||||
return track
|
||||
|
||||
async def extract_audio_from_video(self, track):
|
||||
"""
|
||||
Extract audio from a video file.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated media information
|
||||
"""
|
||||
self.logger.info(f"Extracting audio from video for {track.base_name}")
|
||||
|
||||
# Skip if input is not a video file
|
||||
if not self._is_video_file(track.input_media):
|
||||
self.logger.info(f"Input is not a video file, skipping audio extraction")
|
||||
return track
|
||||
|
||||
# Define output path with (Original) label
|
||||
output_filename_no_extension = os.path.join(
|
||||
track.track_output_dir,
|
||||
f"{track.base_name} (Original)"
|
||||
)
|
||||
output_wav = f"{output_filename_no_extension}.wav"
|
||||
|
||||
# Skip if output already exists
|
||||
if os.path.isfile(output_wav):
|
||||
self.logger.info(f"Audio file already exists: {output_wav}")
|
||||
track.input_audio_wav = output_wav
|
||||
return track
|
||||
|
||||
# Build ffmpeg command
|
||||
command = f'{self.ffmpeg_base_command} -i "{track.input_media}" -vn -acodec pcm_s16le -ar 44100 -ac 2 "{output_wav}"'
|
||||
|
||||
# Execute command
|
||||
if not self.config.dry_run:
|
||||
try:
|
||||
self.logger.debug(f"Executing command: {command}")
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
stdout, stderr = await process.communicate()
|
||||
|
||||
if process.returncode != 0:
|
||||
error_message = stderr.decode() if stderr else "Unknown error"
|
||||
raise MediaError(f"Failed to extract audio: {error_message}")
|
||||
|
||||
self.logger.info(f"Successfully extracted audio: {output_wav}")
|
||||
track.input_audio_wav = output_wav
|
||||
|
||||
except Exception as e:
|
||||
raise MediaError(f"Failed to extract audio: {str(e)}") from e
|
||||
else:
|
||||
self.logger.info(f"[DRY RUN] Would extract audio: {output_wav}")
|
||||
track.input_audio_wav = output_wav
|
||||
|
||||
return track
|
||||
|
||||
async def copy_audio_file(self, track):
|
||||
"""
|
||||
Copy an audio file to the output directory.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated media information
|
||||
"""
|
||||
self.logger.info(f"Copying audio file for {track.base_name}")
|
||||
|
||||
# Define output path with (Original) label
|
||||
output_filename_no_extension = os.path.join(
|
||||
track.track_output_dir,
|
||||
f"{track.base_name} (Original)"
|
||||
)
|
||||
|
||||
# Determine output extension
|
||||
input_ext = os.path.splitext(track.input_media)[1].lower()
|
||||
output_file = f"{output_filename_no_extension}{input_ext}"
|
||||
|
||||
# Skip if output already exists
|
||||
if os.path.isfile(output_file) and os.path.abspath(output_file) != os.path.abspath(track.input_media):
|
||||
self.logger.info(f"Audio file already exists: {output_file}")
|
||||
elif not self.config.dry_run:
|
||||
try:
|
||||
# Copy file
|
||||
shutil.copy2(track.input_media, output_file)
|
||||
self.logger.info(f"Successfully copied audio file: {output_file}")
|
||||
except Exception as e:
|
||||
raise MediaError(f"Failed to copy audio file: {str(e)}") from e
|
||||
else:
|
||||
self.logger.info(f"[DRY RUN] Would copy audio file: {output_file}")
|
||||
|
||||
# Convert to WAV if needed
|
||||
output_wav = f"{output_filename_no_extension}.wav"
|
||||
|
||||
# Skip if output already exists
|
||||
if os.path.isfile(output_wav):
|
||||
self.logger.info(f"WAV file already exists: {output_wav}")
|
||||
track.input_audio_wav = output_wav
|
||||
return track
|
||||
|
||||
# Build ffmpeg command
|
||||
command = f'{self.ffmpeg_base_command} -i "{output_file}" -vn -acodec pcm_s16le -ar 44100 -ac 2 "{output_wav}"'
|
||||
|
||||
# Execute command
|
||||
if not self.config.dry_run:
|
||||
try:
|
||||
self.logger.debug(f"Executing command: {command}")
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
stdout, stderr = await process.communicate()
|
||||
|
||||
if process.returncode != 0:
|
||||
error_message = stderr.decode() if stderr else "Unknown error"
|
||||
raise MediaError(f"Failed to convert audio to WAV: {error_message}")
|
||||
|
||||
self.logger.info(f"Successfully converted audio to WAV: {output_wav}")
|
||||
track.input_audio_wav = output_wav
|
||||
|
||||
except Exception as e:
|
||||
raise MediaError(f"Failed to convert audio to WAV: {str(e)}") from e
|
||||
else:
|
||||
self.logger.info(f"[DRY RUN] Would convert audio to WAV: {output_wav}")
|
||||
track.input_audio_wav = output_wav
|
||||
|
||||
return track
|
||||
|
||||
async def copy_image_file(self, track):
|
||||
"""
|
||||
Copy an image file to the output directory.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated media information
|
||||
"""
|
||||
self.logger.info(f"Copying image file for {track.base_name}")
|
||||
|
||||
# Define output path with (Original) label
|
||||
output_filename_no_extension = os.path.join(
|
||||
track.track_output_dir,
|
||||
f"{track.base_name} (Original)"
|
||||
)
|
||||
|
||||
# Determine output extension
|
||||
input_ext = os.path.splitext(track.input_media)[1].lower()
|
||||
output_file = f"{output_filename_no_extension}{input_ext}"
|
||||
|
||||
# Skip if output already exists
|
||||
if os.path.isfile(output_file) and os.path.abspath(output_file) != os.path.abspath(track.input_media):
|
||||
self.logger.info(f"Image file already exists: {output_file}")
|
||||
elif not self.config.dry_run:
|
||||
try:
|
||||
# Copy file
|
||||
shutil.copy2(track.input_media, output_file)
|
||||
self.logger.info(f"Successfully copied image file: {output_file}")
|
||||
except Exception as e:
|
||||
raise MediaError(f"Failed to copy image file: {str(e)}") from e
|
||||
else:
|
||||
self.logger.info(f"[DRY RUN] Would copy image file: {output_file}")
|
||||
|
||||
# Set still image
|
||||
track.input_still_image = output_file
|
||||
|
||||
return track
|
||||
|
||||
def _is_video_file(self, file_path):
|
||||
"""
|
||||
Check if a file is a video file.
|
||||
|
||||
Args:
|
||||
file_path: The path to the file
|
||||
|
||||
Returns:
|
||||
True if the file is a video file, False otherwise
|
||||
"""
|
||||
if not file_path or not os.path.isfile(file_path):
|
||||
return False
|
||||
|
||||
video_extensions = ['.mp4', '.avi', '.mov', '.mkv', '.webm', '.flv', '.wmv', '.m4v']
|
||||
_, ext = os.path.splitext(file_path)
|
||||
return ext.lower() in video_extensions
|
||||
|
||||
async def extract_media(self, track: Track) -> Track:
|
||||
"""
|
||||
Extract media from the input file based on its type.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated media information
|
||||
"""
|
||||
self.logger.info(f"Extracting media for {track.base_name}")
|
||||
|
||||
# Check if the input is a video file
|
||||
if self._is_video_file(track.input_media):
|
||||
# Extract still image and audio from video
|
||||
track = await self.extract_still_image(track)
|
||||
track = await self.extract_audio_from_video(track)
|
||||
elif self._is_image_file(track.input_media):
|
||||
# Copy image file
|
||||
track = await self.copy_image_file(track)
|
||||
else:
|
||||
# Assume it's an audio file
|
||||
track = await self.copy_audio_file(track)
|
||||
|
||||
return track
|
||||
|
||||
def _is_image_file(self, file_path):
|
||||
"""
|
||||
Check if a file is an image file.
|
||||
|
||||
Args:
|
||||
file_path: The path to the file
|
||||
|
||||
Returns:
|
||||
True if the file is an image file, False otherwise
|
||||
"""
|
||||
image_extensions = ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.tiff', '.webp']
|
||||
ext = os.path.splitext(file_path)[1].lower()
|
||||
return ext in image_extensions
|
||||
@@ -0,0 +1,115 @@
|
||||
import logging
|
||||
import os
|
||||
import asyncio
|
||||
import shutil
|
||||
import glob
|
||||
from typing import Dict, Any, Optional, Tuple
|
||||
from karaoke_gen.core.project import ProjectConfig
|
||||
from karaoke_gen.core.track import Track
|
||||
from karaoke_gen.core.exceptions import MediaError, DownloadError, ConversionError
|
||||
from karaoke_gen.services.media.downloader import MediaDownloader
|
||||
from karaoke_gen.services.media.extractor import MediaExtractor
|
||||
from karaoke_gen.services.media.detector import MediaDetector
|
||||
|
||||
|
||||
class MediaService:
|
||||
"""
|
||||
Service for media handling operations including downloading, extraction, and detection.
|
||||
"""
|
||||
|
||||
def __init__(self, config: ProjectConfig):
|
||||
"""
|
||||
Initialize the media service.
|
||||
|
||||
Args:
|
||||
config: The project configuration
|
||||
"""
|
||||
self.config = config
|
||||
self.logger = config.logger or logging.getLogger(__name__)
|
||||
|
||||
# Initialize components
|
||||
self.downloader = MediaDownloader(config)
|
||||
self.extractor = MediaExtractor(config)
|
||||
self.detector = MediaDetector(config)
|
||||
|
||||
async def download_media(self, track: Track) -> Track:
|
||||
"""
|
||||
Download media for the track.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated media information
|
||||
"""
|
||||
if self.config.skip_download:
|
||||
self.logger.info("Skipping media download")
|
||||
return track
|
||||
|
||||
self.logger.info(f"Downloading media for {track.base_name}")
|
||||
|
||||
# Download media
|
||||
track = await self.downloader.download_media(track)
|
||||
|
||||
return track
|
||||
|
||||
async def extract_media(self, track: Track) -> Track:
|
||||
"""
|
||||
Extract audio and other components from media.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated extracted media information
|
||||
"""
|
||||
if self.config.skip_separation:
|
||||
self.logger.info("Skipping media extraction")
|
||||
return track
|
||||
|
||||
self.logger.info(f"Extracting media for {track.base_name}")
|
||||
|
||||
# Extract media
|
||||
track = await self.extractor.extract_media(track)
|
||||
|
||||
return track
|
||||
|
||||
async def detect_media_info(self, track: Track) -> Track:
|
||||
"""
|
||||
Detect media information.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated media information
|
||||
"""
|
||||
self.logger.info(f"Detecting media info for {track.base_name}")
|
||||
|
||||
# Detect media info
|
||||
track = await self.detector.detect_media_info(track)
|
||||
|
||||
return track
|
||||
|
||||
async def process_media(self, track: Track) -> Track:
|
||||
"""
|
||||
Process media for the track.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated media information
|
||||
"""
|
||||
self.logger.info(f"Processing media for {track.base_name}")
|
||||
|
||||
# Download media
|
||||
track = await self.download_media(track)
|
||||
|
||||
# Extract media
|
||||
track = await self.extract_media(track)
|
||||
|
||||
# Detect media info
|
||||
track = await self.detect_media_info(track)
|
||||
|
||||
return track
|
||||
@@ -0,0 +1,5 @@
|
||||
from karaoke_gen.services.video.service import VideoService
|
||||
from karaoke_gen.services.video.renderer import VideoRenderer
|
||||
from karaoke_gen.services.video.text import TextRenderer
|
||||
from karaoke_gen.services.video.screens import ScreenGenerator
|
||||
from karaoke_gen.services.video.compositor import VideoCompositor
|
||||
@@ -0,0 +1,626 @@
|
||||
import os
|
||||
import asyncio
|
||||
import tempfile
|
||||
from karaoke_gen.core.exceptions import VideoError
|
||||
|
||||
|
||||
class VideoCompositor:
|
||||
"""
|
||||
Handles video composition operations.
|
||||
"""
|
||||
|
||||
def __init__(self, config):
|
||||
"""
|
||||
Initialize the video compositor.
|
||||
|
||||
Args:
|
||||
config: The project configuration
|
||||
"""
|
||||
self.config = config
|
||||
self.logger = config.logger
|
||||
|
||||
# Path to ffmpeg
|
||||
self.ffmpeg_path = "ffmpeg"
|
||||
|
||||
# Set up ffmpeg base command
|
||||
self.ffmpeg_base_command = f"{self.ffmpeg_path} -hide_banner -nostats"
|
||||
|
||||
if self.config.log_level <= 10: # DEBUG
|
||||
self.ffmpeg_base_command += " -loglevel verbose"
|
||||
else:
|
||||
self.ffmpeg_base_command += " -loglevel fatal"
|
||||
|
||||
# Initialize temporary files list
|
||||
self._temp_files = []
|
||||
|
||||
async def compose_final_video(self, track):
|
||||
"""
|
||||
Compose the final video by combining title, content, and end videos.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated video information
|
||||
"""
|
||||
self.logger.info(f"Composing final video for {track.base_name}")
|
||||
|
||||
# Define output path
|
||||
output_path = os.path.join(track.track_output_dir, f"{track.base_name} (Final Karaoke).mp4")
|
||||
|
||||
# Skip if output already exists
|
||||
if os.path.isfile(output_path):
|
||||
self.logger.info(f"Final video already exists: {output_path}")
|
||||
track.final_video = output_path
|
||||
return track
|
||||
|
||||
# Check for required videos
|
||||
title_video = track.title_video
|
||||
content_video = track.video_with_lyrics or track.video_with_instrumental
|
||||
end_video = track.end_video
|
||||
|
||||
if not title_video or not os.path.isfile(title_video):
|
||||
self.logger.warning("Title video not found, skipping final video composition")
|
||||
return track
|
||||
|
||||
if not content_video or not os.path.isfile(content_video):
|
||||
self.logger.warning("Content video not found, skipping final video composition")
|
||||
return track
|
||||
|
||||
# Compose video
|
||||
if not self.config.dry_run:
|
||||
try:
|
||||
# Build ffmpeg command
|
||||
command = f'{self.ffmpeg_base_command} -i "{title_video}" -i "{content_video}" '
|
||||
|
||||
# Add end video if available
|
||||
if end_video and os.path.isfile(end_video):
|
||||
command += f'-i "{end_video}" '
|
||||
filter_complex = '[0:v][0:a][1:v][1:a][2:v][2:a]concat=n=3:v=1:a=1[outv][outa]'
|
||||
else:
|
||||
filter_complex = '[0:v][0:a][1:v][1:a]concat=n=2:v=1:a=1[outv][outa]'
|
||||
|
||||
# Add filter complex and output options
|
||||
command += (
|
||||
f'-filter_complex "{filter_complex}" '
|
||||
f'-map "[outv]" -map "[outa]" '
|
||||
f'-c:v libx264 -preset medium -crf 22 -c:a aac -b:a 192k '
|
||||
f'-pix_fmt yuv420p "{output_path}"'
|
||||
)
|
||||
|
||||
# Execute command
|
||||
self.logger.debug(f"Composing final video: {command}")
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
stdout, stderr = await process.communicate()
|
||||
|
||||
if process.returncode != 0:
|
||||
error_message = stderr.decode() if stderr else "Unknown error"
|
||||
raise VideoError(f"Failed to compose final video: {error_message}")
|
||||
|
||||
track.final_video = output_path
|
||||
self.logger.info(f"Successfully composed final video: {output_path}")
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to compose final video: {str(e)}")
|
||||
# Continue with other processing
|
||||
else:
|
||||
self.logger.info(f"[DRY RUN] Would compose final video: {output_path}")
|
||||
track.final_video = output_path
|
||||
|
||||
return track
|
||||
|
||||
async def create_lossless_version(self, track):
|
||||
"""
|
||||
Create a lossless version of the final video.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated video information
|
||||
"""
|
||||
self.logger.info(f"Creating lossless version for {track.base_name}")
|
||||
|
||||
# Skip if no final video
|
||||
if not track.final_video or not os.path.isfile(track.final_video):
|
||||
self.logger.info("No final video available, skipping lossless version creation")
|
||||
return track
|
||||
|
||||
# Define output path
|
||||
output_path = os.path.join(track.track_output_dir, f"{track.base_name} (Final Karaoke).mkv")
|
||||
|
||||
# Skip if output already exists
|
||||
if os.path.isfile(output_path):
|
||||
self.logger.info(f"Lossless version already exists: {output_path}")
|
||||
track.final_video_mkv = output_path
|
||||
return track
|
||||
|
||||
# Create lossless version
|
||||
if not self.config.dry_run:
|
||||
try:
|
||||
# Build ffmpeg command
|
||||
command = (
|
||||
f'{self.ffmpeg_base_command} -i "{track.final_video}" '
|
||||
f'-c:v copy -c:a flac "{output_path}"'
|
||||
)
|
||||
|
||||
# Execute command
|
||||
self.logger.debug(f"Creating lossless version: {command}")
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
stdout, stderr = await process.communicate()
|
||||
|
||||
if process.returncode != 0:
|
||||
error_message = stderr.decode() if stderr else "Unknown error"
|
||||
raise VideoError(f"Failed to create lossless version: {error_message}")
|
||||
|
||||
track.final_video_mkv = output_path
|
||||
self.logger.info(f"Successfully created lossless version: {output_path}")
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to create lossless version: {str(e)}")
|
||||
# Continue with other processing
|
||||
else:
|
||||
self.logger.info(f"[DRY RUN] Would create lossless version: {output_path}")
|
||||
track.final_video_mkv = output_path
|
||||
|
||||
return track
|
||||
|
||||
async def create_720p_version(self, track):
|
||||
"""
|
||||
Create a 720p version of the final video.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated video information
|
||||
"""
|
||||
self.logger.info(f"Creating 720p version for {track.base_name}")
|
||||
|
||||
# Skip if no final video
|
||||
if not track.final_video or not os.path.isfile(track.final_video):
|
||||
self.logger.info("No final video available, skipping 720p version creation")
|
||||
return track
|
||||
|
||||
# Define output path
|
||||
output_path = os.path.join(track.track_output_dir, f"{track.base_name} (Final Karaoke 720p).mp4")
|
||||
|
||||
# Skip if output already exists
|
||||
if os.path.isfile(output_path):
|
||||
self.logger.info(f"720p version already exists: {output_path}")
|
||||
track.final_video_720p = output_path
|
||||
return track
|
||||
|
||||
# Create 720p version
|
||||
if not self.config.dry_run:
|
||||
try:
|
||||
# Build ffmpeg command
|
||||
command = (
|
||||
f'{self.ffmpeg_base_command} -i "{track.final_video}" '
|
||||
f'-c:v libx264 -vf "scale=1280:720" -b:v 2000k -preset medium -tune animation '
|
||||
f'-c:a aac -b:a 128k -pix_fmt yuv420p "{output_path}"'
|
||||
)
|
||||
|
||||
# Execute command
|
||||
self.logger.debug(f"Creating 720p version: {command}")
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
stdout, stderr = await process.communicate()
|
||||
|
||||
if process.returncode != 0:
|
||||
error_message = stderr.decode() if stderr else "Unknown error"
|
||||
raise VideoError(f"Failed to create 720p version: {error_message}")
|
||||
|
||||
track.final_video_720p = output_path
|
||||
self.logger.info(f"Successfully created 720p version: {output_path}")
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to create 720p version: {str(e)}")
|
||||
# Continue with other processing
|
||||
else:
|
||||
self.logger.info(f"[DRY RUN] Would create 720p version: {output_path}")
|
||||
track.final_video_720p = output_path
|
||||
|
||||
return track
|
||||
|
||||
async def create_lossy_version(self, track):
|
||||
"""
|
||||
Create a lossy version of the final video.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated video information
|
||||
"""
|
||||
self.logger.info(f"Creating lossy version for {track.base_name}")
|
||||
|
||||
# Skip if no final video
|
||||
if not track.final_video or not os.path.isfile(track.final_video):
|
||||
self.logger.warning(f"No final video found for {track.base_name}")
|
||||
return track
|
||||
|
||||
# Define output path
|
||||
output_path = os.path.join(track.track_output_dir, f"{track.base_name} (Final Karaoke Lossy).mp4")
|
||||
|
||||
# Skip if output already exists
|
||||
if os.path.isfile(output_path) and not self.config.force_regenerate:
|
||||
self.logger.info(f"Lossy version already exists: {output_path}")
|
||||
track.final_video_lossy = output_path
|
||||
return track
|
||||
|
||||
# Create lossy version
|
||||
if not self.config.dry_run:
|
||||
try:
|
||||
# Build ffmpeg command
|
||||
command = (
|
||||
f'{self.ffmpeg_base_command} -i "{track.final_video}" '
|
||||
f'-c:v libx264 -preset slow -crf 23 -c:a aac -b:a 128k '
|
||||
f'-pix_fmt yuv420p "{output_path}"'
|
||||
)
|
||||
|
||||
# Execute command
|
||||
self.logger.debug(f"Creating lossy version: {command}")
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
stdout, stderr = await process.communicate()
|
||||
|
||||
if process.returncode != 0:
|
||||
error_message = stderr.decode() if stderr else "Unknown error"
|
||||
raise VideoError(f"Failed to create lossy version: {error_message}")
|
||||
|
||||
track.final_video_lossy = output_path
|
||||
self.logger.info(f"Successfully created lossy version: {output_path}")
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to create lossy version: {str(e)}")
|
||||
# Continue with other processing
|
||||
else:
|
||||
self.logger.info(f"[DRY RUN] Would create lossy version: {output_path}")
|
||||
track.final_video_lossy = output_path
|
||||
|
||||
return track
|
||||
|
||||
async def add_subtitles_to_video(self, track, subtitles_file, output_file=None):
|
||||
"""
|
||||
Add subtitles to a video.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
subtitles_file: The subtitles file
|
||||
output_file: The output file path
|
||||
|
||||
Returns:
|
||||
The track with updated subtitled video information
|
||||
"""
|
||||
self.logger.info(f"Adding subtitles to video for {track.base_name}")
|
||||
|
||||
# Set default output file
|
||||
if output_file is None:
|
||||
output_file = os.path.join(track.track_output_dir, f"{track.base_name} (Subtitled).mov")
|
||||
|
||||
# Skip if output already exists
|
||||
if os.path.isfile(output_file):
|
||||
self.logger.info(f"Subtitled video already exists: {output_file}")
|
||||
track.subtitled_video = output_file
|
||||
return track
|
||||
|
||||
# Check if required files exist
|
||||
if not track.video or not os.path.isfile(track.video):
|
||||
self.logger.error(f"Video not found: {track.video}")
|
||||
raise VideoError(f"Video not found: {track.video}")
|
||||
|
||||
if not os.path.isfile(subtitles_file):
|
||||
self.logger.error(f"Subtitles file not found: {subtitles_file}")
|
||||
raise VideoError(f"Subtitles file not found: {subtitles_file}")
|
||||
|
||||
# Add subtitles to video
|
||||
if not self.config.dry_run:
|
||||
try:
|
||||
await self._add_subtitles_to_video(track.video, subtitles_file, output_file)
|
||||
|
||||
track.subtitled_video = output_file
|
||||
self.logger.info(f"Successfully added subtitles to video: {output_file}")
|
||||
|
||||
except Exception as e:
|
||||
raise VideoError(f"Failed to add subtitles to video: {str(e)}") from e
|
||||
else:
|
||||
self.logger.info(f"[DRY RUN] Would add subtitles to video: {output_file}")
|
||||
track.subtitled_video = output_file
|
||||
|
||||
return track
|
||||
|
||||
async def overlay_videos(self, background_video, overlay_video, output_file, position=None,
|
||||
start_time=None, end_time=None, opacity=None):
|
||||
"""
|
||||
Overlay one video on top of another.
|
||||
|
||||
Args:
|
||||
background_video: The background video file
|
||||
overlay_video: The overlay video file
|
||||
output_file: The output file path
|
||||
position: The position (x:y)
|
||||
start_time: The start time in seconds
|
||||
end_time: The end time in seconds
|
||||
opacity: The opacity (0.0-1.0)
|
||||
|
||||
Returns:
|
||||
The output file path
|
||||
"""
|
||||
self.logger.info(f"Overlaying video on {background_video}")
|
||||
|
||||
# Skip if output already exists
|
||||
if os.path.isfile(output_file):
|
||||
self.logger.info(f"Overlaid video already exists: {output_file}")
|
||||
return output_file
|
||||
|
||||
# Check if required files exist
|
||||
if not os.path.isfile(background_video):
|
||||
self.logger.error(f"Background video not found: {background_video}")
|
||||
raise VideoError(f"Background video not found: {background_video}")
|
||||
|
||||
if not os.path.isfile(overlay_video):
|
||||
self.logger.error(f"Overlay video not found: {overlay_video}")
|
||||
raise VideoError(f"Overlay video not found: {overlay_video}")
|
||||
|
||||
# Set default values
|
||||
position = position or self.config.overlay_position or "10:10"
|
||||
opacity = opacity or self.config.overlay_opacity or 1.0
|
||||
|
||||
# Overlay video
|
||||
if not self.config.dry_run:
|
||||
try:
|
||||
# Create filter complex
|
||||
filter_complex = (
|
||||
f"[0:v][1:v]overlay={position}"
|
||||
)
|
||||
|
||||
# Add start time if specified
|
||||
if start_time is not None:
|
||||
filter_complex += f":enable='between(t,{start_time},{end_time or 999999})'"
|
||||
|
||||
# Add opacity if less than 1.0
|
||||
if opacity < 1.0:
|
||||
filter_complex += f":alpha={opacity}"
|
||||
|
||||
# Overlay video
|
||||
command = (
|
||||
f'{self.ffmpeg_base_command} -i "{background_video}" -i "{overlay_video}" '
|
||||
f'-filter_complex "{filter_complex}" -c:v prores_ks -profile:v 3 '
|
||||
f'-vendor ap10 -bits_per_mb 8000 -pix_fmt yuv422p10le -c:a copy "{output_file}"'
|
||||
)
|
||||
|
||||
self.logger.debug(f"Overlaying video: {command}")
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
stdout, stderr = await process.communicate()
|
||||
|
||||
if process.returncode != 0:
|
||||
error_message = stderr.decode() if stderr else "Unknown error"
|
||||
raise VideoError(f"Failed to overlay video: {error_message}")
|
||||
|
||||
self.logger.info(f"Successfully overlaid video: {output_file}")
|
||||
|
||||
except Exception as e:
|
||||
raise VideoError(f"Failed to overlay video: {str(e)}") from e
|
||||
else:
|
||||
self.logger.info(f"[DRY RUN] Would overlay video: {output_file}")
|
||||
|
||||
return output_file
|
||||
|
||||
async def create_picture_in_picture(self, main_video, pip_video, output_file, position=None,
|
||||
size=None, start_time=None, end_time=None, border=None,
|
||||
border_color=None):
|
||||
"""
|
||||
Create a picture-in-picture video.
|
||||
|
||||
Args:
|
||||
main_video: The main video file
|
||||
pip_video: The picture-in-picture video file
|
||||
output_file: The output file path
|
||||
position: The position (x:y)
|
||||
size: The size (width:height)
|
||||
start_time: The start time in seconds
|
||||
end_time: The end time in seconds
|
||||
border: The border width
|
||||
border_color: The border color
|
||||
|
||||
Returns:
|
||||
The output file path
|
||||
"""
|
||||
self.logger.info(f"Creating picture-in-picture video with {main_video} and {pip_video}")
|
||||
|
||||
# Skip if output already exists
|
||||
if os.path.isfile(output_file):
|
||||
self.logger.info(f"Picture-in-picture video already exists: {output_file}")
|
||||
return output_file
|
||||
|
||||
# Check if required files exist
|
||||
if not os.path.isfile(main_video):
|
||||
self.logger.error(f"Main video not found: {main_video}")
|
||||
raise VideoError(f"Main video not found: {main_video}")
|
||||
|
||||
if not os.path.isfile(pip_video):
|
||||
self.logger.error(f"Picture-in-picture video not found: {pip_video}")
|
||||
raise VideoError(f"Picture-in-picture video not found: {pip_video}")
|
||||
|
||||
# Set default values
|
||||
position = position or self.config.pip_position or "main_w-overlay_w-10:main_h-overlay_h-10"
|
||||
size = size or self.config.pip_size or "iw/4:ih/4"
|
||||
border = border or self.config.pip_border or 0
|
||||
border_color = border_color or self.config.pip_border_color or "black"
|
||||
|
||||
# Create picture-in-picture video
|
||||
if not self.config.dry_run:
|
||||
try:
|
||||
# Create filter complex
|
||||
filter_complex = (
|
||||
f"[1:v]scale={size}"
|
||||
)
|
||||
|
||||
# Add border if specified
|
||||
if border > 0:
|
||||
filter_complex += f",pad=iw+{border*2}:ih+{border*2}:{border}:{border}:{border_color}"
|
||||
|
||||
filter_complex += f"[pip]; [0:v][pip]overlay={position}"
|
||||
|
||||
# Add start time if specified
|
||||
if start_time is not None:
|
||||
filter_complex += f":enable='between(t,{start_time},{end_time or 999999})'"
|
||||
|
||||
# Create picture-in-picture video
|
||||
command = (
|
||||
f'{self.ffmpeg_base_command} -i "{main_video}" -i "{pip_video}" '
|
||||
f'-filter_complex "{filter_complex}" -c:v prores_ks -profile:v 3 '
|
||||
f'-vendor ap10 -bits_per_mb 8000 -pix_fmt yuv422p10le -c:a copy "{output_file}"'
|
||||
)
|
||||
|
||||
self.logger.debug(f"Creating picture-in-picture video: {command}")
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
stdout, stderr = await process.communicate()
|
||||
|
||||
if process.returncode != 0:
|
||||
error_message = stderr.decode() if stderr else "Unknown error"
|
||||
raise VideoError(f"Failed to create picture-in-picture video: {error_message}")
|
||||
|
||||
self.logger.info(f"Successfully created picture-in-picture video: {output_file}")
|
||||
|
||||
except Exception as e:
|
||||
raise VideoError(f"Failed to create picture-in-picture video: {str(e)}") from e
|
||||
else:
|
||||
self.logger.info(f"[DRY RUN] Would create picture-in-picture video: {output_file}")
|
||||
|
||||
return output_file
|
||||
|
||||
async def _combine_videos(self, videos, output_file):
|
||||
"""
|
||||
Combine multiple videos into one.
|
||||
|
||||
Args:
|
||||
videos: The list of video files
|
||||
output_file: The output file path
|
||||
|
||||
Returns:
|
||||
The output file path
|
||||
"""
|
||||
# Create a temporary file for the concat list
|
||||
with tempfile.NamedTemporaryFile(suffix=".txt", delete=False) as temp_file:
|
||||
concat_list = temp_file.name
|
||||
self._temp_files.append(concat_list) # Track temporary file
|
||||
|
||||
# Write concat list
|
||||
with open(concat_list, "w") as f:
|
||||
for video in videos:
|
||||
f.write(f"file '{video}'\n")
|
||||
|
||||
# Combine videos
|
||||
command = (
|
||||
f'{self.ffmpeg_base_command} -f concat -safe 0 -i "{concat_list}" '
|
||||
f'-c:v prores_ks -profile:v 3 -vendor ap10 -bits_per_mb 8000 '
|
||||
f'-pix_fmt yuv422p10le -c:a pcm_s24le "{output_file}"'
|
||||
)
|
||||
|
||||
self.logger.debug(f"Combining videos: {command}")
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
stdout, stderr = await process.communicate()
|
||||
|
||||
if process.returncode != 0:
|
||||
error_message = stderr.decode() if stderr else "Unknown error"
|
||||
raise VideoError(f"Failed to combine videos: {error_message}")
|
||||
|
||||
return output_file
|
||||
|
||||
async def _add_subtitles_to_video(self, video_file, subtitles_file, output_file):
|
||||
"""
|
||||
Add subtitles to a video.
|
||||
|
||||
Args:
|
||||
video_file: The video file
|
||||
subtitles_file: The subtitles file
|
||||
output_file: The output file path
|
||||
|
||||
Returns:
|
||||
The output file path
|
||||
"""
|
||||
# Determine subtitles format
|
||||
subtitles_format = os.path.splitext(subtitles_file)[1].lower()
|
||||
|
||||
# Add subtitles to video
|
||||
if subtitles_format == ".srt":
|
||||
# Use subtitles filter for SRT
|
||||
command = (
|
||||
f'{self.ffmpeg_base_command} -i "{video_file}" '
|
||||
f'-vf "subtitles={subtitles_file}" -c:v prores_ks -profile:v 3 '
|
||||
f'-vendor ap10 -bits_per_mb 8000 -pix_fmt yuv422p10le -c:a copy "{output_file}"'
|
||||
)
|
||||
elif subtitles_format == ".ass":
|
||||
# Use ASS filter for ASS/SSA
|
||||
command = (
|
||||
f'{self.ffmpeg_base_command} -i "{video_file}" '
|
||||
f'-vf "ass={subtitles_file}" -c:v prores_ks -profile:v 3 '
|
||||
f'-vendor ap10 -bits_per_mb 8000 -pix_fmt yuv422p10le -c:a copy "{output_file}"'
|
||||
)
|
||||
else:
|
||||
# Use subtitles filter for other formats
|
||||
command = (
|
||||
f'{self.ffmpeg_base_command} -i "{video_file}" -i "{subtitles_file}" '
|
||||
f'-c:v prores_ks -profile:v 3 -vendor ap10 -bits_per_mb 8000 '
|
||||
f'-pix_fmt yuv422p10le -c:a copy -c:s mov_text "{output_file}"'
|
||||
)
|
||||
|
||||
self.logger.debug(f"Adding subtitles to video: {command}")
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
stdout, stderr = await process.communicate()
|
||||
|
||||
if process.returncode != 0:
|
||||
error_message = stderr.decode() if stderr else "Unknown error"
|
||||
raise VideoError(f"Failed to add subtitles to video: {error_message}")
|
||||
|
||||
return output_file
|
||||
|
||||
async def cleanup(self):
|
||||
"""
|
||||
Perform cleanup operations for the video compositor.
|
||||
"""
|
||||
self.logger.info("Cleaning up video compositor resources")
|
||||
|
||||
# Clean up any temporary files
|
||||
if hasattr(self, '_temp_files') and self._temp_files:
|
||||
for temp_file in self._temp_files:
|
||||
if os.path.exists(temp_file):
|
||||
try:
|
||||
os.remove(temp_file)
|
||||
self.logger.debug(f"Removed temporary file: {temp_file}")
|
||||
except Exception as e:
|
||||
self.logger.warning(f"Failed to remove temporary file {temp_file}: {str(e)}")
|
||||
|
||||
self.logger.info("Video compositor cleanup complete")
|
||||
@@ -0,0 +1,803 @@
|
||||
import os
|
||||
import asyncio
|
||||
import tempfile
|
||||
import subprocess
|
||||
import shutil
|
||||
from karaoke_gen.core.exceptions import VideoError
|
||||
|
||||
|
||||
class VideoRenderer:
|
||||
"""
|
||||
Handles video rendering operations.
|
||||
"""
|
||||
|
||||
def __init__(self, config):
|
||||
"""
|
||||
Initialize the video renderer.
|
||||
|
||||
Args:
|
||||
config: The project configuration
|
||||
"""
|
||||
self.config = config
|
||||
self.logger = config.logger
|
||||
|
||||
# Path to ffmpeg
|
||||
self.ffmpeg_path = "ffmpeg"
|
||||
|
||||
# Set up ffmpeg base command
|
||||
self.ffmpeg_base_command = f"{self.ffmpeg_path} -hide_banner -nostats"
|
||||
|
||||
if self.config.log_level <= 10: # DEBUG
|
||||
self.ffmpeg_base_command += " -loglevel verbose"
|
||||
else:
|
||||
self.ffmpeg_base_command += " -loglevel fatal"
|
||||
|
||||
# Initialize temporary files list
|
||||
self._temp_files = []
|
||||
|
||||
async def render_video(self, track, output_file=None, resolution=None, fps=None,
|
||||
codec=None, bitrate=None, background_color=None):
|
||||
"""
|
||||
Render a video for a track.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
output_file: The output file path
|
||||
resolution: The resolution
|
||||
fps: The frames per second
|
||||
codec: The codec
|
||||
bitrate: The bitrate
|
||||
background_color: The background color
|
||||
|
||||
Returns:
|
||||
The output file path
|
||||
"""
|
||||
self.logger.info(f"Rendering video for {track.base_name}")
|
||||
|
||||
# Set default output file
|
||||
if output_file is None:
|
||||
output_file = os.path.join(track.track_output_dir, f"{track.base_name} (Video).mov")
|
||||
|
||||
# Skip if output already exists
|
||||
if os.path.isfile(output_file):
|
||||
self.logger.info(f"Video already exists: {output_file}")
|
||||
track.video = output_file
|
||||
return track
|
||||
|
||||
# Set default values
|
||||
resolution = resolution or self.config.video_resolution or "1920x1080"
|
||||
fps = fps or self.config.video_fps or 30
|
||||
codec = codec or self.config.video_codec or "prores_ks"
|
||||
bitrate = bitrate or self.config.video_bitrate or "8000k"
|
||||
background_color = background_color or self.config.video_background_color or "black"
|
||||
|
||||
# Check if audio file exists
|
||||
if not track.audio_file or not os.path.isfile(track.audio_file):
|
||||
self.logger.error(f"Audio file not found: {track.audio_file}")
|
||||
raise VideoError(f"Audio file not found: {track.audio_file}")
|
||||
|
||||
# Create video
|
||||
if not self.config.dry_run:
|
||||
try:
|
||||
# Create a video from audio
|
||||
await self._create_video_from_audio(
|
||||
track.audio_file,
|
||||
output_file,
|
||||
track.duration,
|
||||
resolution,
|
||||
fps,
|
||||
codec,
|
||||
bitrate,
|
||||
background_color
|
||||
)
|
||||
|
||||
track.video = output_file
|
||||
self.logger.info(f"Successfully rendered video: {output_file}")
|
||||
|
||||
except Exception as e:
|
||||
raise VideoError(f"Failed to render video: {str(e)}") from e
|
||||
else:
|
||||
self.logger.info(f"[DRY RUN] Would render video: {output_file}")
|
||||
track.video = output_file
|
||||
|
||||
return track
|
||||
|
||||
async def combine_videos(self, videos, output_file, transition_duration=None):
|
||||
"""
|
||||
Combine multiple videos into one.
|
||||
|
||||
Args:
|
||||
videos: The list of video files to combine
|
||||
output_file: The output file path
|
||||
transition_duration: The transition duration in seconds
|
||||
|
||||
Returns:
|
||||
The output file path
|
||||
"""
|
||||
self.logger.info(f"Combining {len(videos)} videos")
|
||||
|
||||
# Skip if output already exists
|
||||
if os.path.isfile(output_file):
|
||||
self.logger.info(f"Combined video already exists: {output_file}")
|
||||
return output_file
|
||||
|
||||
# Check if videos exist
|
||||
for video in videos:
|
||||
if not os.path.isfile(video):
|
||||
self.logger.error(f"Video file not found: {video}")
|
||||
raise VideoError(f"Video file not found: {video}")
|
||||
|
||||
# Set default transition duration
|
||||
transition_duration = transition_duration or self.config.transition_duration or 0.5
|
||||
|
||||
# Create video
|
||||
if not self.config.dry_run:
|
||||
try:
|
||||
# Create a temporary file for the concat list
|
||||
with tempfile.NamedTemporaryFile(suffix=".txt", delete=False) as temp_file:
|
||||
concat_list = temp_file.name
|
||||
self._temp_files.append(concat_list) # Track temporary file
|
||||
|
||||
# Write concat list
|
||||
with open(concat_list, "w") as f:
|
||||
for video in videos:
|
||||
f.write(f"file '{video}'\n")
|
||||
|
||||
# Combine videos
|
||||
if transition_duration > 0:
|
||||
await self._combine_videos_with_transitions(videos, output_file, transition_duration)
|
||||
else:
|
||||
await self._combine_videos_simple(concat_list, output_file)
|
||||
|
||||
self.logger.info(f"Successfully combined videos: {output_file}")
|
||||
|
||||
except Exception as e:
|
||||
raise VideoError(f"Failed to combine videos: {str(e)}") from e
|
||||
else:
|
||||
self.logger.info(f"[DRY RUN] Would combine videos: {output_file}")
|
||||
|
||||
return output_file
|
||||
|
||||
async def add_audio_to_video(self, video_file, audio_file, output_file):
|
||||
"""
|
||||
Add audio to a video.
|
||||
|
||||
Args:
|
||||
video_file: The video file
|
||||
audio_file: The audio file
|
||||
output_file: The output file path
|
||||
|
||||
Returns:
|
||||
The output file path
|
||||
"""
|
||||
self.logger.info(f"Adding audio to video: {video_file}")
|
||||
|
||||
# Skip if output already exists
|
||||
if os.path.isfile(output_file):
|
||||
self.logger.info(f"Video with audio already exists: {output_file}")
|
||||
return output_file
|
||||
|
||||
# Check if files exist
|
||||
if not os.path.isfile(video_file):
|
||||
self.logger.error(f"Video file not found: {video_file}")
|
||||
raise VideoError(f"Video file not found: {video_file}")
|
||||
|
||||
if not os.path.isfile(audio_file):
|
||||
self.logger.error(f"Audio file not found: {audio_file}")
|
||||
raise VideoError(f"Audio file not found: {audio_file}")
|
||||
|
||||
# Add audio to video
|
||||
if not self.config.dry_run:
|
||||
try:
|
||||
command = (
|
||||
f'{self.ffmpeg_base_command} -i "{video_file}" -i "{audio_file}" '
|
||||
f'-c:v copy -c:a pcm_s24le -shortest "{output_file}"'
|
||||
)
|
||||
|
||||
self.logger.debug(f"Adding audio to video: {command}")
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
stdout, stderr = await process.communicate()
|
||||
|
||||
if process.returncode != 0:
|
||||
error_message = stderr.decode() if stderr else "Unknown error"
|
||||
raise VideoError(f"Failed to add audio to video: {error_message}")
|
||||
|
||||
self.logger.info(f"Successfully added audio to video: {output_file}")
|
||||
|
||||
except Exception as e:
|
||||
raise VideoError(f"Failed to add audio to video: {str(e)}") from e
|
||||
else:
|
||||
self.logger.info(f"[DRY RUN] Would add audio to video: {output_file}")
|
||||
|
||||
return output_file
|
||||
|
||||
async def _create_video_from_audio(self, audio_file, output_file, duration, resolution,
|
||||
fps, codec, bitrate, background_color):
|
||||
"""
|
||||
Create a video from an audio file.
|
||||
|
||||
Args:
|
||||
audio_file: The audio file
|
||||
output_file: The output file path
|
||||
duration: The duration in seconds
|
||||
resolution: The resolution
|
||||
fps: The frames per second
|
||||
codec: The codec
|
||||
bitrate: The bitrate
|
||||
background_color: The background color
|
||||
|
||||
Returns:
|
||||
The output file path
|
||||
"""
|
||||
# Create a video from audio
|
||||
command = (
|
||||
f'{self.ffmpeg_base_command} -f lavfi -i color=c={background_color}:s={resolution}:r={fps} '
|
||||
f'-i "{audio_file}" -t {duration} -c:v {codec} -profile:v 3 -vendor ap10 '
|
||||
f'-b:v {bitrate} -pix_fmt yuv422p10le -c:a pcm_s24le "{output_file}"'
|
||||
)
|
||||
|
||||
self.logger.debug(f"Creating video from audio: {command}")
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
stdout, stderr = await process.communicate()
|
||||
|
||||
if process.returncode != 0:
|
||||
error_message = stderr.decode() if stderr else "Unknown error"
|
||||
raise VideoError(f"Failed to create video from audio: {error_message}")
|
||||
|
||||
return output_file
|
||||
|
||||
async def _combine_videos_simple(self, concat_list, output_file):
|
||||
"""
|
||||
Combine videos using the concat demuxer.
|
||||
|
||||
Args:
|
||||
concat_list: The concat list file
|
||||
output_file: The output file path
|
||||
|
||||
Returns:
|
||||
The output file path
|
||||
"""
|
||||
# Combine videos
|
||||
command = (
|
||||
f'{self.ffmpeg_base_command} -f concat -safe 0 -i "{concat_list}" '
|
||||
f'-c:v prores_ks -profile:v 3 -vendor ap10 -bits_per_mb 8000 '
|
||||
f'-pix_fmt yuv422p10le -c:a pcm_s24le "{output_file}"'
|
||||
)
|
||||
|
||||
self.logger.debug(f"Combining videos: {command}")
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
stdout, stderr = await process.communicate()
|
||||
|
||||
if process.returncode != 0:
|
||||
error_message = stderr.decode() if stderr else "Unknown error"
|
||||
raise VideoError(f"Failed to combine videos: {error_message}")
|
||||
|
||||
return output_file
|
||||
|
||||
async def _combine_videos_with_transitions(self, videos, output_file, transition_duration):
|
||||
"""
|
||||
Combine videos with crossfade transitions.
|
||||
|
||||
Args:
|
||||
videos: The list of video files
|
||||
output_file: The output file path
|
||||
transition_duration: The transition duration in seconds
|
||||
|
||||
Returns:
|
||||
The output file path
|
||||
"""
|
||||
# Create a complex filter for crossfade transitions
|
||||
filter_complex = ""
|
||||
inputs = ""
|
||||
|
||||
# Add input files
|
||||
for i, video in enumerate(videos):
|
||||
inputs += f' -i "{video}"'
|
||||
|
||||
# Create filter complex
|
||||
for i in range(len(videos)):
|
||||
filter_complex += f"[{i}:v]setpts=PTS-STARTPTS[v{i}];"
|
||||
|
||||
# Add crossfade transitions
|
||||
for i in range(len(videos) - 1):
|
||||
filter_complex += (
|
||||
f"[v{i}][v{i+1}]xfade=transition=fade:duration={transition_duration}:offset="
|
||||
f"{self._get_video_duration(videos[i]) - transition_duration}[v{i}out];"
|
||||
)
|
||||
|
||||
# Finalize filter complex
|
||||
if len(videos) > 2:
|
||||
for i in range(len(videos) - 2):
|
||||
filter_complex += f"[v{i}out][v{i+2}]concat=n=2:v=1:a=0[v{i+1}out];"
|
||||
filter_complex = filter_complex[:-1] # Remove last semicolon
|
||||
output_label = f"[v{len(videos)-2}out]"
|
||||
else:
|
||||
output_label = "[v0out]"
|
||||
|
||||
# Combine videos with transitions
|
||||
command = (
|
||||
f'{self.ffmpeg_base_command}{inputs} -filter_complex "{filter_complex}" '
|
||||
f'-map "{output_label}" -c:v prores_ks -profile:v 3 -vendor ap10 '
|
||||
f'-bits_per_mb 8000 -pix_fmt yuv422p10le "{output_file}"'
|
||||
)
|
||||
|
||||
self.logger.debug(f"Combining videos with transitions: {command}")
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
stdout, stderr = await process.communicate()
|
||||
|
||||
if process.returncode != 0:
|
||||
error_message = stderr.decode() if stderr else "Unknown error"
|
||||
raise VideoError(f"Failed to combine videos with transitions: {error_message}")
|
||||
|
||||
return output_file
|
||||
|
||||
async def _get_video_duration(self, video_file):
|
||||
"""
|
||||
Get the duration of a video file.
|
||||
|
||||
Args:
|
||||
video_file: The video file
|
||||
|
||||
Returns:
|
||||
The duration in seconds
|
||||
"""
|
||||
# Get video duration
|
||||
command = (
|
||||
f'{self.ffmpeg_path} -i "{video_file}" -hide_banner 2>&1 | '
|
||||
f'grep "Duration" | cut -d " " -f 4 | sed s/,//'
|
||||
)
|
||||
|
||||
self.logger.debug(f"Getting video duration: {command}")
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE,
|
||||
shell=True
|
||||
)
|
||||
stdout, stderr = await process.communicate()
|
||||
|
||||
if process.returncode != 0:
|
||||
error_message = stderr.decode() if stderr else "Unknown error"
|
||||
raise VideoError(f"Failed to get video duration: {error_message}")
|
||||
|
||||
# Parse duration
|
||||
duration_str = stdout.decode().strip()
|
||||
if not duration_str:
|
||||
raise VideoError(f"Failed to get video duration: {video_file}")
|
||||
|
||||
# Convert HH:MM:SS.ms to seconds
|
||||
hours, minutes, seconds = duration_str.split(":")
|
||||
seconds, milliseconds = seconds.split(".")
|
||||
|
||||
duration = (
|
||||
int(hours) * 3600 +
|
||||
int(minutes) * 60 +
|
||||
int(seconds) +
|
||||
int(milliseconds) / 100
|
||||
)
|
||||
|
||||
return duration
|
||||
|
||||
async def render_lyrics_video(self, track):
|
||||
"""
|
||||
Render a video with lyrics.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated video information
|
||||
"""
|
||||
self.logger.info(f"Rendering lyrics video for {track.base_name}")
|
||||
|
||||
# Define output path
|
||||
output_path = os.path.join(track.track_output_dir, f"{track.base_name} (With Vocals).mp4")
|
||||
|
||||
# Skip if output already exists
|
||||
if os.path.isfile(output_path):
|
||||
self.logger.info(f"Lyrics video already exists: {output_path}")
|
||||
track.video_with_lyrics = output_path
|
||||
return track
|
||||
|
||||
# Debug logging
|
||||
self.logger.debug(f"processed_lyrics: {track.processed_lyrics}, type: {type(track.processed_lyrics)}")
|
||||
self.logger.debug(f"title_video: {track.title_video}, type: {type(track.title_video)}")
|
||||
self.logger.debug(f"instrumental: {track.instrumental}, type: {type(track.instrumental)}")
|
||||
|
||||
# Handle case where processed_lyrics is a dictionary
|
||||
lyrics_file = None
|
||||
if isinstance(track.processed_lyrics, dict):
|
||||
# Try to get the formatted lyrics file
|
||||
if 'formatted_lyrics_file' in track.processed_lyrics:
|
||||
lyrics_file = track.processed_lyrics['formatted_lyrics_file']
|
||||
elif 'formatted_lyrics' in track.processed_lyrics:
|
||||
lyrics_file = track.processed_lyrics['formatted_lyrics']
|
||||
elif 'ass_filepath' in track.processed_lyrics:
|
||||
lyrics_file = track.processed_lyrics['ass_filepath']
|
||||
else:
|
||||
lyrics_file = track.processed_lyrics
|
||||
|
||||
# Check for processed lyrics
|
||||
if not lyrics_file or not os.path.isfile(lyrics_file):
|
||||
self.logger.warning(f"No processed lyrics found for {track.base_name}")
|
||||
return track
|
||||
|
||||
# Check for audio file
|
||||
audio_file = track.audio_file
|
||||
if not audio_file or not os.path.isfile(audio_file):
|
||||
self.logger.warning(f"No audio file found for {track.base_name}")
|
||||
return track
|
||||
|
||||
# Render video
|
||||
if not self.config.dry_run:
|
||||
try:
|
||||
# Determine if we have a valid title video
|
||||
has_title_video = track.title_video and os.path.isfile(track.title_video)
|
||||
|
||||
# Create temporary subtitle file in ASS format if needed
|
||||
if lyrics_file.endswith('.lrc'):
|
||||
subtitle_file = await self._convert_lrc_to_ass(lyrics_file, track.track_output_dir)
|
||||
else:
|
||||
subtitle_file = lyrics_file
|
||||
|
||||
# Build ffmpeg command
|
||||
if has_title_video:
|
||||
# Use title video if available
|
||||
command = (
|
||||
f'{self.ffmpeg_base_command} -i "{track.title_video}" -i "{audio_file}" '
|
||||
f'-vf "ass={subtitle_file}" '
|
||||
f'-c:v libx264 -preset medium -crf 22 -c:a aac -b:a 192k '
|
||||
f'-pix_fmt yuv420p -shortest "{output_path}"'
|
||||
)
|
||||
else:
|
||||
# Create video from audio with black background
|
||||
command = (
|
||||
f'{self.ffmpeg_base_command} -f lavfi -i color=c=black:s=1920x1080:r=30 '
|
||||
f'-i "{audio_file}" -vf "ass={subtitle_file}" '
|
||||
f'-c:v libx264 -preset medium -crf 22 -c:a aac -b:a 192k '
|
||||
f'-pix_fmt yuv420p -shortest -t {track.duration} "{output_path}"'
|
||||
)
|
||||
|
||||
# Execute command
|
||||
self.logger.debug(f"Rendering lyrics video: {command}")
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
stdout, stderr = await process.communicate()
|
||||
|
||||
if process.returncode != 0:
|
||||
error_message = stderr.decode() if stderr else "Unknown error"
|
||||
raise VideoError(f"Failed to render lyrics video: {error_message}")
|
||||
|
||||
track.video_with_lyrics = output_path
|
||||
self.logger.info(f"Successfully rendered lyrics video: {output_path}")
|
||||
|
||||
# Clean up temporary files
|
||||
if lyrics_file.endswith('.lrc') and os.path.isfile(subtitle_file) and subtitle_file != lyrics_file:
|
||||
os.remove(subtitle_file)
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to render lyrics video: {str(e)}")
|
||||
# Continue with other processing
|
||||
else:
|
||||
self.logger.info(f"[DRY RUN] Would render lyrics video: {output_path}")
|
||||
track.video_with_lyrics = output_path
|
||||
|
||||
return track
|
||||
|
||||
async def render_instrumental_video(self, track):
|
||||
"""
|
||||
Render a video with instrumental audio.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated video information
|
||||
"""
|
||||
self.logger.info(f"Rendering instrumental video for {track.base_name}")
|
||||
|
||||
# Define output path
|
||||
output_path = os.path.join(track.track_output_dir, f"{track.base_name} (Instrumental).mp4")
|
||||
|
||||
# Skip if output already exists
|
||||
if os.path.isfile(output_path):
|
||||
self.logger.info(f"Instrumental video already exists: {output_path}")
|
||||
track.video_with_instrumental = output_path
|
||||
return track
|
||||
|
||||
# Check for title video
|
||||
if not track.title_video or not os.path.isfile(track.title_video):
|
||||
self.logger.warning(f"No title video found for {track.base_name}")
|
||||
return track
|
||||
|
||||
# Check for instrumental audio
|
||||
if not track.instrumental or not os.path.isfile(track.instrumental):
|
||||
self.logger.warning(f"No instrumental audio found for {track.base_name}")
|
||||
return track
|
||||
|
||||
# Render video
|
||||
if not self.config.dry_run:
|
||||
try:
|
||||
# Build ffmpeg command
|
||||
command = (
|
||||
f'{self.ffmpeg_base_command} -i "{track.title_video}" -i "{track.instrumental}" '
|
||||
f'-map 0:v -map 1:a -c:v libx264 -preset medium -crf 22 -c:a aac -b:a 192k '
|
||||
f'-pix_fmt yuv420p -shortest "{output_path}"'
|
||||
)
|
||||
|
||||
# Execute command
|
||||
self.logger.debug(f"Rendering instrumental video: {command}")
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
stdout, stderr = await process.communicate()
|
||||
|
||||
if process.returncode != 0:
|
||||
error_message = stderr.decode() if stderr else "Unknown error"
|
||||
raise VideoError(f"Failed to render instrumental video: {error_message}")
|
||||
|
||||
track.video_with_instrumental = output_path
|
||||
self.logger.info(f"Successfully rendered instrumental video: {output_path}")
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to render instrumental video: {str(e)}")
|
||||
# Continue with other processing
|
||||
else:
|
||||
self.logger.info(f"[DRY RUN] Would render instrumental video: {output_path}")
|
||||
track.video_with_instrumental = output_path
|
||||
|
||||
return track
|
||||
|
||||
async def render_karaoke_video(self, track):
|
||||
"""
|
||||
Render a karaoke video with lyrics and instrumental audio.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated video information
|
||||
"""
|
||||
self.logger.info(f"Rendering karaoke video for {track.base_name}")
|
||||
|
||||
# Skip if no processed lyrics
|
||||
if not track.processed_lyrics or not track.processed_lyrics.get("lrc_filepath"):
|
||||
self.logger.info("No processed lyrics available, skipping karaoke video rendering")
|
||||
return track
|
||||
|
||||
# Skip if no instrumental audio
|
||||
if not track.separated_audio["clean_instrumental"].get("instrumental"):
|
||||
self.logger.info("No instrumental audio available, skipping karaoke video rendering")
|
||||
return track
|
||||
|
||||
# Define output path
|
||||
output_path = os.path.join(track.track_output_dir, f"{track.base_name} (Karaoke).mp4")
|
||||
|
||||
# Skip if output already exists
|
||||
if os.path.isfile(output_path):
|
||||
self.logger.info(f"Karaoke video already exists: {output_path}")
|
||||
track.final_video = output_path
|
||||
return track
|
||||
|
||||
# Get input paths
|
||||
title_video = track.title_video
|
||||
end_video = track.end_video
|
||||
instrumental_audio = track.separated_audio["clean_instrumental"]["instrumental"]
|
||||
lyrics_file = track.processed_lyrics.get("lrc_filepath")
|
||||
|
||||
# Check if all required files exist
|
||||
if not all(os.path.isfile(f) for f in [title_video, instrumental_audio, lyrics_file]):
|
||||
self.logger.warning("Missing required files for karaoke video rendering")
|
||||
return track
|
||||
|
||||
# Render video
|
||||
if not self.config.dry_run:
|
||||
try:
|
||||
# Create temporary subtitle file in ASS format
|
||||
ass_file = await self._convert_lrc_to_ass(lyrics_file, track.track_output_dir)
|
||||
|
||||
# Build ffmpeg command
|
||||
command = (
|
||||
f'{self.ffmpeg_base_command} -i "{title_video}" -i "{instrumental_audio}" '
|
||||
)
|
||||
|
||||
# Add end video if available
|
||||
if end_video and os.path.isfile(end_video):
|
||||
command += f'-i "{end_video}" '
|
||||
filter_complex = (
|
||||
f'-filter_complex "[0:v][1:a][2:v][1:a]concat=n=2:v=1:a=1[outv][outa]" '
|
||||
f'-map "[outv]" -map "[outa]" '
|
||||
)
|
||||
else:
|
||||
filter_complex = ""
|
||||
command += f'-map 0:v -map 1:a '
|
||||
|
||||
# Add subtitle filter
|
||||
if filter_complex:
|
||||
command = command.replace("-filter_complex", f'-filter_complex "ass={ass_file}:')
|
||||
else:
|
||||
command += f'-vf "ass={ass_file}" '
|
||||
|
||||
# Add output options
|
||||
command += (
|
||||
f'-c:v libx264 -preset medium -crf 22 -c:a aac -b:a 192k '
|
||||
f'-pix_fmt yuv420p -shortest "{output_path}"'
|
||||
)
|
||||
|
||||
# Execute command
|
||||
self.logger.debug(f"Rendering karaoke video: {command}")
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
stdout, stderr = await process.communicate()
|
||||
|
||||
if process.returncode != 0:
|
||||
error_message = stderr.decode() if stderr else "Unknown error"
|
||||
raise VideoError(f"Failed to render karaoke video: {error_message}")
|
||||
|
||||
track.final_video = output_path
|
||||
self.logger.info(f"Successfully rendered karaoke video: {output_path}")
|
||||
|
||||
# Clean up temporary files
|
||||
if os.path.isfile(ass_file):
|
||||
os.remove(ass_file)
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to render karaoke video: {str(e)}")
|
||||
# Continue with other processing
|
||||
else:
|
||||
self.logger.info(f"[DRY RUN] Would render karaoke video: {output_path}")
|
||||
track.final_video = output_path
|
||||
|
||||
return track
|
||||
|
||||
async def _convert_lrc_to_ass(self, lrc_file, output_dir):
|
||||
"""
|
||||
Convert LRC file to ASS subtitle format.
|
||||
|
||||
Args:
|
||||
lrc_file: The LRC file path
|
||||
output_dir: The output directory
|
||||
|
||||
Returns:
|
||||
The path to the ASS file
|
||||
"""
|
||||
self.logger.info(f"Converting LRC file to ASS: {lrc_file}")
|
||||
|
||||
# Define output path
|
||||
ass_file = os.path.join(output_dir, os.path.basename(lrc_file).replace(".lrc", ".ass"))
|
||||
|
||||
# Skip if output already exists
|
||||
if os.path.isfile(ass_file):
|
||||
self.logger.info(f"ASS file already exists: {ass_file}")
|
||||
return ass_file
|
||||
|
||||
# Create a temporary file for the ASS file
|
||||
with tempfile.NamedTemporaryFile(suffix=".ass", delete=False) as temp_file:
|
||||
temp_ass_file = temp_file.name
|
||||
self._temp_files.append(temp_ass_file) # Track temporary file
|
||||
|
||||
# Read LRC file
|
||||
with open(lrc_file, "r", encoding="utf-8") as f:
|
||||
lrc_content = f.readlines()
|
||||
|
||||
# Parse LRC content
|
||||
lyrics = []
|
||||
for line in lrc_content:
|
||||
line = line.strip()
|
||||
if not line or line.startswith("[ti:") or line.startswith("[ar:") or line.startswith("[al:"):
|
||||
continue
|
||||
|
||||
# Extract timestamp and text
|
||||
if line.startswith("[") and "]" in line:
|
||||
timestamp = line[1:line.find("]")]
|
||||
text = line[line.find("]") + 1:].strip()
|
||||
|
||||
# Parse timestamp
|
||||
if ":" in timestamp and "." in timestamp:
|
||||
minutes, seconds = timestamp.split(":")
|
||||
seconds, milliseconds = seconds.split(".")
|
||||
|
||||
start_time = int(minutes) * 60 + int(seconds) + int(milliseconds) / 100
|
||||
lyrics.append((start_time, text))
|
||||
|
||||
# Sort lyrics by timestamp
|
||||
lyrics.sort(key=lambda x: x[0])
|
||||
|
||||
# Calculate end times
|
||||
for i in range(len(lyrics) - 1):
|
||||
lyrics[i] = (lyrics[i][0], lyrics[i + 1][0], lyrics[i][1])
|
||||
|
||||
# Add end time for last lyric
|
||||
if lyrics:
|
||||
lyrics[-1] = (lyrics[-1][0], lyrics[-1][0] + 5, lyrics[-1][1])
|
||||
|
||||
# Create ASS file
|
||||
with open(temp_ass_file, "w", encoding="utf-8") as f:
|
||||
# Write header
|
||||
f.write("[Script Info]\n")
|
||||
f.write("Title: Karaoke Lyrics\n")
|
||||
f.write("ScriptType: v4.00+\n")
|
||||
f.write("PlayResX: 3840\n")
|
||||
f.write("PlayResY: 2160\n")
|
||||
f.write("Collisions: Normal\n\n")
|
||||
|
||||
# Write styles
|
||||
f.write("[V4+ Styles]\n")
|
||||
f.write("Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding\n")
|
||||
f.write("Style: Default,Arial,72,&H00FFFFFF,&H00FFFFFF,&H00000000,&H80000000,-1,0,0,0,100,100,0,0,1,3,0,2,20,20,20,1\n\n")
|
||||
|
||||
# Write events
|
||||
f.write("[Events]\n")
|
||||
f.write("Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\n")
|
||||
|
||||
# Write lyrics
|
||||
for start_time, end_time, text in lyrics:
|
||||
start_str = self._format_time(start_time)
|
||||
end_str = self._format_time(end_time)
|
||||
f.write(f"Dialogue: 0,{start_str},{end_str},Default,,0,0,0,,{text}\n")
|
||||
|
||||
# Copy to output path
|
||||
shutil.copy2(temp_ass_file, ass_file)
|
||||
|
||||
self.logger.info(f"Successfully converted LRC to ASS: {ass_file}")
|
||||
return ass_file
|
||||
|
||||
def _format_time(self, seconds):
|
||||
"""
|
||||
Format time in seconds to ASS format (h:mm:ss.cc).
|
||||
|
||||
Args:
|
||||
seconds: The time in seconds
|
||||
|
||||
Returns:
|
||||
The formatted time string
|
||||
"""
|
||||
hours = int(seconds // 3600)
|
||||
minutes = int((seconds % 3600) // 60)
|
||||
seconds = seconds % 60
|
||||
centiseconds = int((seconds - int(seconds)) * 100)
|
||||
seconds = int(seconds)
|
||||
|
||||
return f"{hours}:{minutes:02d}:{seconds:02d}.{centiseconds:02d}"
|
||||
|
||||
async def cleanup(self):
|
||||
"""
|
||||
Perform cleanup operations for the video renderer.
|
||||
"""
|
||||
self.logger.info("Cleaning up video renderer resources")
|
||||
|
||||
# Clean up any temporary files
|
||||
if hasattr(self, '_temp_files') and self._temp_files:
|
||||
for temp_file in self._temp_files:
|
||||
if os.path.exists(temp_file):
|
||||
try:
|
||||
os.remove(temp_file)
|
||||
self.logger.debug(f"Removed temporary file: {temp_file}")
|
||||
except Exception as e:
|
||||
self.logger.warning(f"Failed to remove temporary file {temp_file}: {str(e)}")
|
||||
|
||||
self.logger.info("Video renderer cleanup complete")
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,236 @@
|
||||
import os
|
||||
import asyncio
|
||||
import logging
|
||||
from typing import List, Optional
|
||||
from karaoke_gen.core.track import Track
|
||||
from karaoke_gen.core.exceptions import VideoError
|
||||
from karaoke_gen.services.video.screens import ScreenGenerator
|
||||
from karaoke_gen.services.video.renderer import VideoRenderer
|
||||
from karaoke_gen.services.video.compositor import VideoCompositor
|
||||
|
||||
|
||||
class VideoService:
|
||||
"""
|
||||
Service for orchestrating the video generation process.
|
||||
"""
|
||||
|
||||
def __init__(self, config):
|
||||
"""
|
||||
Initialize the video service.
|
||||
|
||||
Args:
|
||||
config: The project configuration
|
||||
"""
|
||||
self.config = config
|
||||
self.logger = config.logger or logging.getLogger(__name__)
|
||||
|
||||
# Initialize components
|
||||
self.screen_generator = ScreenGenerator(config)
|
||||
self.renderer = VideoRenderer(config)
|
||||
self.compositor = VideoCompositor(config)
|
||||
|
||||
async def process_video(self, track: Track) -> Track:
|
||||
"""
|
||||
Process video for a track, including screen generation, rendering, and composition.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated video information
|
||||
"""
|
||||
self.logger.info(f"Processing video for {track.base_name}")
|
||||
|
||||
try:
|
||||
# Skip if final video already exists and we're not forcing regeneration
|
||||
if track.final_video and os.path.isfile(track.final_video) and not self.config.force_regenerate:
|
||||
self.logger.info(f"Final video already exists for {track.base_name}, skipping video processing")
|
||||
return track
|
||||
|
||||
# Generate screens
|
||||
track = await self.generate_screens(track)
|
||||
|
||||
# Render videos
|
||||
track = await self.render_videos(track)
|
||||
|
||||
# Compose final video
|
||||
track = await self.compose_final_video(track)
|
||||
|
||||
# Create additional versions
|
||||
track = await self.create_additional_versions(track)
|
||||
|
||||
return track
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to process video for {track.base_name}: {str(e)}")
|
||||
# Continue with other processing
|
||||
return track
|
||||
|
||||
async def generate_screens(self, track: Track) -> Track:
|
||||
"""
|
||||
Generate title and end screens for the track.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated screen information
|
||||
"""
|
||||
self.logger.info(f"Generating screens for {track.base_name}")
|
||||
|
||||
try:
|
||||
# Generate title screen
|
||||
if not track.title_video or not os.path.isfile(track.title_video) or self.config.force_regenerate:
|
||||
track = await self.screen_generator.generate_title_screen(track)
|
||||
else:
|
||||
self.logger.info(f"Title screen already exists: {track.title_video}")
|
||||
|
||||
# Generate end screen
|
||||
if not track.end_video or not os.path.isfile(track.end_video) or self.config.force_regenerate:
|
||||
track = await self.screen_generator.generate_end_screen(track)
|
||||
else:
|
||||
self.logger.info(f"End screen already exists: {track.end_video}")
|
||||
|
||||
return track
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to generate screens for {track.base_name}: {str(e)}")
|
||||
# Continue with other processing
|
||||
return track
|
||||
|
||||
async def render_videos(self, track: Track) -> Track:
|
||||
"""
|
||||
Render videos for the track.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated video information
|
||||
"""
|
||||
self.logger.info(f"Rendering videos for {track.base_name}")
|
||||
|
||||
try:
|
||||
# Render lyrics video
|
||||
if (not track.video_with_lyrics or not os.path.isfile(track.video_with_lyrics) or
|
||||
self.config.force_regenerate):
|
||||
track = await self.renderer.render_lyrics_video(track)
|
||||
else:
|
||||
self.logger.info(f"Lyrics video already exists: {track.video_with_lyrics}")
|
||||
|
||||
# Render instrumental video
|
||||
if (not track.video_with_instrumental or not os.path.isfile(track.video_with_instrumental) or
|
||||
self.config.force_regenerate):
|
||||
track = await self.renderer.render_instrumental_video(track)
|
||||
else:
|
||||
self.logger.info(f"Instrumental video already exists: {track.video_with_instrumental}")
|
||||
|
||||
return track
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to render videos for {track.base_name}: {str(e)}")
|
||||
# Continue with other processing
|
||||
return track
|
||||
|
||||
async def compose_final_video(self, track: Track) -> Track:
|
||||
"""
|
||||
Compose the final video for the track.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated final video information
|
||||
"""
|
||||
self.logger.info(f"Composing final video for {track.base_name}")
|
||||
|
||||
try:
|
||||
# Skip if final video already exists
|
||||
if track.final_video and os.path.isfile(track.final_video) and not self.config.force_regenerate:
|
||||
self.logger.info(f"Final video already exists: {track.final_video}")
|
||||
return track
|
||||
|
||||
# Check for required videos
|
||||
if not track.title_video or not os.path.isfile(track.title_video):
|
||||
self.logger.warning(f"Title video not found for {track.base_name}")
|
||||
return track
|
||||
|
||||
if not track.video_with_lyrics and not track.video_with_instrumental:
|
||||
self.logger.warning(f"No content videos found for {track.base_name}")
|
||||
return track
|
||||
|
||||
# Compose final video
|
||||
track = await self.compositor.compose_final_video(track)
|
||||
|
||||
return track
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to compose final video for {track.base_name}: {str(e)}")
|
||||
# Continue with other processing
|
||||
return track
|
||||
|
||||
async def create_additional_versions(self, track: Track) -> Track:
|
||||
"""
|
||||
Create additional versions of the final video.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
|
||||
Returns:
|
||||
The track with updated video version information
|
||||
"""
|
||||
self.logger.info(f"Creating additional video versions for {track.base_name}")
|
||||
|
||||
try:
|
||||
# Skip if no final video
|
||||
if not track.final_video or not os.path.isfile(track.final_video):
|
||||
self.logger.warning(f"No final video found for {track.base_name}")
|
||||
return track
|
||||
|
||||
# Create lossless version
|
||||
if not track.final_video_mkv or not os.path.isfile(track.final_video_mkv) or self.config.force_regenerate:
|
||||
track = await self.compositor.create_lossless_version(track)
|
||||
else:
|
||||
self.logger.info(f"Lossless version already exists: {track.final_video_mkv}")
|
||||
|
||||
# Create 720p version
|
||||
if not track.final_video_720p or not os.path.isfile(track.final_video_720p) or self.config.force_regenerate:
|
||||
track = await self.compositor.create_720p_version(track)
|
||||
else:
|
||||
self.logger.info(f"720p version already exists: {track.final_video_720p}")
|
||||
|
||||
# Create lossy version
|
||||
if not track.final_video_lossy or not os.path.isfile(track.final_video_lossy) or self.config.force_regenerate:
|
||||
track = await self.compositor.create_lossy_version(track)
|
||||
else:
|
||||
self.logger.info(f"Lossy version already exists: {track.final_video_lossy}")
|
||||
|
||||
return track
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Failed to create additional versions for {track.base_name}: {str(e)}")
|
||||
# Continue with other processing
|
||||
return track
|
||||
|
||||
async def cleanup(self):
|
||||
"""
|
||||
Perform cleanup operations for the video service.
|
||||
"""
|
||||
self.logger.info("Cleaning up video service resources")
|
||||
|
||||
# Clean up temporary files
|
||||
if self.config.cleanup_temp_files:
|
||||
self.logger.info("Cleaning up temporary video files")
|
||||
# Implementation would depend on what temporary files are created
|
||||
|
||||
# Close any open resources
|
||||
if hasattr(self, 'screen_generator'):
|
||||
await self.screen_generator.cleanup()
|
||||
|
||||
if hasattr(self, 'renderer'):
|
||||
await self.renderer.cleanup()
|
||||
|
||||
if hasattr(self, 'compositor'):
|
||||
await self.compositor.cleanup()
|
||||
|
||||
self.logger.info("Video service cleanup complete")
|
||||
@@ -0,0 +1,545 @@
|
||||
import os
|
||||
import asyncio
|
||||
import tempfile
|
||||
from PIL import Image, ImageDraw, ImageFont
|
||||
import pkg_resources
|
||||
from karaoke_gen.core.exceptions import VideoError
|
||||
|
||||
|
||||
class TextRenderer:
|
||||
"""
|
||||
Handles text rendering for videos.
|
||||
"""
|
||||
|
||||
def __init__(self, config):
|
||||
"""
|
||||
Initialize the text renderer.
|
||||
|
||||
Args:
|
||||
config: The project configuration
|
||||
"""
|
||||
self.config = config
|
||||
self.logger = config.logger
|
||||
|
||||
# Path to ffmpeg
|
||||
self.ffmpeg_path = "ffmpeg"
|
||||
|
||||
# Set up ffmpeg base command
|
||||
self.ffmpeg_base_command = f"{self.ffmpeg_path} -hide_banner -nostats"
|
||||
|
||||
if self.config.log_level <= 10: # DEBUG
|
||||
self.ffmpeg_base_command += " -loglevel verbose"
|
||||
else:
|
||||
self.ffmpeg_base_command += " -loglevel fatal"
|
||||
|
||||
async def render_lyrics(self, track, lyrics_file, output_file, font_name=None, font_size=None,
|
||||
font_color=None, outline_color=None, outline_width=None,
|
||||
position=None, alignment=None, background_color=None):
|
||||
"""
|
||||
Render lyrics to a video file.
|
||||
|
||||
Args:
|
||||
track: The track to process
|
||||
lyrics_file: The lyrics file to render
|
||||
output_file: The output file path
|
||||
font_name: The font name
|
||||
font_size: The font size
|
||||
font_color: The font color
|
||||
outline_color: The outline color
|
||||
outline_width: The outline width
|
||||
position: The position
|
||||
alignment: The alignment
|
||||
background_color: The background color
|
||||
|
||||
Returns:
|
||||
The output file path
|
||||
"""
|
||||
self.logger.info(f"Rendering lyrics for {track.base_name}")
|
||||
|
||||
# Skip if output already exists
|
||||
if os.path.isfile(output_file):
|
||||
self.logger.info(f"Lyrics video already exists: {output_file}")
|
||||
return output_file
|
||||
|
||||
# Check if lyrics file exists
|
||||
if not os.path.isfile(lyrics_file):
|
||||
self.logger.error(f"Lyrics file not found: {lyrics_file}")
|
||||
raise VideoError(f"Lyrics file not found: {lyrics_file}")
|
||||
|
||||
# Set default values
|
||||
font_name = font_name or self.config.lyrics_font or "Arial"
|
||||
font_size = font_size or self.config.lyrics_font_size or 48
|
||||
font_color = font_color or self.config.lyrics_font_color or "white"
|
||||
outline_color = outline_color or self.config.lyrics_outline_color or "black"
|
||||
outline_width = outline_width or self.config.lyrics_outline_width or 2
|
||||
position = position or self.config.lyrics_position or "bottom"
|
||||
alignment = alignment or self.config.lyrics_alignment or "center"
|
||||
background_color = background_color or self.config.lyrics_background_color or "transparent"
|
||||
|
||||
# Get font path
|
||||
font_path = self._get_font_path(font_name)
|
||||
|
||||
# Create subtitles file
|
||||
subtitles_file = await self._create_subtitles_file(
|
||||
lyrics_file,
|
||||
font_path,
|
||||
font_size,
|
||||
font_color,
|
||||
outline_color,
|
||||
outline_width,
|
||||
position,
|
||||
alignment,
|
||||
background_color
|
||||
)
|
||||
|
||||
# Create video with subtitles
|
||||
if not self.config.dry_run:
|
||||
try:
|
||||
# Create a black video if no input video is provided
|
||||
temp_video = await self._create_temp_black_video(track.duration)
|
||||
|
||||
# Add subtitles to video
|
||||
await self._add_subtitles_to_video(temp_video, subtitles_file, output_file)
|
||||
|
||||
# Clean up temporary files
|
||||
os.remove(temp_video)
|
||||
os.remove(subtitles_file)
|
||||
|
||||
self.logger.info(f"Successfully rendered lyrics: {output_file}")
|
||||
|
||||
except Exception as e:
|
||||
raise VideoError(f"Failed to render lyrics: {str(e)}") from e
|
||||
else:
|
||||
self.logger.info(f"[DRY RUN] Would render lyrics: {output_file}")
|
||||
|
||||
return output_file
|
||||
|
||||
async def render_text_overlay(self, input_video, output_video, text, font_name=None, font_size=None,
|
||||
font_color=None, outline_color=None, outline_width=None,
|
||||
position=None, alignment=None, background_color=None,
|
||||
start_time=None, end_time=None):
|
||||
"""
|
||||
Render text overlay on a video.
|
||||
|
||||
Args:
|
||||
input_video: The input video file
|
||||
output_video: The output video file
|
||||
text: The text to render
|
||||
font_name: The font name
|
||||
font_size: The font size
|
||||
font_color: The font color
|
||||
outline_color: The outline color
|
||||
outline_width: The outline width
|
||||
position: The position
|
||||
alignment: The alignment
|
||||
background_color: The background color
|
||||
start_time: The start time
|
||||
end_time: The end time
|
||||
|
||||
Returns:
|
||||
The output video file
|
||||
"""
|
||||
self.logger.info(f"Rendering text overlay on {input_video}")
|
||||
|
||||
# Skip if output already exists
|
||||
if os.path.isfile(output_video):
|
||||
self.logger.info(f"Text overlay video already exists: {output_video}")
|
||||
return output_video
|
||||
|
||||
# Check if input video exists
|
||||
if not os.path.isfile(input_video):
|
||||
self.logger.error(f"Input video not found: {input_video}")
|
||||
raise VideoError(f"Input video not found: {input_video}")
|
||||
|
||||
# Set default values
|
||||
font_name = font_name or self.config.overlay_font or "Arial"
|
||||
font_size = font_size or self.config.overlay_font_size or 48
|
||||
font_color = font_color or self.config.overlay_font_color or "white"
|
||||
outline_color = outline_color or self.config.overlay_outline_color or "black"
|
||||
outline_width = outline_width or self.config.overlay_outline_width or 2
|
||||
position = position or self.config.overlay_position or "bottom"
|
||||
alignment = alignment or self.config.overlay_alignment or "center"
|
||||
background_color = background_color or self.config.overlay_background_color or "transparent"
|
||||
|
||||
# Get font path
|
||||
font_path = self._get_font_path(font_name)
|
||||
|
||||
# Create subtitles file with single entry
|
||||
subtitles_file = await self._create_simple_subtitles_file(
|
||||
text,
|
||||
start_time or 0,
|
||||
end_time or 999999,
|
||||
font_path,
|
||||
font_size,
|
||||
font_color,
|
||||
outline_color,
|
||||
outline_width,
|
||||
position,
|
||||
alignment,
|
||||
background_color
|
||||
)
|
||||
|
||||
# Add subtitles to video
|
||||
if not self.config.dry_run:
|
||||
try:
|
||||
await self._add_subtitles_to_video(input_video, subtitles_file, output_video)
|
||||
|
||||
# Clean up temporary files
|
||||
os.remove(subtitles_file)
|
||||
|
||||
self.logger.info(f"Successfully rendered text overlay: {output_video}")
|
||||
|
||||
except Exception as e:
|
||||
raise VideoError(f"Failed to render text overlay: {str(e)}") from e
|
||||
else:
|
||||
self.logger.info(f"[DRY RUN] Would render text overlay: {output_video}")
|
||||
|
||||
return output_video
|
||||
|
||||
def _get_font_path(self, font_name):
|
||||
"""
|
||||
Get the path to a font file.
|
||||
|
||||
Args:
|
||||
font_name: The font name
|
||||
|
||||
Returns:
|
||||
The font path
|
||||
"""
|
||||
# Check if font is a path
|
||||
if os.path.isfile(font_name):
|
||||
return font_name
|
||||
|
||||
# Check in resources directory
|
||||
resources_dir = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "resources")
|
||||
font_path = os.path.join(resources_dir, font_name)
|
||||
if os.path.isfile(font_path):
|
||||
return font_path
|
||||
|
||||
# Try to find font in package resources
|
||||
try:
|
||||
font_path = pkg_resources.resource_filename("karaoke_gen", f"resources/{font_name}")
|
||||
if os.path.isfile(font_path):
|
||||
return font_path
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
# Default to a system font
|
||||
self.logger.warning(f"Font not found: {font_name}, using default font")
|
||||
return font_name
|
||||
|
||||
async def _create_subtitles_file(self, lyrics_file, font_path, font_size, font_color,
|
||||
outline_color, outline_width, position, alignment, background_color):
|
||||
"""
|
||||
Create a subtitles file from a lyrics file.
|
||||
|
||||
Args:
|
||||
lyrics_file: The lyrics file
|
||||
font_path: The font path
|
||||
font_size: The font size
|
||||
font_color: The font color
|
||||
outline_color: The outline color
|
||||
outline_width: The outline width
|
||||
position: The position
|
||||
alignment: The alignment
|
||||
background_color: The background color
|
||||
|
||||
Returns:
|
||||
The subtitles file path
|
||||
"""
|
||||
# Create a temporary file for subtitles
|
||||
with tempfile.NamedTemporaryFile(suffix=".ass", delete=False) as temp_file:
|
||||
subtitles_file = temp_file.name
|
||||
|
||||
# Parse LRC file and convert to ASS format
|
||||
with open(lyrics_file, "r", encoding="utf-8") as f:
|
||||
lrc_lines = f.readlines()
|
||||
|
||||
# Write ASS header
|
||||
with open(subtitles_file, "w", encoding="utf-8") as f:
|
||||
f.write("[Script Info]\n")
|
||||
f.write("Title: Lyrics\n")
|
||||
f.write("ScriptType: v4.00+\n")
|
||||
f.write("WrapStyle: 0\n")
|
||||
f.write("ScaledBorderAndShadow: yes\n")
|
||||
f.write("YCbCr Matrix: None\n\n")
|
||||
|
||||
f.write("[V4+ Styles]\n")
|
||||
f.write("Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding\n")
|
||||
|
||||
# Convert colors to ASS format
|
||||
primary_color = self._color_to_ass(font_color)
|
||||
outline_color_ass = self._color_to_ass(outline_color)
|
||||
background_color_ass = self._color_to_ass(background_color)
|
||||
|
||||
# Set alignment based on position and alignment
|
||||
ass_alignment = self._get_ass_alignment(position, alignment)
|
||||
|
||||
# Set margin based on position
|
||||
margin_v = 20 if position == "bottom" else (20 if position == "top" else 10)
|
||||
|
||||
f.write(f"Style: Default,{os.path.basename(font_path)},{font_size},{primary_color},{primary_color},{outline_color_ass},{background_color_ass},0,0,0,0,100,100,0,0,1,{outline_width},0,{ass_alignment},10,10,{margin_v},1\n\n")
|
||||
|
||||
f.write("[Events]\n")
|
||||
f.write("Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\n")
|
||||
|
||||
# Parse LRC lines
|
||||
events = []
|
||||
for line in lrc_lines:
|
||||
line = line.strip()
|
||||
if line and "[" in line and "]" in line:
|
||||
try:
|
||||
time_tag = line[line.find("[") + 1:line.find("]")]
|
||||
if ":" in time_tag and "." in time_tag:
|
||||
minutes, rest = time_tag.split(":")
|
||||
seconds, milliseconds = rest.split(".")
|
||||
|
||||
start_time_seconds = int(minutes) * 60 + int(seconds) + int(milliseconds) / 100
|
||||
text = line[line.find("]") + 1:].strip()
|
||||
|
||||
if text: # Only add non-empty lines
|
||||
events.append((start_time_seconds, text))
|
||||
except Exception as e:
|
||||
self.logger.warning(f"Failed to parse LRC line: {line}, error: {str(e)}")
|
||||
|
||||
# Sort events by start time
|
||||
events.sort(key=lambda x: x[0])
|
||||
|
||||
# Write events with end times
|
||||
for i, (start_time, text) in enumerate(events):
|
||||
# Set end time to the start time of the next event, or 5 seconds after if it's the last event
|
||||
end_time = events[i + 1][0] if i < len(events) - 1 else start_time + 5
|
||||
|
||||
# Format times as h:mm:ss.cc
|
||||
start_time_formatted = self._format_ass_time(start_time)
|
||||
end_time_formatted = self._format_ass_time(end_time)
|
||||
|
||||
# Escape special characters
|
||||
text = text.replace("\\", "\\\\").replace("{", "\\{").replace("}", "\\}")
|
||||
|
||||
f.write(f"Dialogue: 0,{start_time_formatted},{end_time_formatted},Default,,0,0,0,,{text}\n")
|
||||
|
||||
return subtitles_file
|
||||
|
||||
async def _create_simple_subtitles_file(self, text, start_time, end_time, font_path, font_size,
|
||||
font_color, outline_color, outline_width, position,
|
||||
alignment, background_color):
|
||||
"""
|
||||
Create a simple subtitles file with a single entry.
|
||||
|
||||
Args:
|
||||
text: The text
|
||||
start_time: The start time in seconds
|
||||
end_time: The end time in seconds
|
||||
font_path: The font path
|
||||
font_size: The font size
|
||||
font_color: The font color
|
||||
outline_color: The outline color
|
||||
outline_width: The outline width
|
||||
position: The position
|
||||
alignment: The alignment
|
||||
background_color: The background color
|
||||
|
||||
Returns:
|
||||
The subtitles file path
|
||||
"""
|
||||
# Create a temporary file for subtitles
|
||||
with tempfile.NamedTemporaryFile(suffix=".ass", delete=False) as temp_file:
|
||||
subtitles_file = temp_file.name
|
||||
|
||||
# Write ASS header
|
||||
with open(subtitles_file, "w", encoding="utf-8") as f:
|
||||
f.write("[Script Info]\n")
|
||||
f.write("Title: Text Overlay\n")
|
||||
f.write("ScriptType: v4.00+\n")
|
||||
f.write("WrapStyle: 0\n")
|
||||
f.write("ScaledBorderAndShadow: yes\n")
|
||||
f.write("YCbCr Matrix: None\n\n")
|
||||
|
||||
f.write("[V4+ Styles]\n")
|
||||
f.write("Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding\n")
|
||||
|
||||
# Convert colors to ASS format
|
||||
primary_color = self._color_to_ass(font_color)
|
||||
outline_color_ass = self._color_to_ass(outline_color)
|
||||
background_color_ass = self._color_to_ass(background_color)
|
||||
|
||||
# Set alignment based on position and alignment
|
||||
ass_alignment = self._get_ass_alignment(position, alignment)
|
||||
|
||||
# Set margin based on position
|
||||
margin_v = 20 if position == "bottom" else (20 if position == "top" else 10)
|
||||
|
||||
f.write(f"Style: Default,{os.path.basename(font_path)},{font_size},{primary_color},{primary_color},{outline_color_ass},{background_color_ass},0,0,0,0,100,100,0,0,1,{outline_width},0,{ass_alignment},10,10,{margin_v},1\n\n")
|
||||
|
||||
f.write("[Events]\n")
|
||||
f.write("Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\n")
|
||||
|
||||
# Format times as h:mm:ss.cc
|
||||
start_time_formatted = self._format_ass_time(start_time)
|
||||
end_time_formatted = self._format_ass_time(end_time)
|
||||
|
||||
# Escape special characters
|
||||
text = text.replace("\\", "\\\\").replace("{", "\\{").replace("}", "\\}")
|
||||
|
||||
f.write(f"Dialogue: 0,{start_time_formatted},{end_time_formatted},Default,,0,0,0,,{text}\n")
|
||||
|
||||
return subtitles_file
|
||||
|
||||
def _color_to_ass(self, color):
|
||||
"""
|
||||
Convert a color to ASS format.
|
||||
|
||||
Args:
|
||||
color: The color
|
||||
|
||||
Returns:
|
||||
The ASS color
|
||||
"""
|
||||
if color == "transparent":
|
||||
return "&H00FFFFFF" # Transparent
|
||||
|
||||
# Handle hex colors
|
||||
if color.startswith("#"):
|
||||
r = int(color[1:3], 16)
|
||||
g = int(color[3:5], 16)
|
||||
b = int(color[5:7], 16)
|
||||
return f"&H00{b:02X}{g:02X}{r:02X}"
|
||||
|
||||
# Handle named colors
|
||||
color_map = {
|
||||
"white": "&H00FFFFFF",
|
||||
"black": "&H00000000",
|
||||
"red": "&H000000FF",
|
||||
"green": "&H0000FF00",
|
||||
"blue": "&H00FF0000",
|
||||
"yellow": "&H0000FFFF",
|
||||
"cyan": "&H00FFFF00",
|
||||
"magenta": "&H00FF00FF",
|
||||
}
|
||||
|
||||
return color_map.get(color.lower(), "&H00FFFFFF") # Default to white
|
||||
|
||||
def _get_ass_alignment(self, position, alignment):
|
||||
"""
|
||||
Get the ASS alignment value.
|
||||
|
||||
Args:
|
||||
position: The position
|
||||
alignment: The alignment
|
||||
|
||||
Returns:
|
||||
The ASS alignment value
|
||||
"""
|
||||
# ASS alignment values:
|
||||
# 1: bottom left, 2: bottom center, 3: bottom right
|
||||
# 4: middle left, 5: middle center, 6: middle right
|
||||
# 7: top left, 8: top center, 9: top right
|
||||
|
||||
if position == "bottom":
|
||||
if alignment == "left":
|
||||
return 1
|
||||
elif alignment == "right":
|
||||
return 3
|
||||
else: # center
|
||||
return 2
|
||||
elif position == "middle":
|
||||
if alignment == "left":
|
||||
return 4
|
||||
elif alignment == "right":
|
||||
return 6
|
||||
else: # center
|
||||
return 5
|
||||
elif position == "top":
|
||||
if alignment == "left":
|
||||
return 7
|
||||
elif alignment == "right":
|
||||
return 9
|
||||
else: # center
|
||||
return 8
|
||||
else:
|
||||
return 2 # Default to bottom center
|
||||
|
||||
def _format_ass_time(self, seconds):
|
||||
"""
|
||||
Format seconds as h:mm:ss.cc for ASS format.
|
||||
|
||||
Args:
|
||||
seconds: The time in seconds
|
||||
|
||||
Returns:
|
||||
The formatted time
|
||||
"""
|
||||
hours = int(seconds // 3600)
|
||||
minutes = int((seconds % 3600) // 60)
|
||||
seconds_remainder = seconds % 60
|
||||
centiseconds = int((seconds_remainder - int(seconds_remainder)) * 100)
|
||||
|
||||
return f"{hours}:{minutes:02d}:{int(seconds_remainder):02d}.{centiseconds:02d}"
|
||||
|
||||
async def _create_temp_black_video(self, duration):
|
||||
"""
|
||||
Create a temporary black video.
|
||||
|
||||
Args:
|
||||
duration: The duration in seconds
|
||||
|
||||
Returns:
|
||||
The temporary video file path
|
||||
"""
|
||||
# Create a temporary file for the video
|
||||
with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as temp_file:
|
||||
temp_video = temp_file.name
|
||||
|
||||
# Create a black video
|
||||
command = (
|
||||
f'{self.ffmpeg_base_command} -f lavfi -i color=c=black:s=1920x1080:r=30 '
|
||||
f'-t {duration} -c:v libx264 -pix_fmt yuv420p "{temp_video}"'
|
||||
)
|
||||
|
||||
self.logger.debug(f"Creating temporary black video: {command}")
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
stdout, stderr = await process.communicate()
|
||||
|
||||
if process.returncode != 0:
|
||||
error_message = stderr.decode() if stderr else "Unknown error"
|
||||
raise VideoError(f"Failed to create temporary black video: {error_message}")
|
||||
|
||||
return temp_video
|
||||
|
||||
async def _add_subtitles_to_video(self, input_video, subtitles_file, output_video):
|
||||
"""
|
||||
Add subtitles to a video.
|
||||
|
||||
Args:
|
||||
input_video: The input video file
|
||||
subtitles_file: The subtitles file
|
||||
output_video: The output video file
|
||||
|
||||
Returns:
|
||||
The output video file
|
||||
"""
|
||||
# Add subtitles to video
|
||||
command = (
|
||||
f'{self.ffmpeg_base_command} -i "{input_video}" -vf '
|
||||
f'ass="{subtitles_file}" -c:v prores_ks -profile:v 3 -vendor ap10 '
|
||||
f'-bits_per_mb 8000 -pix_fmt yuv422p10le "{output_video}"'
|
||||
)
|
||||
|
||||
self.logger.debug(f"Adding subtitles to video: {command}")
|
||||
process = await asyncio.create_subprocess_shell(
|
||||
command,
|
||||
stdout=asyncio.subprocess.PIPE,
|
||||
stderr=asyncio.subprocess.PIPE
|
||||
)
|
||||
stdout, stderr = await process.communicate()
|
||||
|
||||
if process.returncode != 0:
|
||||
error_message = stderr.decode() if stderr else "Unknown error"
|
||||
raise VideoError(f"Failed to add subtitles to video: {error_message}")
|
||||
|
||||
return output_video
|
||||
@@ -0,0 +1,108 @@
|
||||
"""
|
||||
Utility functions for the karaoke_gen package.
|
||||
"""
|
||||
|
||||
# Import utility modules
|
||||
from karaoke_gen.utils import config
|
||||
from karaoke_gen.utils import date
|
||||
from karaoke_gen.utils import file
|
||||
from karaoke_gen.utils import logging
|
||||
from karaoke_gen.utils import path
|
||||
from karaoke_gen.utils import string
|
||||
from karaoke_gen.utils import validation
|
||||
|
||||
# Re-export functions from config module
|
||||
from karaoke_gen.utils.config import (
|
||||
load_config_file,
|
||||
save_config_file,
|
||||
get_config_value,
|
||||
set_config_value,
|
||||
merge_configs,
|
||||
validate_required_config_keys,
|
||||
get_nested_config_value,
|
||||
set_nested_config_value,
|
||||
)
|
||||
|
||||
# Re-export functions from date module
|
||||
from karaoke_gen.utils.date import (
|
||||
get_current_timestamp,
|
||||
get_current_date,
|
||||
get_current_time,
|
||||
format_date,
|
||||
parse_date,
|
||||
get_date_components,
|
||||
add_days,
|
||||
days_between,
|
||||
is_date_in_range,
|
||||
get_month_name,
|
||||
get_day_of_week,
|
||||
)
|
||||
|
||||
# Re-export functions from file module
|
||||
from karaoke_gen.utils.file import (
|
||||
sanitize_filename,
|
||||
ensure_directory_exists,
|
||||
backup_existing_files,
|
||||
file_exists,
|
||||
copy_file,
|
||||
move_file,
|
||||
delete_file,
|
||||
create_zip_file,
|
||||
execute_command,
|
||||
)
|
||||
|
||||
# Re-export functions from logging module
|
||||
from karaoke_gen.utils.logging import (
|
||||
setup_logger,
|
||||
get_log_level_from_string,
|
||||
configure_logger_from_config,
|
||||
log_section,
|
||||
log_subsection,
|
||||
log_dict,
|
||||
log_exception,
|
||||
)
|
||||
|
||||
# Re-export functions from path module
|
||||
from karaoke_gen.utils.path import (
|
||||
normalize_path,
|
||||
join_paths,
|
||||
get_absolute_path,
|
||||
get_relative_path,
|
||||
get_parent_directory,
|
||||
get_filename,
|
||||
get_filename_without_extension,
|
||||
get_file_extension,
|
||||
create_directory,
|
||||
delete_directory,
|
||||
list_files,
|
||||
list_directories,
|
||||
get_file_info,
|
||||
find_files_by_extension,
|
||||
copy_directory,
|
||||
move_directory,
|
||||
get_directory_size,
|
||||
)
|
||||
|
||||
# Re-export functions from string module
|
||||
from karaoke_gen.utils.string import (
|
||||
slugify,
|
||||
truncate_string,
|
||||
extract_artist_and_title,
|
||||
format_duration,
|
||||
format_filesize,
|
||||
strip_html_tags,
|
||||
normalize_whitespace,
|
||||
extract_urls,
|
||||
replace_placeholders,
|
||||
generate_random_string,
|
||||
)
|
||||
|
||||
# Re-export functions from validation module
|
||||
from karaoke_gen.utils.validation import (
|
||||
is_url,
|
||||
is_file,
|
||||
is_directory,
|
||||
prompt_user_confirmation_or_raise_exception,
|
||||
prompt_user_bool,
|
||||
validate_input_parameters_for_features,
|
||||
)
|
||||
@@ -0,0 +1,204 @@
|
||||
"""
|
||||
Configuration utility functions.
|
||||
"""
|
||||
|
||||
import os
|
||||
import json
|
||||
import logging
|
||||
from typing import Dict, Any, Optional, List, Union
|
||||
|
||||
|
||||
def load_config_file(config_file: str, logger: Optional[logging.Logger] = None) -> Dict[str, Any]:
|
||||
"""
|
||||
Load a configuration file.
|
||||
|
||||
Args:
|
||||
config_file: The configuration file to load
|
||||
logger: The logger to use
|
||||
|
||||
Returns:
|
||||
The loaded configuration
|
||||
|
||||
Raises:
|
||||
FileNotFoundError: If the configuration file does not exist
|
||||
json.JSONDecodeError: If the configuration file is not valid JSON
|
||||
"""
|
||||
if logger:
|
||||
logger.info(f"Loading configuration from {config_file}")
|
||||
|
||||
if not os.path.isfile(config_file):
|
||||
error_msg = f"Configuration file not found: {config_file}"
|
||||
if logger:
|
||||
logger.error(error_msg)
|
||||
raise FileNotFoundError(error_msg)
|
||||
|
||||
try:
|
||||
with open(config_file, "r") as f:
|
||||
config = json.load(f)
|
||||
|
||||
if logger:
|
||||
logger.info(f"Successfully loaded configuration from {config_file}")
|
||||
return config
|
||||
except json.JSONDecodeError as e:
|
||||
error_msg = f"Invalid JSON in configuration file {config_file}: {str(e)}"
|
||||
if logger:
|
||||
logger.error(error_msg)
|
||||
raise
|
||||
|
||||
|
||||
def save_config_file(config_file: str, config: Dict[str, Any], logger: Optional[logging.Logger] = None) -> bool:
|
||||
"""
|
||||
Save a configuration file.
|
||||
|
||||
Args:
|
||||
config_file: The configuration file to save
|
||||
config: The configuration to save
|
||||
logger: The logger to use
|
||||
|
||||
Returns:
|
||||
True if the configuration was saved successfully, False otherwise
|
||||
"""
|
||||
if logger:
|
||||
logger.info(f"Saving configuration to {config_file}")
|
||||
|
||||
try:
|
||||
# Create directory if it doesn't exist
|
||||
os.makedirs(os.path.dirname(config_file), exist_ok=True)
|
||||
|
||||
with open(config_file, "w") as f:
|
||||
json.dump(config, f, indent=4)
|
||||
|
||||
if logger:
|
||||
logger.info(f"Successfully saved configuration to {config_file}")
|
||||
return True
|
||||
except Exception as e:
|
||||
if logger:
|
||||
logger.error(f"Failed to save configuration to {config_file}: {str(e)}")
|
||||
return False
|
||||
|
||||
|
||||
def get_config_value(config: Dict[str, Any], key: str, default: Any = None) -> Any:
|
||||
"""
|
||||
Get a value from a configuration dictionary.
|
||||
|
||||
Args:
|
||||
config: The configuration dictionary
|
||||
key: The key to get
|
||||
default: The default value to return if the key is not found
|
||||
|
||||
Returns:
|
||||
The value for the key, or the default value if the key is not found
|
||||
"""
|
||||
return config.get(key, default)
|
||||
|
||||
|
||||
def set_config_value(config: Dict[str, Any], key: str, value: Any) -> Dict[str, Any]:
|
||||
"""
|
||||
Set a value in a configuration dictionary.
|
||||
|
||||
Args:
|
||||
config: The configuration dictionary
|
||||
key: The key to set
|
||||
value: The value to set
|
||||
|
||||
Returns:
|
||||
The updated configuration dictionary
|
||||
"""
|
||||
config[key] = value
|
||||
return config
|
||||
|
||||
|
||||
def merge_configs(base_config: Dict[str, Any], override_config: Dict[str, Any]) -> Dict[str, Any]:
|
||||
"""
|
||||
Merge two configuration dictionaries.
|
||||
|
||||
Args:
|
||||
base_config: The base configuration dictionary
|
||||
override_config: The override configuration dictionary
|
||||
|
||||
Returns:
|
||||
The merged configuration dictionary
|
||||
"""
|
||||
result = base_config.copy()
|
||||
|
||||
for key, value in override_config.items():
|
||||
if key in result and isinstance(result[key], dict) and isinstance(value, dict):
|
||||
result[key] = merge_configs(result[key], value)
|
||||
else:
|
||||
result[key] = value
|
||||
|
||||
return result
|
||||
|
||||
|
||||
def validate_required_config_keys(config: Dict[str, Any], required_keys: List[str], logger: Optional[logging.Logger] = None) -> bool:
|
||||
"""
|
||||
Validate that a configuration dictionary contains all required keys.
|
||||
|
||||
Args:
|
||||
config: The configuration dictionary
|
||||
required_keys: The required keys
|
||||
logger: The logger to use
|
||||
|
||||
Returns:
|
||||
True if all required keys are present, False otherwise
|
||||
"""
|
||||
missing_keys = [key for key in required_keys if key not in config]
|
||||
|
||||
if missing_keys:
|
||||
if logger:
|
||||
logger.error(f"Missing required configuration keys: {', '.join(missing_keys)}")
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
|
||||
def get_nested_config_value(config: Dict[str, Any], key_path: str, default: Any = None) -> Any:
|
||||
"""
|
||||
Get a nested value from a configuration dictionary using a dot-separated path.
|
||||
|
||||
Args:
|
||||
config: The configuration dictionary
|
||||
key_path: The dot-separated path to the key
|
||||
default: The default value to return if the key is not found
|
||||
|
||||
Returns:
|
||||
The value for the key, or the default value if the key is not found
|
||||
"""
|
||||
keys = key_path.split(".")
|
||||
current = config
|
||||
|
||||
for key in keys:
|
||||
if not isinstance(current, dict) or key not in current:
|
||||
return default
|
||||
current = current[key]
|
||||
|
||||
return current
|
||||
|
||||
|
||||
def set_nested_config_value(config: Dict[str, Any], key_path: str, value: Any) -> Dict[str, Any]:
|
||||
"""
|
||||
Set a nested value in a configuration dictionary using a dot-separated path.
|
||||
|
||||
Args:
|
||||
config: The configuration dictionary
|
||||
key_path: The dot-separated path to the key
|
||||
value: The value to set
|
||||
|
||||
Returns:
|
||||
The updated configuration dictionary
|
||||
"""
|
||||
keys = key_path.split(".")
|
||||
current = config
|
||||
|
||||
# Navigate to the parent of the final key
|
||||
for key in keys[:-1]:
|
||||
if key not in current:
|
||||
current[key] = {}
|
||||
elif not isinstance(current[key], dict):
|
||||
current[key] = {}
|
||||
current = current[key]
|
||||
|
||||
# Set the value at the final key
|
||||
current[keys[-1]] = value
|
||||
|
||||
return config
|
||||
@@ -0,0 +1,223 @@
|
||||
"""
|
||||
Date utility functions.
|
||||
"""
|
||||
|
||||
import datetime
|
||||
from typing import Optional, Union, Dict, Any
|
||||
|
||||
|
||||
def get_current_timestamp() -> str:
|
||||
"""
|
||||
Get the current timestamp in ISO 8601 format.
|
||||
|
||||
Returns:
|
||||
The current timestamp in ISO 8601 format
|
||||
"""
|
||||
return datetime.datetime.now().isoformat()
|
||||
|
||||
|
||||
def get_current_date() -> str:
|
||||
"""
|
||||
Get the current date in YYYY-MM-DD format.
|
||||
|
||||
Returns:
|
||||
The current date in YYYY-MM-DD format
|
||||
"""
|
||||
return datetime.date.today().isoformat()
|
||||
|
||||
|
||||
def get_current_time() -> str:
|
||||
"""
|
||||
Get the current time in HH:MM:SS format.
|
||||
|
||||
Returns:
|
||||
The current time in HH:MM:SS format
|
||||
"""
|
||||
return datetime.datetime.now().strftime("%H:%M:%S")
|
||||
|
||||
|
||||
def format_date(date: Union[datetime.date, datetime.datetime, str], format_string: str = "%Y-%m-%d") -> str:
|
||||
"""
|
||||
Format a date object or string as a string.
|
||||
|
||||
Args:
|
||||
date: The date to format
|
||||
format_string: The format string to use
|
||||
|
||||
Returns:
|
||||
The formatted date string
|
||||
|
||||
Raises:
|
||||
ValueError: If the date is not a valid date object or string
|
||||
"""
|
||||
if isinstance(date, str):
|
||||
try:
|
||||
date = datetime.datetime.fromisoformat(date)
|
||||
except ValueError:
|
||||
try:
|
||||
date = datetime.datetime.strptime(date, "%Y-%m-%d")
|
||||
except ValueError:
|
||||
raise ValueError(f"Invalid date string: {date}")
|
||||
|
||||
return date.strftime(format_string)
|
||||
|
||||
|
||||
def parse_date(date_string: str, format_string: Optional[str] = None) -> datetime.date:
|
||||
"""
|
||||
Parse a date string into a date object.
|
||||
|
||||
Args:
|
||||
date_string: The date string to parse
|
||||
format_string: The format string to use (optional)
|
||||
|
||||
Returns:
|
||||
The parsed date object
|
||||
|
||||
Raises:
|
||||
ValueError: If the date string is not valid
|
||||
"""
|
||||
if format_string:
|
||||
return datetime.datetime.strptime(date_string, format_string).date()
|
||||
|
||||
try:
|
||||
return datetime.date.fromisoformat(date_string)
|
||||
except ValueError:
|
||||
try:
|
||||
return datetime.datetime.fromisoformat(date_string).date()
|
||||
except ValueError:
|
||||
raise ValueError(f"Invalid date string: {date_string}")
|
||||
|
||||
|
||||
def get_date_components(date: Union[datetime.date, datetime.datetime, str]) -> Dict[str, int]:
|
||||
"""
|
||||
Get the components of a date.
|
||||
|
||||
Args:
|
||||
date: The date to get components from
|
||||
|
||||
Returns:
|
||||
A dictionary with "year", "month", and "day" keys
|
||||
|
||||
Raises:
|
||||
ValueError: If the date is not a valid date object or string
|
||||
"""
|
||||
if isinstance(date, str):
|
||||
date = parse_date(date)
|
||||
|
||||
return {
|
||||
"year": date.year,
|
||||
"month": date.month,
|
||||
"day": date.day,
|
||||
}
|
||||
|
||||
|
||||
def add_days(date: Union[datetime.date, datetime.datetime, str], days: int) -> datetime.date:
|
||||
"""
|
||||
Add days to a date.
|
||||
|
||||
Args:
|
||||
date: The date to add days to
|
||||
days: The number of days to add
|
||||
|
||||
Returns:
|
||||
The new date
|
||||
|
||||
Raises:
|
||||
ValueError: If the date is not a valid date object or string
|
||||
"""
|
||||
if isinstance(date, str):
|
||||
date = parse_date(date)
|
||||
|
||||
return date + datetime.timedelta(days=days)
|
||||
|
||||
|
||||
def days_between(start_date: Union[datetime.date, datetime.datetime, str],
|
||||
end_date: Union[datetime.date, datetime.datetime, str]) -> int:
|
||||
"""
|
||||
Calculate the number of days between two dates.
|
||||
|
||||
Args:
|
||||
start_date: The start date
|
||||
end_date: The end date
|
||||
|
||||
Returns:
|
||||
The number of days between the dates
|
||||
|
||||
Raises:
|
||||
ValueError: If either date is not a valid date object or string
|
||||
"""
|
||||
if isinstance(start_date, str):
|
||||
start_date = parse_date(start_date)
|
||||
|
||||
if isinstance(end_date, str):
|
||||
end_date = parse_date(end_date)
|
||||
|
||||
delta = end_date - start_date
|
||||
return delta.days
|
||||
|
||||
|
||||
def is_date_in_range(date: Union[datetime.date, datetime.datetime, str],
|
||||
start_date: Union[datetime.date, datetime.datetime, str],
|
||||
end_date: Union[datetime.date, datetime.datetime, str]) -> bool:
|
||||
"""
|
||||
Check if a date is within a range.
|
||||
|
||||
Args:
|
||||
date: The date to check
|
||||
start_date: The start date of the range
|
||||
end_date: The end date of the range
|
||||
|
||||
Returns:
|
||||
True if the date is within the range, False otherwise
|
||||
|
||||
Raises:
|
||||
ValueError: If any date is not a valid date object or string
|
||||
"""
|
||||
if isinstance(date, str):
|
||||
date = parse_date(date)
|
||||
|
||||
if isinstance(start_date, str):
|
||||
start_date = parse_date(start_date)
|
||||
|
||||
if isinstance(end_date, str):
|
||||
end_date = parse_date(end_date)
|
||||
|
||||
return start_date <= date <= end_date
|
||||
|
||||
|
||||
def get_month_name(month: int) -> str:
|
||||
"""
|
||||
Get the name of a month.
|
||||
|
||||
Args:
|
||||
month: The month number (1-12)
|
||||
|
||||
Returns:
|
||||
The month name
|
||||
|
||||
Raises:
|
||||
ValueError: If the month is not valid
|
||||
"""
|
||||
if not 1 <= month <= 12:
|
||||
raise ValueError(f"Invalid month: {month}")
|
||||
|
||||
return datetime.date(2000, month, 1).strftime("%B")
|
||||
|
||||
|
||||
def get_day_of_week(date: Union[datetime.date, datetime.datetime, str]) -> str:
|
||||
"""
|
||||
Get the day of the week for a date.
|
||||
|
||||
Args:
|
||||
date: The date to get the day of the week for
|
||||
|
||||
Returns:
|
||||
The day of the week
|
||||
|
||||
Raises:
|
||||
ValueError: If the date is not a valid date object or string
|
||||
"""
|
||||
if isinstance(date, str):
|
||||
date = parse_date(date)
|
||||
|
||||
return date.strftime("%A")
|
||||
@@ -0,0 +1,233 @@
|
||||
"""
|
||||
File utility functions.
|
||||
"""
|
||||
|
||||
import os
|
||||
import re
|
||||
import shutil
|
||||
import subprocess
|
||||
import logging
|
||||
import zipfile
|
||||
from typing import Optional, List, Dict, Any
|
||||
|
||||
|
||||
def sanitize_filename(filename: str) -> str:
|
||||
"""
|
||||
Sanitize a filename to be safe for all operating systems.
|
||||
|
||||
Args:
|
||||
filename: The filename to sanitize
|
||||
|
||||
Returns:
|
||||
The sanitized filename
|
||||
"""
|
||||
# Replace invalid characters with underscores
|
||||
sanitized = re.sub(r'[\\/*?:"<>|]', "_", filename)
|
||||
# Remove leading/trailing whitespace and dots
|
||||
sanitized = sanitized.strip(". ")
|
||||
# Ensure the filename is not empty
|
||||
if not sanitized:
|
||||
sanitized = "unnamed"
|
||||
return sanitized
|
||||
|
||||
|
||||
def ensure_directory_exists(directory: str) -> None:
|
||||
"""
|
||||
Ensure a directory exists, creating it if necessary.
|
||||
|
||||
Args:
|
||||
directory: The directory to ensure exists
|
||||
"""
|
||||
os.makedirs(directory, exist_ok=True)
|
||||
|
||||
|
||||
def backup_existing_files(file_path: str, max_backups: int = 5) -> None:
|
||||
"""
|
||||
Backup existing files to prevent overwriting.
|
||||
|
||||
Args:
|
||||
file_path: The file to backup
|
||||
max_backups: The maximum number of backups to keep
|
||||
"""
|
||||
if not os.path.exists(file_path):
|
||||
return
|
||||
|
||||
# Create backup directory
|
||||
backup_dir = os.path.join(os.path.dirname(file_path), "backups")
|
||||
ensure_directory_exists(backup_dir)
|
||||
|
||||
# Get base filename
|
||||
base_name = os.path.basename(file_path)
|
||||
|
||||
# Create backup filename with timestamp
|
||||
from datetime import datetime
|
||||
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
|
||||
backup_file = os.path.join(backup_dir, f"{base_name}.{timestamp}")
|
||||
|
||||
# Copy the file to the backup location
|
||||
shutil.copy2(file_path, backup_file)
|
||||
|
||||
# Remove old backups if there are too many
|
||||
backup_files = [
|
||||
os.path.join(backup_dir, f) for f in os.listdir(backup_dir)
|
||||
if f.startswith(base_name + ".")
|
||||
]
|
||||
backup_files.sort(key=os.path.getmtime)
|
||||
|
||||
if len(backup_files) > max_backups:
|
||||
for old_backup in backup_files[:-max_backups]:
|
||||
os.remove(old_backup)
|
||||
|
||||
|
||||
def file_exists(file_path: str) -> bool:
|
||||
"""
|
||||
Check if a file exists with proper error handling.
|
||||
|
||||
Args:
|
||||
file_path: The file to check
|
||||
|
||||
Returns:
|
||||
True if the file exists, False otherwise
|
||||
"""
|
||||
try:
|
||||
return os.path.isfile(file_path)
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
|
||||
def copy_file(source: str, destination: str, logger: Optional[logging.Logger] = None) -> bool:
|
||||
"""
|
||||
Copy a file with proper error handling.
|
||||
|
||||
Args:
|
||||
source: The source file
|
||||
destination: The destination file
|
||||
logger: The logger to use
|
||||
|
||||
Returns:
|
||||
True if the copy was successful, False otherwise
|
||||
"""
|
||||
try:
|
||||
shutil.copy2(source, destination)
|
||||
if logger:
|
||||
logger.info(f"Copied {source} to {destination}")
|
||||
return True
|
||||
except Exception as e:
|
||||
if logger:
|
||||
logger.error(f"Failed to copy {source} to {destination}: {str(e)}")
|
||||
return False
|
||||
|
||||
|
||||
def move_file(source: str, destination: str, logger: Optional[logging.Logger] = None) -> bool:
|
||||
"""
|
||||
Move a file with proper error handling.
|
||||
|
||||
Args:
|
||||
source: The source file
|
||||
destination: The destination file
|
||||
logger: The logger to use
|
||||
|
||||
Returns:
|
||||
True if the move was successful, False otherwise
|
||||
"""
|
||||
try:
|
||||
shutil.move(source, destination)
|
||||
if logger:
|
||||
logger.info(f"Moved {source} to {destination}")
|
||||
return True
|
||||
except Exception as e:
|
||||
if logger:
|
||||
logger.error(f"Failed to move {source} to {destination}: {str(e)}")
|
||||
return False
|
||||
|
||||
|
||||
def delete_file(file_path: str, logger: Optional[logging.Logger] = None) -> bool:
|
||||
"""
|
||||
Delete a file with proper error handling.
|
||||
|
||||
Args:
|
||||
file_path: The file to delete
|
||||
logger: The logger to use
|
||||
|
||||
Returns:
|
||||
True if the deletion was successful, False otherwise
|
||||
"""
|
||||
try:
|
||||
os.remove(file_path)
|
||||
if logger:
|
||||
logger.info(f"Deleted {file_path}")
|
||||
return True
|
||||
except Exception as e:
|
||||
if logger:
|
||||
logger.error(f"Failed to delete {file_path}: {str(e)}")
|
||||
return False
|
||||
|
||||
|
||||
def create_zip_file(zip_file: str, files: List[str], logger: Optional[logging.Logger] = None) -> bool:
|
||||
"""
|
||||
Create a zip file from a list of files.
|
||||
|
||||
Args:
|
||||
zip_file: The zip file to create
|
||||
files: The files to include in the zip file
|
||||
logger: The logger to use
|
||||
|
||||
Returns:
|
||||
True if the zip file was created successfully, False otherwise
|
||||
"""
|
||||
try:
|
||||
with zipfile.ZipFile(zip_file, "w") as zipf:
|
||||
for file in files:
|
||||
if os.path.isfile(file):
|
||||
zipf.write(file, os.path.basename(file))
|
||||
if logger:
|
||||
logger.info(f"Added {file} to {zip_file}")
|
||||
|
||||
if logger:
|
||||
logger.info(f"Created zip file: {zip_file}")
|
||||
return True
|
||||
except Exception as e:
|
||||
if logger:
|
||||
logger.error(f"Failed to create zip file {zip_file}: {str(e)}")
|
||||
return False
|
||||
|
||||
|
||||
def execute_command(command: str, description: str, logger: Optional[logging.Logger] = None, dry_run: bool = False) -> bool:
|
||||
"""
|
||||
Execute a shell command with proper error handling.
|
||||
|
||||
Args:
|
||||
command: The command to execute
|
||||
description: A description of the command
|
||||
logger: The logger to use
|
||||
dry_run: Whether to perform a dry run
|
||||
|
||||
Returns:
|
||||
True if the command was executed successfully, False otherwise
|
||||
"""
|
||||
if logger:
|
||||
logger.info(description)
|
||||
|
||||
if dry_run:
|
||||
if logger:
|
||||
logger.info(f"DRY RUN: Would run command: {command}")
|
||||
return True
|
||||
|
||||
if logger:
|
||||
logger.info(f"Running command: {command}")
|
||||
|
||||
try:
|
||||
result = subprocess.run(command, shell=True, check=True, capture_output=True, text=True)
|
||||
if logger and result.stdout:
|
||||
logger.debug(f"Command output: {result.stdout}")
|
||||
return True
|
||||
except subprocess.CalledProcessError as e:
|
||||
if logger:
|
||||
logger.error(f"Command failed with exit code {e.returncode}")
|
||||
logger.error(f"Command output (stdout): {e.stdout}")
|
||||
logger.error(f"Command output (stderr): {e.stderr}")
|
||||
return False
|
||||
except Exception as e:
|
||||
if logger:
|
||||
logger.error(f"Failed to execute command: {str(e)}")
|
||||
return False
|
||||
@@ -0,0 +1,220 @@
|
||||
"""
|
||||
Logging utility functions.
|
||||
"""
|
||||
|
||||
import os
|
||||
import logging
|
||||
from typing import Optional, Dict, Any
|
||||
|
||||
|
||||
def setup_logger(
|
||||
name: str,
|
||||
log_file: Optional[str] = None,
|
||||
level: int = logging.INFO,
|
||||
format_string: Optional[str] = None,
|
||||
file_level: Optional[int] = None,
|
||||
console_level: Optional[int] = None,
|
||||
) -> logging.Logger:
|
||||
"""
|
||||
Set up a logger with console and file handlers.
|
||||
|
||||
Args:
|
||||
name: The name of the logger
|
||||
log_file: The log file to write to (optional)
|
||||
level: The default logging level
|
||||
format_string: The format string to use for log messages
|
||||
file_level: The logging level for the file handler (defaults to level)
|
||||
console_level: The logging level for the console handler (defaults to level)
|
||||
|
||||
Returns:
|
||||
The configured logger
|
||||
"""
|
||||
if format_string is None:
|
||||
format_string = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
|
||||
|
||||
if file_level is None:
|
||||
file_level = level
|
||||
|
||||
if console_level is None:
|
||||
console_level = level
|
||||
|
||||
# Create logger
|
||||
logger = logging.getLogger(name)
|
||||
logger.setLevel(level)
|
||||
|
||||
# Remove existing handlers to avoid duplicates
|
||||
for handler in logger.handlers[:]:
|
||||
logger.removeHandler(handler)
|
||||
|
||||
# Create formatter
|
||||
formatter = logging.Formatter(format_string)
|
||||
|
||||
# Create console handler
|
||||
console_handler = logging.StreamHandler()
|
||||
console_handler.setLevel(console_level)
|
||||
console_handler.setFormatter(formatter)
|
||||
logger.addHandler(console_handler)
|
||||
|
||||
# Create file handler if log_file is provided
|
||||
if log_file:
|
||||
# Create directory if it doesn't exist
|
||||
os.makedirs(os.path.dirname(log_file), exist_ok=True)
|
||||
|
||||
file_handler = logging.FileHandler(log_file)
|
||||
file_handler.setLevel(file_level)
|
||||
file_handler.setFormatter(formatter)
|
||||
logger.addHandler(file_handler)
|
||||
|
||||
return logger
|
||||
|
||||
|
||||
def get_log_level_from_string(level_str: str) -> int:
|
||||
"""
|
||||
Convert a string log level to a logging level constant.
|
||||
|
||||
Args:
|
||||
level_str: The string log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
|
||||
|
||||
Returns:
|
||||
The corresponding logging level constant
|
||||
|
||||
Raises:
|
||||
ValueError: If the string log level is invalid
|
||||
"""
|
||||
level_map = {
|
||||
"DEBUG": logging.DEBUG,
|
||||
"INFO": logging.INFO,
|
||||
"WARNING": logging.WARNING,
|
||||
"ERROR": logging.ERROR,
|
||||
"CRITICAL": logging.CRITICAL,
|
||||
}
|
||||
|
||||
level_str = level_str.upper()
|
||||
if level_str not in level_map:
|
||||
valid_levels = ", ".join(level_map.keys())
|
||||
raise ValueError(f"Invalid log level: {level_str}. Valid levels are: {valid_levels}")
|
||||
|
||||
return level_map[level_str]
|
||||
|
||||
|
||||
def configure_logger_from_config(
|
||||
name: str,
|
||||
config: Dict[str, Any],
|
||||
default_level: int = logging.INFO,
|
||||
default_format: str = "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
|
||||
) -> logging.Logger:
|
||||
"""
|
||||
Configure a logger from a configuration dictionary.
|
||||
|
||||
Args:
|
||||
name: The name of the logger
|
||||
config: The configuration dictionary
|
||||
default_level: The default logging level
|
||||
default_format: The default format string
|
||||
|
||||
Returns:
|
||||
The configured logger
|
||||
"""
|
||||
log_config = config.get("logging", {})
|
||||
|
||||
# Get log level
|
||||
level_str = log_config.get("level", "INFO")
|
||||
try:
|
||||
level = get_log_level_from_string(level_str)
|
||||
except ValueError:
|
||||
level = default_level
|
||||
|
||||
# Get log format
|
||||
format_string = log_config.get("format", default_format)
|
||||
|
||||
# Get log file
|
||||
log_file = log_config.get("file")
|
||||
|
||||
# Get file and console levels
|
||||
file_level_str = log_config.get("file_level")
|
||||
console_level_str = log_config.get("console_level")
|
||||
|
||||
file_level = None
|
||||
if file_level_str:
|
||||
try:
|
||||
file_level = get_log_level_from_string(file_level_str)
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
console_level = None
|
||||
if console_level_str:
|
||||
try:
|
||||
console_level = get_log_level_from_string(console_level_str)
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
return setup_logger(
|
||||
name=name,
|
||||
log_file=log_file,
|
||||
level=level,
|
||||
format_string=format_string,
|
||||
file_level=file_level,
|
||||
console_level=console_level,
|
||||
)
|
||||
|
||||
|
||||
def log_section(logger: logging.Logger, section_name: str, level: int = logging.INFO) -> None:
|
||||
"""
|
||||
Log a section header.
|
||||
|
||||
Args:
|
||||
logger: The logger to use
|
||||
section_name: The name of the section
|
||||
level: The logging level
|
||||
"""
|
||||
separator = "=" * 80
|
||||
logger.log(level, separator)
|
||||
logger.log(level, f" {section_name} ".center(80, "="))
|
||||
logger.log(level, separator)
|
||||
|
||||
|
||||
def log_subsection(logger: logging.Logger, subsection_name: str, level: int = logging.INFO) -> None:
|
||||
"""
|
||||
Log a subsection header.
|
||||
|
||||
Args:
|
||||
logger: The logger to use
|
||||
subsection_name: The name of the subsection
|
||||
level: The logging level
|
||||
"""
|
||||
separator = "-" * 60
|
||||
logger.log(level, separator)
|
||||
logger.log(level, f" {subsection_name} ".center(60, "-"))
|
||||
logger.log(level, separator)
|
||||
|
||||
|
||||
def log_dict(logger: logging.Logger, data: Dict[str, Any], title: Optional[str] = None, level: int = logging.INFO) -> None:
|
||||
"""
|
||||
Log a dictionary.
|
||||
|
||||
Args:
|
||||
logger: The logger to use
|
||||
data: The dictionary to log
|
||||
title: The title to use (optional)
|
||||
level: The logging level
|
||||
"""
|
||||
import json
|
||||
|
||||
if title:
|
||||
logger.log(level, f"{title}:")
|
||||
|
||||
formatted_json = json.dumps(data, indent=2)
|
||||
for line in formatted_json.splitlines():
|
||||
logger.log(level, line)
|
||||
|
||||
|
||||
def log_exception(logger: logging.Logger, exception: Exception, message: str = "An error occurred") -> None:
|
||||
"""
|
||||
Log an exception.
|
||||
|
||||
Args:
|
||||
logger: The logger to use
|
||||
exception: The exception to log
|
||||
message: The message to log
|
||||
"""
|
||||
logger.error(f"{message}: {str(exception)}", exc_info=True)
|
||||
@@ -0,0 +1,311 @@
|
||||
"""
|
||||
Path utility functions.
|
||||
"""
|
||||
|
||||
import os
|
||||
import glob
|
||||
import shutil
|
||||
from typing import List, Optional, Dict, Any, Union
|
||||
import logging
|
||||
|
||||
|
||||
def normalize_path(path: str) -> str:
|
||||
"""
|
||||
Normalize a path to use the correct path separator for the current OS.
|
||||
|
||||
Args:
|
||||
path: The path to normalize
|
||||
|
||||
Returns:
|
||||
The normalized path
|
||||
"""
|
||||
return os.path.normpath(path)
|
||||
|
||||
|
||||
def join_paths(*paths: str) -> str:
|
||||
"""
|
||||
Join paths using the correct path separator for the current OS.
|
||||
|
||||
Args:
|
||||
*paths: The paths to join
|
||||
|
||||
Returns:
|
||||
The joined path
|
||||
"""
|
||||
return os.path.join(*paths)
|
||||
|
||||
|
||||
def get_absolute_path(path: str) -> str:
|
||||
"""
|
||||
Get the absolute path of a path.
|
||||
|
||||
Args:
|
||||
path: The path to get the absolute path of
|
||||
|
||||
Returns:
|
||||
The absolute path
|
||||
"""
|
||||
return os.path.abspath(path)
|
||||
|
||||
|
||||
def get_relative_path(path: str, start: Optional[str] = None) -> str:
|
||||
"""
|
||||
Get the relative path of a path.
|
||||
|
||||
Args:
|
||||
path: The path to get the relative path of
|
||||
start: The start path (defaults to the current working directory)
|
||||
|
||||
Returns:
|
||||
The relative path
|
||||
"""
|
||||
if start is None:
|
||||
start = os.getcwd()
|
||||
|
||||
return os.path.relpath(path, start)
|
||||
|
||||
|
||||
def get_parent_directory(path: str) -> str:
|
||||
"""
|
||||
Get the parent directory of a path.
|
||||
|
||||
Args:
|
||||
path: The path to get the parent directory of
|
||||
|
||||
Returns:
|
||||
The parent directory
|
||||
"""
|
||||
return os.path.dirname(path)
|
||||
|
||||
|
||||
def get_filename(path: str) -> str:
|
||||
"""
|
||||
Get the filename from a path.
|
||||
|
||||
Args:
|
||||
path: The path to get the filename from
|
||||
|
||||
Returns:
|
||||
The filename
|
||||
"""
|
||||
return os.path.basename(path)
|
||||
|
||||
|
||||
def get_filename_without_extension(path: str) -> str:
|
||||
"""
|
||||
Get the filename without extension from a path.
|
||||
|
||||
Args:
|
||||
path: The path to get the filename without extension from
|
||||
|
||||
Returns:
|
||||
The filename without extension
|
||||
"""
|
||||
return os.path.splitext(os.path.basename(path))[0]
|
||||
|
||||
|
||||
def get_file_extension(path: str) -> str:
|
||||
"""
|
||||
Get the file extension from a path.
|
||||
|
||||
Args:
|
||||
path: The path to get the file extension from
|
||||
|
||||
Returns:
|
||||
The file extension (including the dot)
|
||||
"""
|
||||
return os.path.splitext(path)[1]
|
||||
|
||||
|
||||
def create_directory(directory: str, logger: Optional[logging.Logger] = None) -> bool:
|
||||
"""
|
||||
Create a directory if it doesn't exist.
|
||||
|
||||
Args:
|
||||
directory: The directory to create
|
||||
logger: The logger to use
|
||||
|
||||
Returns:
|
||||
True if the directory was created or already exists, False otherwise
|
||||
"""
|
||||
try:
|
||||
os.makedirs(directory, exist_ok=True)
|
||||
if logger:
|
||||
logger.info(f"Created directory: {directory}")
|
||||
return True
|
||||
except Exception as e:
|
||||
if logger:
|
||||
logger.error(f"Failed to create directory {directory}: {str(e)}")
|
||||
return False
|
||||
|
||||
|
||||
def delete_directory(directory: str, logger: Optional[logging.Logger] = None) -> bool:
|
||||
"""
|
||||
Delete a directory if it exists.
|
||||
|
||||
Args:
|
||||
directory: The directory to delete
|
||||
logger: The logger to use
|
||||
|
||||
Returns:
|
||||
True if the directory was deleted or doesn't exist, False otherwise
|
||||
"""
|
||||
if not os.path.exists(directory):
|
||||
return True
|
||||
|
||||
try:
|
||||
shutil.rmtree(directory)
|
||||
if logger:
|
||||
logger.info(f"Deleted directory: {directory}")
|
||||
return True
|
||||
except Exception as e:
|
||||
if logger:
|
||||
logger.error(f"Failed to delete directory {directory}: {str(e)}")
|
||||
return False
|
||||
|
||||
|
||||
def list_files(directory: str, pattern: str = "*") -> List[str]:
|
||||
"""
|
||||
List files in a directory matching a pattern.
|
||||
|
||||
Args:
|
||||
directory: The directory to list files in
|
||||
pattern: The glob pattern to match files against
|
||||
|
||||
Returns:
|
||||
A list of file paths
|
||||
"""
|
||||
return glob.glob(os.path.join(directory, pattern))
|
||||
|
||||
|
||||
def list_directories(directory: str) -> List[str]:
|
||||
"""
|
||||
List subdirectories in a directory.
|
||||
|
||||
Args:
|
||||
directory: The directory to list subdirectories in
|
||||
|
||||
Returns:
|
||||
A list of directory paths
|
||||
"""
|
||||
return [
|
||||
os.path.join(directory, d) for d in os.listdir(directory)
|
||||
if os.path.isdir(os.path.join(directory, d))
|
||||
]
|
||||
|
||||
|
||||
def get_file_info(file_path: str) -> Dict[str, Any]:
|
||||
"""
|
||||
Get information about a file.
|
||||
|
||||
Args:
|
||||
file_path: The path to the file
|
||||
|
||||
Returns:
|
||||
A dictionary with file information
|
||||
"""
|
||||
if not os.path.isfile(file_path):
|
||||
return {}
|
||||
|
||||
stat = os.stat(file_path)
|
||||
|
||||
return {
|
||||
"path": file_path,
|
||||
"size": stat.st_size,
|
||||
"created": stat.st_ctime,
|
||||
"modified": stat.st_mtime,
|
||||
"accessed": stat.st_atime,
|
||||
"filename": os.path.basename(file_path),
|
||||
"extension": os.path.splitext(file_path)[1],
|
||||
"directory": os.path.dirname(file_path),
|
||||
}
|
||||
|
||||
|
||||
def find_files_by_extension(directory: str, extension: str, recursive: bool = True) -> List[str]:
|
||||
"""
|
||||
Find files with a specific extension in a directory.
|
||||
|
||||
Args:
|
||||
directory: The directory to search in
|
||||
extension: The file extension to search for (with or without the dot)
|
||||
recursive: Whether to search recursively
|
||||
|
||||
Returns:
|
||||
A list of file paths
|
||||
"""
|
||||
if not extension.startswith("."):
|
||||
extension = f".{extension}"
|
||||
|
||||
if recursive:
|
||||
pattern = os.path.join(directory, f"**/*{extension}")
|
||||
return glob.glob(pattern, recursive=True)
|
||||
else:
|
||||
pattern = os.path.join(directory, f"*{extension}")
|
||||
return glob.glob(pattern)
|
||||
|
||||
|
||||
def copy_directory(source: str, destination: str, logger: Optional[logging.Logger] = None) -> bool:
|
||||
"""
|
||||
Copy a directory.
|
||||
|
||||
Args:
|
||||
source: The source directory
|
||||
destination: The destination directory
|
||||
logger: The logger to use
|
||||
|
||||
Returns:
|
||||
True if the directory was copied successfully, False otherwise
|
||||
"""
|
||||
try:
|
||||
shutil.copytree(source, destination)
|
||||
if logger:
|
||||
logger.info(f"Copied directory from {source} to {destination}")
|
||||
return True
|
||||
except Exception as e:
|
||||
if logger:
|
||||
logger.error(f"Failed to copy directory from {source} to {destination}: {str(e)}")
|
||||
return False
|
||||
|
||||
|
||||
def move_directory(source: str, destination: str, logger: Optional[logging.Logger] = None) -> bool:
|
||||
"""
|
||||
Move a directory.
|
||||
|
||||
Args:
|
||||
source: The source directory
|
||||
destination: The destination directory
|
||||
logger: The logger to use
|
||||
|
||||
Returns:
|
||||
True if the directory was moved successfully, False otherwise
|
||||
"""
|
||||
try:
|
||||
shutil.move(source, destination)
|
||||
if logger:
|
||||
logger.info(f"Moved directory from {source} to {destination}")
|
||||
return True
|
||||
except Exception as e:
|
||||
if logger:
|
||||
logger.error(f"Failed to move directory from {source} to {destination}: {str(e)}")
|
||||
return False
|
||||
|
||||
|
||||
def get_directory_size(directory: str) -> int:
|
||||
"""
|
||||
Get the total size of a directory in bytes.
|
||||
|
||||
Args:
|
||||
directory: The directory to get the size of
|
||||
|
||||
Returns:
|
||||
The total size in bytes
|
||||
"""
|
||||
total_size = 0
|
||||
|
||||
for dirpath, dirnames, filenames in os.walk(directory):
|
||||
for filename in filenames:
|
||||
file_path = os.path.join(dirpath, filename)
|
||||
if os.path.isfile(file_path):
|
||||
total_size += os.path.getsize(file_path)
|
||||
|
||||
return total_size
|
||||
@@ -0,0 +1,187 @@
|
||||
"""
|
||||
String utility functions.
|
||||
"""
|
||||
|
||||
import re
|
||||
import unicodedata
|
||||
from typing import Optional, List, Dict, Any
|
||||
|
||||
|
||||
def slugify(value: str, allow_unicode: bool = False) -> str:
|
||||
"""
|
||||
Convert a string to a URL-friendly slug.
|
||||
|
||||
Args:
|
||||
value: The string to convert
|
||||
allow_unicode: Whether to allow Unicode characters
|
||||
|
||||
Returns:
|
||||
The slugified string
|
||||
"""
|
||||
if allow_unicode:
|
||||
value = unicodedata.normalize("NFKC", value)
|
||||
else:
|
||||
value = (
|
||||
unicodedata.normalize("NFKD", value)
|
||||
.encode("ascii", "ignore")
|
||||
.decode("ascii")
|
||||
)
|
||||
value = re.sub(r"[^\w\s-]", "", value.lower())
|
||||
value = re.sub(r"[-\s]+", "-", value).strip("-_")
|
||||
return value
|
||||
|
||||
|
||||
def truncate_string(value: str, max_length: int, suffix: str = "...") -> str:
|
||||
"""
|
||||
Truncate a string to a maximum length.
|
||||
|
||||
Args:
|
||||
value: The string to truncate
|
||||
max_length: The maximum length
|
||||
suffix: The suffix to append if truncated
|
||||
|
||||
Returns:
|
||||
The truncated string
|
||||
"""
|
||||
if len(value) <= max_length:
|
||||
return value
|
||||
|
||||
return value[:max_length - len(suffix)] + suffix
|
||||
|
||||
|
||||
def extract_artist_and_title(filename: str) -> Dict[str, str]:
|
||||
"""
|
||||
Extract artist and title from a filename.
|
||||
|
||||
Args:
|
||||
filename: The filename to extract from
|
||||
|
||||
Returns:
|
||||
A dictionary with "artist" and "title" keys
|
||||
"""
|
||||
# Remove file extension
|
||||
name_without_ext = re.sub(r"\.[^.]+$", "", filename)
|
||||
|
||||
# Try to split by " - " first
|
||||
parts = name_without_ext.split(" - ", 1)
|
||||
if len(parts) == 2:
|
||||
return {"artist": parts[0].strip(), "title": parts[1].strip()}
|
||||
|
||||
# Try to split by "-" if " - " didn't work
|
||||
parts = name_without_ext.split("-", 1)
|
||||
if len(parts) == 2:
|
||||
return {"artist": parts[0].strip(), "title": parts[1].strip()}
|
||||
|
||||
# If no separator found, use the whole name as the title
|
||||
return {"artist": "", "title": name_without_ext.strip()}
|
||||
|
||||
|
||||
def format_duration(seconds: int) -> str:
|
||||
"""
|
||||
Format a duration in seconds to a human-readable string.
|
||||
|
||||
Args:
|
||||
seconds: The duration in seconds
|
||||
|
||||
Returns:
|
||||
The formatted duration string (MM:SS)
|
||||
"""
|
||||
minutes, seconds = divmod(seconds, 60)
|
||||
return f"{minutes:02d}:{seconds:02d}"
|
||||
|
||||
|
||||
def format_filesize(size_bytes: int) -> str:
|
||||
"""
|
||||
Format a file size in bytes to a human-readable string.
|
||||
|
||||
Args:
|
||||
size_bytes: The file size in bytes
|
||||
|
||||
Returns:
|
||||
The formatted file size string
|
||||
"""
|
||||
if size_bytes < 1024:
|
||||
return f"{size_bytes} B"
|
||||
|
||||
size_kb = size_bytes / 1024
|
||||
if size_kb < 1024:
|
||||
return f"{size_kb:.1f} KB"
|
||||
|
||||
size_mb = size_kb / 1024
|
||||
if size_mb < 1024:
|
||||
return f"{size_mb:.1f} MB"
|
||||
|
||||
size_gb = size_mb / 1024
|
||||
return f"{size_gb:.1f} GB"
|
||||
|
||||
|
||||
def strip_html_tags(html: str) -> str:
|
||||
"""
|
||||
Strip HTML tags from a string.
|
||||
|
||||
Args:
|
||||
html: The HTML string
|
||||
|
||||
Returns:
|
||||
The string with HTML tags removed
|
||||
"""
|
||||
return re.sub(r"<[^>]+>", "", html)
|
||||
|
||||
|
||||
def normalize_whitespace(text: str) -> str:
|
||||
"""
|
||||
Normalize whitespace in a string.
|
||||
|
||||
Args:
|
||||
text: The string to normalize
|
||||
|
||||
Returns:
|
||||
The string with normalized whitespace
|
||||
"""
|
||||
# Replace multiple whitespace characters with a single space
|
||||
return re.sub(r"\s+", " ", text).strip()
|
||||
|
||||
|
||||
def extract_urls(text: str) -> List[str]:
|
||||
"""
|
||||
Extract URLs from a string.
|
||||
|
||||
Args:
|
||||
text: The string to extract URLs from
|
||||
|
||||
Returns:
|
||||
A list of URLs
|
||||
"""
|
||||
url_pattern = r"https?://[^\s]+"
|
||||
return re.findall(url_pattern, text)
|
||||
|
||||
|
||||
def replace_placeholders(template: str, data: Dict[str, Any]) -> str:
|
||||
"""
|
||||
Replace placeholders in a template string with values from a dictionary.
|
||||
|
||||
Args:
|
||||
template: The template string with {placeholder} syntax
|
||||
data: The dictionary with placeholder values
|
||||
|
||||
Returns:
|
||||
The template with placeholders replaced
|
||||
"""
|
||||
return template.format(**data)
|
||||
|
||||
|
||||
def generate_random_string(length: int = 8) -> str:
|
||||
"""
|
||||
Generate a random string of a specified length.
|
||||
|
||||
Args:
|
||||
length: The length of the random string
|
||||
|
||||
Returns:
|
||||
The random string
|
||||
"""
|
||||
import random
|
||||
import string
|
||||
|
||||
characters = string.ascii_letters + string.digits
|
||||
return "".join(random.choice(characters) for _ in range(length))
|
||||
@@ -0,0 +1,230 @@
|
||||
"""
|
||||
Validation utility functions.
|
||||
"""
|
||||
|
||||
import os
|
||||
import logging
|
||||
from typing import Optional, Dict, Any, List, Callable
|
||||
|
||||
|
||||
def is_url(string: str) -> bool:
|
||||
"""
|
||||
Check if a string is a URL.
|
||||
|
||||
Args:
|
||||
string: The string to check
|
||||
|
||||
Returns:
|
||||
True if the string is a URL, False otherwise
|
||||
"""
|
||||
return string.startswith("http://") or string.startswith("https://")
|
||||
|
||||
|
||||
def is_file(string: str) -> bool:
|
||||
"""
|
||||
Check if a string is a valid file.
|
||||
|
||||
Args:
|
||||
string: The string to check
|
||||
|
||||
Returns:
|
||||
True if the string is a valid file, False otherwise
|
||||
"""
|
||||
return os.path.isfile(string)
|
||||
|
||||
|
||||
def is_directory(string: str) -> bool:
|
||||
"""
|
||||
Check if a string is a valid directory.
|
||||
|
||||
Args:
|
||||
string: The string to check
|
||||
|
||||
Returns:
|
||||
True if the string is a valid directory, False otherwise
|
||||
"""
|
||||
return os.path.isdir(string)
|
||||
|
||||
|
||||
def prompt_user_confirmation_or_raise_exception(
|
||||
prompt_message: str,
|
||||
exit_message: str,
|
||||
allow_empty: bool = False,
|
||||
non_interactive: bool = False,
|
||||
logger: Optional[logging.Logger] = None
|
||||
) -> None:
|
||||
"""
|
||||
Prompt the user for confirmation or raise an exception.
|
||||
|
||||
Args:
|
||||
prompt_message: The message to display to the user
|
||||
exit_message: The message to display if the user does not confirm
|
||||
allow_empty: Whether to allow an empty response
|
||||
non_interactive: Whether to automatically confirm in non-interactive mode
|
||||
logger: The logger to use
|
||||
|
||||
Raises:
|
||||
Exception: If the user does not confirm
|
||||
"""
|
||||
if non_interactive:
|
||||
if logger:
|
||||
logger.info(f"Non-interactive mode, automatically confirming: {prompt_message}")
|
||||
return
|
||||
|
||||
if not prompt_user_bool(prompt_message, allow_empty=allow_empty):
|
||||
if logger:
|
||||
logger.error(exit_message)
|
||||
raise Exception(exit_message)
|
||||
|
||||
|
||||
def prompt_user_bool(prompt_message: str, allow_empty: bool = False) -> bool:
|
||||
"""
|
||||
Prompt the user for a boolean value.
|
||||
|
||||
Args:
|
||||
prompt_message: The message to display to the user
|
||||
allow_empty: Whether to allow an empty response
|
||||
|
||||
Returns:
|
||||
True if the user confirms, False otherwise
|
||||
"""
|
||||
options_string = "[y]/n" if allow_empty else "y/[n]"
|
||||
accept_responses = ["y", "yes"]
|
||||
if allow_empty:
|
||||
accept_responses.append("")
|
||||
|
||||
print()
|
||||
response = input(f"{prompt_message} {options_string} ").strip().lower()
|
||||
return response in accept_responses
|
||||
|
||||
|
||||
def validate_input_parameters_for_features(
|
||||
config: Dict[str, Any],
|
||||
logger: Optional[logging.Logger] = None,
|
||||
prompt_confirmation: Optional[Callable] = None
|
||||
) -> Dict[str, bool]:
|
||||
"""
|
||||
Validate input parameters for enabled features.
|
||||
|
||||
Args:
|
||||
config: The configuration dictionary
|
||||
logger: The logger to use
|
||||
prompt_confirmation: A function to prompt the user for confirmation
|
||||
|
||||
Returns:
|
||||
A dictionary of enabled features
|
||||
|
||||
Raises:
|
||||
Exception: If validation fails
|
||||
"""
|
||||
if logger:
|
||||
logger.info(f"Validating input parameters for enabled features...")
|
||||
|
||||
current_directory = os.getcwd()
|
||||
if logger:
|
||||
logger.info(f"Current directory to process: {current_directory}")
|
||||
|
||||
enabled_features = {
|
||||
"youtube_upload": False,
|
||||
"discord_notification": False,
|
||||
"folder_organisation": False,
|
||||
"public_share_copy": False,
|
||||
"public_share_rclone": False,
|
||||
"cdg_zip_creation": config.get("enable_cdg", False),
|
||||
"txt_zip_creation": config.get("enable_txt", False)
|
||||
}
|
||||
|
||||
# Enable youtube upload if client secrets file is provided and is valid JSON
|
||||
youtube_client_secrets_file = config.get("youtube_client_secrets_file")
|
||||
youtube_description_file = config.get("youtube_description_file")
|
||||
|
||||
if youtube_client_secrets_file is not None and youtube_description_file is not None:
|
||||
if not os.path.isfile(youtube_client_secrets_file):
|
||||
raise Exception(f"YouTube client secrets file does not exist: {youtube_client_secrets_file}")
|
||||
|
||||
if not os.path.isfile(youtube_description_file):
|
||||
raise Exception(f"YouTube description file does not exist: {youtube_description_file}")
|
||||
|
||||
# Test parsing the file as JSON to check it's valid
|
||||
try:
|
||||
import json
|
||||
with open(youtube_client_secrets_file, "r") as f:
|
||||
json.load(f)
|
||||
except json.JSONDecodeError as e:
|
||||
raise Exception(f"YouTube client secrets file is not valid JSON: {youtube_client_secrets_file}") from e
|
||||
|
||||
if logger:
|
||||
logger.debug(f"YouTube upload checks passed, enabling YouTube upload")
|
||||
enabled_features["youtube_upload"] = True
|
||||
|
||||
# Enable discord notifications if webhook URL is provided and is valid URL
|
||||
discord_webhook_url = config.get("discord_webhook_url")
|
||||
if discord_webhook_url is not None:
|
||||
if not discord_webhook_url.startswith("https://discord.com/api/webhooks/"):
|
||||
raise Exception(f"Discord webhook URL is not valid: {discord_webhook_url}")
|
||||
|
||||
if logger:
|
||||
logger.debug(f"Discord webhook URL checks passed, enabling Discord notifications")
|
||||
enabled_features["discord_notification"] = True
|
||||
|
||||
# Enable folder organisation if brand prefix and target directory are provided and target directory is valid
|
||||
brand_prefix = config.get("brand_prefix")
|
||||
organised_dir = config.get("organised_dir")
|
||||
|
||||
if brand_prefix is not None and organised_dir is not None:
|
||||
if not os.path.isdir(organised_dir):
|
||||
raise Exception(f"Target directory does not exist: {organised_dir}")
|
||||
|
||||
if logger:
|
||||
logger.debug(f"Brand prefix and target directory provided, enabling folder organisation")
|
||||
enabled_features["folder_organisation"] = True
|
||||
|
||||
# Enable public share copy if public share directory is provided and is valid directory with MP4 and CDG subdirectories
|
||||
public_share_dir = config.get("public_share_dir")
|
||||
if public_share_dir is not None:
|
||||
if not os.path.isdir(public_share_dir):
|
||||
raise Exception(f"Public share directory does not exist: {public_share_dir}")
|
||||
|
||||
mp4_dir = os.path.join(public_share_dir, "MP4")
|
||||
cdg_dir = os.path.join(public_share_dir, "CDG")
|
||||
|
||||
if not os.path.isdir(mp4_dir):
|
||||
os.makedirs(mp4_dir, exist_ok=True)
|
||||
if logger:
|
||||
logger.info(f"Created MP4 subdirectory: {mp4_dir}")
|
||||
|
||||
if not os.path.isdir(cdg_dir):
|
||||
os.makedirs(cdg_dir, exist_ok=True)
|
||||
if logger:
|
||||
logger.info(f"Created CDG subdirectory: {cdg_dir}")
|
||||
|
||||
if logger:
|
||||
logger.debug(f"Public share directory checks passed, enabling public share copy")
|
||||
enabled_features["public_share_copy"] = True
|
||||
|
||||
# Enable public share rclone if rclone destination is provided
|
||||
rclone_destination = config.get("rclone_destination")
|
||||
if rclone_destination is not None:
|
||||
if logger:
|
||||
logger.debug(f"Rclone destination provided, enabling rclone sync")
|
||||
enabled_features["public_share_rclone"] = True
|
||||
|
||||
# Tell user which features are enabled, prompt them to confirm before proceeding
|
||||
if logger:
|
||||
logger.info(f"Enabled features:")
|
||||
logger.info(f" CDG ZIP creation: {enabled_features['cdg_zip_creation']}")
|
||||
logger.info(f" TXT ZIP creation: {enabled_features['txt_zip_creation']}")
|
||||
logger.info(f" YouTube upload: {enabled_features['youtube_upload']}")
|
||||
logger.info(f" Discord notifications: {enabled_features['discord_notification']}")
|
||||
logger.info(f" Folder organisation: {enabled_features['folder_organisation']}")
|
||||
logger.info(f" Public share copy: {enabled_features['public_share_copy']}")
|
||||
logger.info(f" Public share rclone: {enabled_features['public_share_rclone']}")
|
||||
|
||||
if prompt_confirmation:
|
||||
prompt_confirmation(
|
||||
f"Confirm features enabled log messages above match your expectations for finalisation?",
|
||||
"Refusing to proceed without user confirmation they're happy with enabled features.",
|
||||
allow_empty=True,
|
||||
)
|
||||
|
||||
return enabled_features
|
||||
@@ -1 +0,0 @@
|
||||
from .karaoke_prep import KaraokePrep
|
||||
@@ -1,396 +0,0 @@
|
||||
import os
|
||||
import sys
|
||||
import json
|
||||
import logging
|
||||
import glob
|
||||
import shutil
|
||||
import tempfile
|
||||
import time
|
||||
import fcntl
|
||||
import errno
|
||||
import psutil
|
||||
from datetime import datetime
|
||||
from pydub import AudioSegment
|
||||
|
||||
|
||||
# Placeholder class or functions for audio processing
|
||||
class AudioProcessor:
|
||||
def __init__(
|
||||
self,
|
||||
logger,
|
||||
log_level,
|
||||
log_formatter,
|
||||
model_file_dir,
|
||||
lossless_output_format,
|
||||
clean_instrumental_model,
|
||||
backing_vocals_models,
|
||||
other_stems_models,
|
||||
ffmpeg_base_command,
|
||||
):
|
||||
self.logger = logger
|
||||
self.log_level = log_level
|
||||
self.log_formatter = log_formatter
|
||||
self.model_file_dir = model_file_dir
|
||||
self.lossless_output_format = lossless_output_format
|
||||
self.clean_instrumental_model = clean_instrumental_model
|
||||
self.backing_vocals_models = backing_vocals_models
|
||||
self.other_stems_models = other_stems_models
|
||||
self.ffmpeg_base_command = ffmpeg_base_command # Needed for combined instrumentals
|
||||
|
||||
def _file_exists(self, file_path):
|
||||
"""Check if a file exists and log the result."""
|
||||
exists = os.path.isfile(file_path)
|
||||
if exists:
|
||||
self.logger.info(f"File already exists, skipping creation: {file_path}")
|
||||
return exists
|
||||
|
||||
def separate_audio(self, audio_file, model_name, artist_title, track_output_dir, instrumental_path, vocals_path):
|
||||
if audio_file is None or not os.path.isfile(audio_file):
|
||||
raise Exception("Error: Invalid audio source provided.")
|
||||
|
||||
self.logger.debug(f"audio_file is valid file: {audio_file}")
|
||||
|
||||
self.logger.info(
|
||||
f"instantiating Separator with model_file_dir: {self.model_file_dir}, model_filename: {model_name} output_format: {self.lossless_output_format}"
|
||||
)
|
||||
|
||||
from audio_separator.separator import Separator
|
||||
|
||||
separator = Separator(
|
||||
log_level=self.log_level,
|
||||
log_formatter=self.log_formatter,
|
||||
model_file_dir=self.model_file_dir,
|
||||
output_format=self.lossless_output_format,
|
||||
)
|
||||
|
||||
separator.load_model(model_filename=model_name)
|
||||
output_files = separator.separate(audio_file)
|
||||
|
||||
self.logger.debug(f"Separator output files: {output_files}")
|
||||
|
||||
model_name_no_extension = os.path.splitext(model_name)[0]
|
||||
|
||||
for file in output_files:
|
||||
if "(Vocals)" in file:
|
||||
self.logger.info(f"Renaming Vocals file {file} to {vocals_path}")
|
||||
os.rename(file, vocals_path)
|
||||
elif "(Instrumental)" in file:
|
||||
self.logger.info(f"Renaming Instrumental file {file} to {instrumental_path}")
|
||||
os.rename(file, instrumental_path)
|
||||
elif model_name in file:
|
||||
# Example filename 1: "Freddie Jackson - All I'll Ever Ask (feat. Najee) (Local)_(Piano)_htdemucs_6s.flac"
|
||||
# Example filename 2: "Freddie Jackson - All I'll Ever Ask (feat. Najee) (Local)_(Guitar)_htdemucs_6s.flac"
|
||||
# The stem name in these examples would be "Piano" or "Guitar"
|
||||
# Extract stem_name from the filename
|
||||
stem_name = file.split(f"_{model_name}")[0].split("_")[-1]
|
||||
stem_name = stem_name.strip("()") # Remove parentheses if present
|
||||
|
||||
other_stem_path = os.path.join(track_output_dir, f"{artist_title} ({stem_name} {model_name}).{self.lossless_output_format}")
|
||||
self.logger.info(f"Renaming other stem file {file} to {other_stem_path}")
|
||||
os.rename(file, other_stem_path)
|
||||
|
||||
elif model_name_no_extension in file:
|
||||
# Example filename 1: "Freddie Jackson - All I'll Ever Ask (feat. Najee) (Local)_(Piano)_htdemucs_6s.flac"
|
||||
# Example filename 2: "Freddie Jackson - All I'll Ever Ask (feat. Najee) (Local)_(Guitar)_htdemucs_6s.flac"
|
||||
# The stem name in these examples would be "Piano" or "Guitar"
|
||||
# Extract stem_name from the filename
|
||||
stem_name = file.split(f"_{model_name_no_extension}")[0].split("_")[-1]
|
||||
stem_name = stem_name.strip("()") # Remove parentheses if present
|
||||
|
||||
other_stem_path = os.path.join(track_output_dir, f"{artist_title} ({stem_name} {model_name}).{self.lossless_output_format}")
|
||||
self.logger.info(f"Renaming other stem file {file} to {other_stem_path}")
|
||||
os.rename(file, other_stem_path)
|
||||
|
||||
self.logger.info(f"Separation complete! Output file(s): {vocals_path} {instrumental_path}")
|
||||
|
||||
def process_audio_separation(self, audio_file, artist_title, track_output_dir):
|
||||
from audio_separator.separator import Separator
|
||||
|
||||
self.logger.info(f"Starting audio separation process for {artist_title}")
|
||||
|
||||
# Define lock file path in system temp directory
|
||||
lock_file_path = os.path.join(tempfile.gettempdir(), "audio_separator.lock")
|
||||
|
||||
# Try to acquire lock
|
||||
while True:
|
||||
try:
|
||||
# First check if there's a stale lock
|
||||
if os.path.exists(lock_file_path):
|
||||
try:
|
||||
with open(lock_file_path, "r") as f:
|
||||
lock_data = json.load(f)
|
||||
pid = lock_data.get("pid")
|
||||
start_time = datetime.fromisoformat(lock_data.get("start_time"))
|
||||
running_track = lock_data.get("track")
|
||||
|
||||
# Check if process is still running
|
||||
if not psutil.pid_exists(pid):
|
||||
self.logger.warning(f"Found stale lock from dead process {pid}, removing...")
|
||||
os.remove(lock_file_path)
|
||||
else:
|
||||
# Calculate runtime
|
||||
runtime = datetime.now() - start_time
|
||||
runtime_mins = runtime.total_seconds() / 60
|
||||
|
||||
# Get process command line
|
||||
proc = psutil.Process(pid)
|
||||
cmd = " ".join(proc.cmdline())
|
||||
|
||||
self.logger.info(
|
||||
f"Waiting for other audio separation process to complete before starting separation for {artist_title}...\n"
|
||||
f"Currently running process details:\n"
|
||||
f" Track: {running_track}\n"
|
||||
f" PID: {pid}\n"
|
||||
f" Running time: {runtime_mins:.1f} minutes\n"
|
||||
f" Command: {cmd}\n"
|
||||
f"To force clear the lock and kill the process, run:\n"
|
||||
f" kill {pid} && rm {lock_file_path}"
|
||||
)
|
||||
except (json.JSONDecodeError, KeyError, ValueError) as e:
|
||||
self.logger.warning(f"Found invalid lock file, removing: {e}")
|
||||
os.remove(lock_file_path)
|
||||
|
||||
# Try to acquire lock
|
||||
lock_file = open(lock_file_path, "w")
|
||||
fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
|
||||
|
||||
# Write metadata to lock file
|
||||
lock_data = {
|
||||
"pid": os.getpid(),
|
||||
"start_time": datetime.now().isoformat(),
|
||||
"track": f"{artist_title}",
|
||||
}
|
||||
json.dump(lock_data, lock_file)
|
||||
lock_file.flush()
|
||||
break
|
||||
|
||||
except IOError as e:
|
||||
if e.errno != errno.EAGAIN:
|
||||
raise
|
||||
# Lock is held by another process
|
||||
time.sleep(30) # Wait 30 seconds before trying again
|
||||
continue
|
||||
|
||||
try:
|
||||
separator = Separator(
|
||||
log_level=self.log_level,
|
||||
log_formatter=self.log_formatter,
|
||||
model_file_dir=self.model_file_dir,
|
||||
output_format=self.lossless_output_format,
|
||||
)
|
||||
|
||||
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"):
|
||||
return result
|
||||
|
||||
result["clean_instrumental"] = self._separate_clean_instrumental(
|
||||
separator, audio_file, artist_title, track_output_dir, stems_dir
|
||||
)
|
||||
result["other_stems"] = self._separate_other_stems(separator, audio_file, artist_title, stems_dir)
|
||||
result["backing_vocals"] = self._separate_backing_vocals(
|
||||
separator, result["clean_instrumental"]["vocals"], artist_title, stems_dir
|
||||
)
|
||||
result["combined_instrumentals"] = self._generate_combined_instrumentals(
|
||||
result["clean_instrumental"]["instrumental"], result["backing_vocals"], artist_title, track_output_dir
|
||||
)
|
||||
self._normalize_audio_files(result, artist_title, track_output_dir)
|
||||
|
||||
# Create Audacity LOF file
|
||||
lof_path = os.path.join(stems_dir, f"{artist_title} (Audacity).lof")
|
||||
first_model = list(result["backing_vocals"].keys())[0]
|
||||
|
||||
files_to_include = [
|
||||
audio_file, # Original audio
|
||||
result["clean_instrumental"]["instrumental"], # Clean instrumental
|
||||
result["backing_vocals"][first_model]["backing_vocals"], # Backing vocals
|
||||
result["combined_instrumentals"][first_model], # Combined instrumental+BV
|
||||
]
|
||||
|
||||
# Convert to absolute paths
|
||||
files_to_include = [os.path.abspath(f) for f in files_to_include]
|
||||
|
||||
with open(lof_path, "w") as lof:
|
||||
for file_path in files_to_include:
|
||||
lof.write(f'file "{file_path}"\n')
|
||||
|
||||
self.logger.info(f"Created Audacity LOF file: {lof_path}")
|
||||
result["audacity_lof"] = lof_path
|
||||
|
||||
# Launch Audacity with multiple tracks
|
||||
if sys.platform == "darwin": # Check if we're on macOS
|
||||
if lof_path and os.path.exists(lof_path):
|
||||
self.logger.info(f"Launching Audacity with LOF file: {lof_path}")
|
||||
os.system(f'open -a Audacity "{lof_path}"')
|
||||
else:
|
||||
self.logger.debug("Audacity LOF file not available or not found")
|
||||
|
||||
self.logger.info("Audio separation, combination, and normalization process completed")
|
||||
return result
|
||||
finally:
|
||||
# Release lock
|
||||
fcntl.flock(lock_file.fileno(), fcntl.LOCK_UN)
|
||||
lock_file.close()
|
||||
try:
|
||||
os.remove(lock_file_path)
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
def _create_stems_directory(self, track_output_dir):
|
||||
stems_dir = os.path.join(track_output_dir, "stems")
|
||||
os.makedirs(stems_dir, exist_ok=True)
|
||||
self.logger.info(f"Created stems directory: {stems_dir}")
|
||||
return stems_dir
|
||||
|
||||
def _separate_clean_instrumental(self, separator, audio_file, artist_title, track_output_dir, stems_dir):
|
||||
self.logger.info(f"Separating using clean instrumental model: {self.clean_instrumental_model}")
|
||||
instrumental_path = os.path.join(
|
||||
track_output_dir, f"{artist_title} (Instrumental {self.clean_instrumental_model}).{self.lossless_output_format}"
|
||||
)
|
||||
vocals_path = os.path.join(stems_dir, f"{artist_title} (Vocals {self.clean_instrumental_model}).{self.lossless_output_format}")
|
||||
|
||||
result = {}
|
||||
if not self._file_exists(instrumental_path) or not self._file_exists(vocals_path):
|
||||
separator.load_model(model_filename=self.clean_instrumental_model)
|
||||
clean_output_files = separator.separate(audio_file)
|
||||
|
||||
for file in clean_output_files:
|
||||
if "(Vocals)" in file and not self._file_exists(vocals_path):
|
||||
os.rename(file, vocals_path)
|
||||
result["vocals"] = vocals_path
|
||||
elif "(Instrumental)" in file and not self._file_exists(instrumental_path):
|
||||
os.rename(file, instrumental_path)
|
||||
result["instrumental"] = instrumental_path
|
||||
else:
|
||||
result["vocals"] = vocals_path
|
||||
result["instrumental"] = instrumental_path
|
||||
|
||||
return result
|
||||
|
||||
def _separate_other_stems(self, separator, audio_file, artist_title, stems_dir):
|
||||
self.logger.info(f"Separating using other stems models: {self.other_stems_models}")
|
||||
result = {}
|
||||
for model in self.other_stems_models:
|
||||
self.logger.info(f"Processing with model: {model}")
|
||||
result[model] = {}
|
||||
|
||||
# Check if any stem files for this model already exist
|
||||
existing_stems = glob.glob(os.path.join(stems_dir, f"{artist_title} (*{model}).{self.lossless_output_format}"))
|
||||
|
||||
if existing_stems:
|
||||
self.logger.info(f"Found existing stem files for model {model}, skipping separation")
|
||||
for stem_file in existing_stems:
|
||||
stem_name = os.path.basename(stem_file).split("(")[1].split(")")[0].strip()
|
||||
result[model][stem_name] = stem_file
|
||||
else:
|
||||
separator.load_model(model_filename=model)
|
||||
other_stems_output = separator.separate(audio_file)
|
||||
|
||||
for file in other_stems_output:
|
||||
file_name = os.path.basename(file)
|
||||
stem_name = file_name[file_name.rfind("_(") + 2 : file_name.rfind(")_")]
|
||||
new_filename = f"{artist_title} ({stem_name} {model}).{self.lossless_output_format}"
|
||||
other_stem_path = os.path.join(stems_dir, new_filename)
|
||||
if not self._file_exists(other_stem_path):
|
||||
os.rename(file, other_stem_path)
|
||||
result[model][stem_name] = other_stem_path
|
||||
|
||||
return result
|
||||
|
||||
def _separate_backing_vocals(self, separator, vocals_path, artist_title, stems_dir):
|
||||
self.logger.info(f"Separating clean vocals using backing vocals models: {self.backing_vocals_models}")
|
||||
result = {}
|
||||
for model in self.backing_vocals_models:
|
||||
self.logger.info(f"Processing with model: {model}")
|
||||
result[model] = {}
|
||||
lead_vocals_path = os.path.join(stems_dir, f"{artist_title} (Lead Vocals {model}).{self.lossless_output_format}")
|
||||
backing_vocals_path = os.path.join(stems_dir, f"{artist_title} (Backing Vocals {model}).{self.lossless_output_format}")
|
||||
|
||||
if not self._file_exists(lead_vocals_path) or not self._file_exists(backing_vocals_path):
|
||||
separator.load_model(model_filename=model)
|
||||
backing_vocals_output = separator.separate(vocals_path)
|
||||
|
||||
for file in backing_vocals_output:
|
||||
if "(Vocals)" in file and not self._file_exists(lead_vocals_path):
|
||||
os.rename(file, lead_vocals_path)
|
||||
result[model]["lead_vocals"] = lead_vocals_path
|
||||
elif "(Instrumental)" in file and not self._file_exists(backing_vocals_path):
|
||||
os.rename(file, backing_vocals_path)
|
||||
result[model]["backing_vocals"] = backing_vocals_path
|
||||
else:
|
||||
result[model]["lead_vocals"] = lead_vocals_path
|
||||
result[model]["backing_vocals"] = backing_vocals_path
|
||||
return result
|
||||
|
||||
def _generate_combined_instrumentals(self, instrumental_path, backing_vocals_result, artist_title, track_output_dir):
|
||||
self.logger.info("Generating combined instrumental tracks with backing vocals")
|
||||
result = {}
|
||||
for model, paths in backing_vocals_result.items():
|
||||
backing_vocals_path = paths["backing_vocals"]
|
||||
combined_path = os.path.join(track_output_dir, f"{artist_title} (Instrumental +BV {model}).{self.lossless_output_format}")
|
||||
|
||||
if not self._file_exists(combined_path):
|
||||
ffmpeg_command = (
|
||||
f'{self.ffmpeg_base_command} -i "{instrumental_path}" -i "{backing_vocals_path}" '
|
||||
f'-filter_complex "[0:a][1:a]amix=inputs=2:duration=longest:weights=1 1" '
|
||||
f'-c:a {self.lossless_output_format.lower()} "{combined_path}"'
|
||||
)
|
||||
|
||||
self.logger.debug(f"Running command: {ffmpeg_command}")
|
||||
os.system(ffmpeg_command)
|
||||
|
||||
result[model] = combined_path
|
||||
return result
|
||||
|
||||
def _normalize_audio_files(self, separation_result, artist_title, track_output_dir):
|
||||
self.logger.info("Normalizing clean instrumental and combined instrumentals")
|
||||
|
||||
files_to_normalize = [
|
||||
("clean_instrumental", separation_result["clean_instrumental"]["instrumental"]),
|
||||
] + [("combined_instrumentals", path) for path in separation_result["combined_instrumentals"].values()]
|
||||
|
||||
for key, file_path in files_to_normalize:
|
||||
if self._file_exists(file_path):
|
||||
try:
|
||||
self._normalize_audio(file_path, file_path) # Normalize in-place
|
||||
|
||||
# Verify the normalized file
|
||||
if os.path.getsize(file_path) > 0:
|
||||
self.logger.info(f"Successfully normalized: {file_path}")
|
||||
else:
|
||||
raise Exception("Normalized file is empty")
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Error during normalization of {file_path}: {e}")
|
||||
self.logger.warning(f"Normalization failed for {file_path}. Original file remains unchanged.")
|
||||
else:
|
||||
self.logger.warning(f"File not found for normalization: {file_path}")
|
||||
|
||||
self.logger.info("Audio normalization process completed")
|
||||
|
||||
def _normalize_audio(self, input_path, output_path, target_level=0.0):
|
||||
self.logger.info(f"Normalizing audio file: {input_path}")
|
||||
|
||||
# Load audio file
|
||||
audio = AudioSegment.from_file(input_path, format=self.lossless_output_format.lower())
|
||||
|
||||
# Calculate the peak amplitude
|
||||
peak_amplitude = float(audio.max_dBFS)
|
||||
|
||||
# Calculate the necessary gain
|
||||
gain_db = target_level - peak_amplitude
|
||||
|
||||
# Apply gain
|
||||
normalized_audio = audio.apply_gain(gain_db)
|
||||
|
||||
# Ensure the audio is not completely silent
|
||||
if normalized_audio.rms == 0:
|
||||
self.logger.warning(f"Normalized audio is silent for {input_path}. Using original audio.")
|
||||
normalized_audio = audio
|
||||
|
||||
# Export normalized audio, overwriting the original file
|
||||
normalized_audio.export(output_path, format=self.lossless_output_format.lower())
|
||||
|
||||
self.logger.info(f"Normalized audio saved, replacing: {output_path}")
|
||||
self.logger.debug(f"Original peak: {peak_amplitude} dB, Applied gain: {gain_db} dB")
|
||||
@@ -1,134 +0,0 @@
|
||||
import os
|
||||
import sys
|
||||
import json
|
||||
import logging
|
||||
|
||||
# Default style parameters if no JSON file is provided or if it's invalid
|
||||
DEFAULT_STYLE_PARAMS = {
|
||||
"intro": {
|
||||
"video_duration": 5,
|
||||
"existing_image": None,
|
||||
"background_color": "#000000",
|
||||
"background_image": None,
|
||||
"font": "Montserrat-Bold.ttf",
|
||||
"artist_color": "#ffdf6b",
|
||||
"artist_gradient": None,
|
||||
"title_color": "#ffffff",
|
||||
"title_gradient": None,
|
||||
"title_region": "370, 200, 3100, 480",
|
||||
"artist_region": "370, 700, 3100, 480",
|
||||
"extra_text": None,
|
||||
"extra_text_color": "#ffffff",
|
||||
"extra_text_gradient": None,
|
||||
"extra_text_region": "370, 1200, 3100, 480",
|
||||
"title_text_transform": None, # none, uppercase, lowercase, propercase
|
||||
"artist_text_transform": None, # none, uppercase, lowercase, propercase
|
||||
},
|
||||
"end": {
|
||||
"video_duration": 5,
|
||||
"existing_image": None,
|
||||
"background_color": "#000000",
|
||||
"background_image": None,
|
||||
"font": "Montserrat-Bold.ttf",
|
||||
"artist_color": "#ffdf6b",
|
||||
"artist_gradient": None,
|
||||
"title_color": "#ffffff",
|
||||
"title_gradient": None,
|
||||
"title_region": None,
|
||||
"artist_region": None,
|
||||
"extra_text": "THANK YOU FOR SINGING!",
|
||||
"extra_text_color": "#ff7acc",
|
||||
"extra_text_gradient": None,
|
||||
"extra_text_region": None,
|
||||
"title_text_transform": None, # none, uppercase, lowercase, propercase
|
||||
"artist_text_transform": None, # none, uppercase, lowercase, propercase
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
def load_style_params(style_params_json, logger):
|
||||
"""Loads style parameters from a JSON file or uses defaults."""
|
||||
if style_params_json:
|
||||
try:
|
||||
with open(style_params_json, "r") as f:
|
||||
style_params = json.loads(f.read())
|
||||
logger.info(f"Loaded style parameters from {style_params_json}")
|
||||
# You might want to add validation here to ensure the structure matches expectations
|
||||
return style_params
|
||||
except FileNotFoundError:
|
||||
logger.error(f"Style parameters configuration file not found: {style_params_json}")
|
||||
sys.exit(1)
|
||||
except json.JSONDecodeError as e:
|
||||
logger.error(f"Invalid JSON in style parameters configuration file: {e}")
|
||||
sys.exit(1)
|
||||
except Exception as e:
|
||||
logger.error(f"Error loading style parameters file {style_params_json}: {e}")
|
||||
sys.exit(1)
|
||||
else:
|
||||
logger.info("No style parameters JSON file provided. Using default styles.")
|
||||
return DEFAULT_STYLE_PARAMS
|
||||
|
||||
def setup_title_format(style_params):
|
||||
"""Sets up the title format dictionary from style parameters."""
|
||||
intro_params = style_params.get("intro", DEFAULT_STYLE_PARAMS["intro"])
|
||||
return {
|
||||
"background_color": intro_params.get("background_color", DEFAULT_STYLE_PARAMS["intro"]["background_color"]),
|
||||
"background_image": intro_params.get("background_image"),
|
||||
"font": intro_params.get("font", DEFAULT_STYLE_PARAMS["intro"]["font"]),
|
||||
"artist_color": intro_params.get("artist_color", DEFAULT_STYLE_PARAMS["intro"]["artist_color"]),
|
||||
"artist_gradient": intro_params.get("artist_gradient"),
|
||||
"title_color": intro_params.get("title_color", DEFAULT_STYLE_PARAMS["intro"]["title_color"]),
|
||||
"title_gradient": intro_params.get("title_gradient"),
|
||||
"extra_text": intro_params.get("extra_text"),
|
||||
"extra_text_color": intro_params.get("extra_text_color", DEFAULT_STYLE_PARAMS["intro"]["extra_text_color"]),
|
||||
"extra_text_gradient": intro_params.get("extra_text_gradient"),
|
||||
"extra_text_region": intro_params.get("extra_text_region", DEFAULT_STYLE_PARAMS["intro"]["extra_text_region"]),
|
||||
"title_region": intro_params.get("title_region", DEFAULT_STYLE_PARAMS["intro"]["title_region"]),
|
||||
"artist_region": intro_params.get("artist_region", DEFAULT_STYLE_PARAMS["intro"]["artist_region"]),
|
||||
"title_text_transform": intro_params.get("title_text_transform"),
|
||||
"artist_text_transform": intro_params.get("artist_text_transform"),
|
||||
}
|
||||
|
||||
def setup_end_format(style_params):
|
||||
"""Sets up the end format dictionary from style parameters."""
|
||||
end_params = style_params.get("end", DEFAULT_STYLE_PARAMS["end"])
|
||||
return {
|
||||
"background_color": end_params.get("background_color", DEFAULT_STYLE_PARAMS["end"]["background_color"]),
|
||||
"background_image": end_params.get("background_image"),
|
||||
"font": end_params.get("font", DEFAULT_STYLE_PARAMS["end"]["font"]),
|
||||
"artist_color": end_params.get("artist_color", DEFAULT_STYLE_PARAMS["end"]["artist_color"]),
|
||||
"artist_gradient": end_params.get("artist_gradient"),
|
||||
"title_color": end_params.get("title_color", DEFAULT_STYLE_PARAMS["end"]["title_color"]),
|
||||
"title_gradient": end_params.get("title_gradient"),
|
||||
"extra_text": end_params.get("extra_text", DEFAULT_STYLE_PARAMS["end"]["extra_text"]),
|
||||
"extra_text_color": end_params.get("extra_text_color", DEFAULT_STYLE_PARAMS["end"]["extra_text_color"]),
|
||||
"extra_text_gradient": end_params.get("extra_text_gradient"),
|
||||
"extra_text_region": end_params.get("extra_text_region"),
|
||||
"title_region": end_params.get("title_region"),
|
||||
"artist_region": end_params.get("artist_region"),
|
||||
"title_text_transform": end_params.get("title_text_transform"),
|
||||
"artist_text_transform": end_params.get("artist_text_transform"),
|
||||
}
|
||||
|
||||
def get_video_durations(style_params):
|
||||
"""Gets intro and end video durations from style parameters."""
|
||||
intro_duration = style_params.get("intro", {}).get("video_duration", DEFAULT_STYLE_PARAMS["intro"]["video_duration"])
|
||||
end_duration = style_params.get("end", {}).get("video_duration", DEFAULT_STYLE_PARAMS["end"]["video_duration"])
|
||||
return intro_duration, end_duration
|
||||
|
||||
def get_existing_images(style_params):
|
||||
"""Gets existing title and end images from style parameters."""
|
||||
existing_title_image = style_params.get("intro", {}).get("existing_image")
|
||||
existing_end_image = style_params.get("end", {}).get("existing_image")
|
||||
return existing_title_image, existing_end_image
|
||||
|
||||
def setup_ffmpeg_command(log_level):
|
||||
"""Sets up the base ffmpeg command string based on log level."""
|
||||
# Path to the Windows PyInstaller frozen bundled ffmpeg.exe, or the system-installed FFmpeg binary on Mac/Linux
|
||||
ffmpeg_path = os.path.join(sys._MEIPASS, "ffmpeg.exe") if getattr(sys, "frozen", False) else "ffmpeg"
|
||||
ffmpeg_base_command = f"{ffmpeg_path} -hide_banner -nostats"
|
||||
if log_level == logging.DEBUG:
|
||||
ffmpeg_base_command += " -loglevel verbose"
|
||||
else:
|
||||
ffmpeg_base_command += " -loglevel fatal"
|
||||
return ffmpeg_base_command
|
||||
@@ -1,186 +0,0 @@
|
||||
import os
|
||||
import glob
|
||||
import logging
|
||||
import shutil
|
||||
import tempfile
|
||||
import yt_dlp.YoutubeDL as ydl
|
||||
from .utils import sanitize_filename
|
||||
|
||||
|
||||
# Placeholder class or functions for file handling
|
||||
class FileHandler:
|
||||
def __init__(self, logger, ffmpeg_base_command, create_track_subfolders, dry_run):
|
||||
self.logger = logger
|
||||
self.ffmpeg_base_command = ffmpeg_base_command
|
||||
self.create_track_subfolders = create_track_subfolders
|
||||
self.dry_run = dry_run
|
||||
|
||||
def _file_exists(self, file_path):
|
||||
"""Check if a file exists and log the result."""
|
||||
exists = os.path.isfile(file_path)
|
||||
if exists:
|
||||
self.logger.info(f"File already exists, skipping creation: {file_path}")
|
||||
return exists
|
||||
|
||||
# Placeholder methods - to be filled by user moving code
|
||||
def copy_input_media(self, input_media, output_filename_no_extension):
|
||||
self.logger.debug(f"Copying media from local path {input_media} to filename {output_filename_no_extension} + existing extension")
|
||||
|
||||
copied_file_name = output_filename_no_extension + os.path.splitext(input_media)[1]
|
||||
self.logger.debug(f"Target filename: {copied_file_name}")
|
||||
|
||||
# Check if source and destination are the same
|
||||
if os.path.abspath(input_media) == os.path.abspath(copied_file_name):
|
||||
self.logger.info("Source and destination are the same file, skipping copy")
|
||||
return input_media
|
||||
|
||||
self.logger.debug(f"Copying {input_media} to {copied_file_name}")
|
||||
shutil.copy2(input_media, copied_file_name)
|
||||
|
||||
return copied_file_name
|
||||
|
||||
def download_video(self, url, output_filename_no_extension):
|
||||
self.logger.debug(f"Downloading media from URL {url} to filename {output_filename_no_extension} + (as yet) unknown extension")
|
||||
|
||||
ydl_opts = {
|
||||
"quiet": True,
|
||||
"format": "bv*+ba/b", # if a combined video + audio format is better than the best video-only format use the combined format
|
||||
"outtmpl": f"{output_filename_no_extension}.%(ext)s",
|
||||
"user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.169 Safari/537.36",
|
||||
}
|
||||
|
||||
with ydl(ydl_opts) as ydl_instance:
|
||||
ydl_instance.download([url])
|
||||
|
||||
# Search for the file with any extension
|
||||
downloaded_files = glob.glob(f"{output_filename_no_extension}.*")
|
||||
if downloaded_files:
|
||||
downloaded_file_name = downloaded_files[0] # Assume the first match is the correct one
|
||||
self.logger.info(f"Download finished, returning downloaded filename: {downloaded_file_name}")
|
||||
return downloaded_file_name
|
||||
else:
|
||||
self.logger.error("No files found matching the download pattern.")
|
||||
return None
|
||||
|
||||
def extract_still_image_from_video(self, input_filename, output_filename_no_extension):
|
||||
output_filename = output_filename_no_extension + ".png"
|
||||
self.logger.info(f"Extracting still image from position 30s input media")
|
||||
ffmpeg_command = f'{self.ffmpeg_base_command} -i "{input_filename}" -ss 00:00:30 -vframes 1 "{output_filename}"'
|
||||
self.logger.debug(f"Running command: {ffmpeg_command}")
|
||||
os.system(ffmpeg_command)
|
||||
return output_filename
|
||||
|
||||
def convert_to_wav(self, input_filename, output_filename_no_extension):
|
||||
"""Convert input audio to WAV format, with input validation."""
|
||||
# Validate input file exists and is readable
|
||||
if not os.path.isfile(input_filename):
|
||||
raise Exception(f"Input audio file not found: {input_filename}")
|
||||
|
||||
if os.path.getsize(input_filename) == 0:
|
||||
raise Exception(f"Input audio file is empty: {input_filename}")
|
||||
|
||||
# Validate input file format using ffprobe
|
||||
probe_command = f'ffprobe -v error -show_entries stream=codec_type -of default=noprint_wrappers=1 "{input_filename}"'
|
||||
probe_output = os.popen(probe_command).read()
|
||||
|
||||
if "codec_type=audio" not in probe_output:
|
||||
raise Exception(f"No valid audio stream found in file: {input_filename}")
|
||||
|
||||
output_filename = output_filename_no_extension + ".wav"
|
||||
self.logger.info(f"Converting input media to audio WAV file")
|
||||
ffmpeg_command = f'{self.ffmpeg_base_command} -n -i "{input_filename}" "{output_filename}"'
|
||||
self.logger.debug(f"Running command: {ffmpeg_command}")
|
||||
if not self.dry_run:
|
||||
os.system(ffmpeg_command)
|
||||
return output_filename
|
||||
|
||||
def setup_output_paths(self, output_dir, artist, title):
|
||||
if title is None and artist is None:
|
||||
raise ValueError("Error: At least title or artist must be provided")
|
||||
|
||||
# If only title is provided, use it for both artist and title portions of paths
|
||||
if artist is None:
|
||||
sanitized_title = sanitize_filename(title)
|
||||
artist_title = sanitized_title
|
||||
else:
|
||||
sanitized_artist = sanitize_filename(artist)
|
||||
sanitized_title = sanitize_filename(title)
|
||||
artist_title = f"{sanitized_artist} - {sanitized_title}"
|
||||
|
||||
track_output_dir = output_dir
|
||||
if self.create_track_subfolders:
|
||||
track_output_dir = os.path.join(output_dir, f"{artist_title}")
|
||||
|
||||
if not os.path.exists(track_output_dir):
|
||||
self.logger.debug(f"Output dir {track_output_dir} did not exist, creating")
|
||||
os.makedirs(track_output_dir)
|
||||
|
||||
return track_output_dir, artist_title
|
||||
|
||||
def backup_existing_outputs(self, track_output_dir, artist, title):
|
||||
"""
|
||||
Backup existing outputs to a versioned folder.
|
||||
|
||||
Args:
|
||||
track_output_dir: The directory containing the track outputs
|
||||
artist: The artist name
|
||||
title: The track title
|
||||
|
||||
Returns:
|
||||
The path to the original input audio file
|
||||
"""
|
||||
self.logger.info(f"Backing up existing outputs for {artist} - {title}")
|
||||
|
||||
# Sanitize artist and title for filenames
|
||||
sanitized_artist = sanitize_filename(artist)
|
||||
sanitized_title = sanitize_filename(title)
|
||||
base_name = f"{sanitized_artist} - {sanitized_title}"
|
||||
|
||||
# Find the next available version number
|
||||
version_num = 1
|
||||
while os.path.exists(os.path.join(track_output_dir, f"version-{version_num}")):
|
||||
version_num += 1
|
||||
|
||||
version_dir = os.path.join(track_output_dir, f"version-{version_num}")
|
||||
self.logger.info(f"Creating backup directory: {version_dir}")
|
||||
os.makedirs(version_dir, exist_ok=True)
|
||||
|
||||
# Find the input audio file (we'll need this for re-running the transcription)
|
||||
input_audio_wav = os.path.join(track_output_dir, f"{base_name}.wav")
|
||||
if not os.path.exists(input_audio_wav):
|
||||
self.logger.warning(f"Input audio file not found: {input_audio_wav}")
|
||||
# Try to find any WAV file
|
||||
wav_files = glob.glob(os.path.join(track_output_dir, "*.wav"))
|
||||
if wav_files:
|
||||
input_audio_wav = wav_files[0]
|
||||
self.logger.info(f"Using alternative input audio file: {input_audio_wav}")
|
||||
else:
|
||||
raise Exception(f"No input audio file found in {track_output_dir}")
|
||||
|
||||
# List of file patterns to move
|
||||
file_patterns = [
|
||||
f"{base_name} (With Vocals).*",
|
||||
f"{base_name} (Karaoke).*",
|
||||
f"{base_name} (Final Karaoke*).*",
|
||||
]
|
||||
|
||||
# Move files matching patterns to version directory
|
||||
for pattern in file_patterns:
|
||||
for file_path in glob.glob(os.path.join(track_output_dir, pattern)):
|
||||
if os.path.isfile(file_path):
|
||||
dest_path = os.path.join(version_dir, os.path.basename(file_path))
|
||||
self.logger.info(f"Moving {file_path} to {dest_path}")
|
||||
if not self.dry_run:
|
||||
shutil.move(file_path, dest_path)
|
||||
|
||||
# Also backup the lyrics directory
|
||||
lyrics_dir = os.path.join(track_output_dir, "lyrics")
|
||||
if os.path.exists(lyrics_dir):
|
||||
lyrics_backup_dir = os.path.join(version_dir, "lyrics")
|
||||
self.logger.info(f"Backing up lyrics directory to {lyrics_backup_dir}")
|
||||
if not self.dry_run:
|
||||
shutil.copytree(lyrics_dir, lyrics_backup_dir)
|
||||
# Remove the original lyrics directory
|
||||
shutil.rmtree(lyrics_dir)
|
||||
|
||||
return input_audio_wav
|
||||
@@ -1 +0,0 @@
|
||||
from .karaoke_finalise import KaraokeFinalise
|
||||
@@ -1,687 +0,0 @@
|
||||
import os
|
||||
import sys
|
||||
import re
|
||||
import glob
|
||||
import logging
|
||||
import tempfile
|
||||
import shutil
|
||||
import asyncio
|
||||
import signal
|
||||
import time
|
||||
import fcntl
|
||||
import errno
|
||||
import psutil
|
||||
from datetime import datetime
|
||||
import importlib.resources as pkg_resources
|
||||
import json
|
||||
from dotenv import load_dotenv
|
||||
from .config import (
|
||||
load_style_params,
|
||||
setup_title_format,
|
||||
setup_end_format,
|
||||
get_video_durations,
|
||||
get_existing_images,
|
||||
setup_ffmpeg_command,
|
||||
)
|
||||
from .metadata import extract_info_for_online_media, parse_track_metadata
|
||||
from .file_handler import FileHandler
|
||||
from .audio_processor import AudioProcessor
|
||||
from .lyrics_processor import LyricsProcessor
|
||||
from .video_generator import VideoGenerator
|
||||
|
||||
|
||||
class KaraokePrep:
|
||||
def __init__(
|
||||
self,
|
||||
# Basic inputs
|
||||
input_media=None,
|
||||
artist=None,
|
||||
title=None,
|
||||
filename_pattern=None,
|
||||
# Logging & Debugging
|
||||
dry_run=False,
|
||||
logger=None,
|
||||
log_level=logging.DEBUG,
|
||||
log_formatter=None,
|
||||
render_bounding_boxes=False,
|
||||
# Input/Output Configuration
|
||||
output_dir=".",
|
||||
create_track_subfolders=False,
|
||||
lossless_output_format="FLAC",
|
||||
output_png=True,
|
||||
output_jpg=True,
|
||||
# Audio Processing Configuration
|
||||
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"],
|
||||
model_file_dir=os.path.join(tempfile.gettempdir(), "audio-separator-models"),
|
||||
existing_instrumental=None,
|
||||
# Lyrics Configuration
|
||||
lyrics_artist=None,
|
||||
lyrics_title=None,
|
||||
lyrics_file=None,
|
||||
skip_lyrics=False,
|
||||
skip_transcription=False,
|
||||
skip_transcription_review=False,
|
||||
render_video=True,
|
||||
subtitle_offset_ms=0,
|
||||
# Style Configuration
|
||||
style_params_json=None,
|
||||
# Add the new parameter
|
||||
skip_separation=False,
|
||||
):
|
||||
self.log_level = log_level
|
||||
self.log_formatter = log_formatter
|
||||
|
||||
if logger is None:
|
||||
self.logger = logging.getLogger(__name__)
|
||||
self.logger.setLevel(log_level)
|
||||
|
||||
self.log_handler = logging.StreamHandler()
|
||||
|
||||
if self.log_formatter is None:
|
||||
self.log_formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(module)s - %(message)s")
|
||||
|
||||
self.log_handler.setFormatter(self.log_formatter)
|
||||
self.logger.addHandler(self.log_handler)
|
||||
else:
|
||||
self.logger = logger
|
||||
|
||||
self.logger.debug(f"KaraokePrep instantiating with input_media: {input_media} artist: {artist} title: {title}")
|
||||
|
||||
self.dry_run = dry_run
|
||||
self.extractor = None # Will be set later based on source (Original or yt-dlp extractor)
|
||||
self.media_id = None # Will be set by parse_track_metadata if applicable
|
||||
self.url = None # Will be set by parse_track_metadata if applicable
|
||||
self.input_media = input_media
|
||||
self.artist = artist
|
||||
self.title = title
|
||||
self.filename_pattern = filename_pattern
|
||||
|
||||
# Input/Output - Keep these as they might be needed for logic outside handlers or passed to multiple handlers
|
||||
self.output_dir = output_dir
|
||||
self.lossless_output_format = lossless_output_format.lower()
|
||||
self.create_track_subfolders = create_track_subfolders
|
||||
self.output_png = output_png
|
||||
self.output_jpg = output_jpg
|
||||
|
||||
# Lyrics Config - Keep needed ones
|
||||
self.lyrics_artist = lyrics_artist
|
||||
self.lyrics_title = lyrics_title
|
||||
self.lyrics_file = lyrics_file # Passed to LyricsProcessor
|
||||
self.skip_lyrics = skip_lyrics # Used in prep_single_track logic
|
||||
self.skip_transcription = skip_transcription # Passed to LyricsProcessor
|
||||
self.skip_transcription_review = skip_transcription_review # Passed to LyricsProcessor
|
||||
self.render_video = render_video # Passed to LyricsProcessor
|
||||
self.subtitle_offset_ms = subtitle_offset_ms # Passed to LyricsProcessor
|
||||
|
||||
# Audio Config - Keep needed ones
|
||||
self.existing_instrumental = existing_instrumental # Used in prep_single_track logic
|
||||
self.skip_separation = skip_separation # Used in prep_single_track logic
|
||||
self.model_file_dir = model_file_dir # Passed to AudioProcessor
|
||||
|
||||
# Style Config - Keep needed ones
|
||||
self.render_bounding_boxes = render_bounding_boxes # Passed to VideoGenerator
|
||||
self.style_params_json = style_params_json # Passed to LyricsProcessor
|
||||
|
||||
# Load style parameters using the config module
|
||||
self.style_params = load_style_params(self.style_params_json, self.logger)
|
||||
|
||||
# Set up title and end formats using the config module
|
||||
self.title_format = setup_title_format(self.style_params)
|
||||
self.end_format = setup_end_format(self.style_params)
|
||||
|
||||
# Get video durations and existing images using the config module
|
||||
self.intro_video_duration, self.end_video_duration = get_video_durations(self.style_params)
|
||||
self.existing_title_image, self.existing_end_image = get_existing_images(self.style_params)
|
||||
|
||||
# Set up ffmpeg command using the config module
|
||||
self.ffmpeg_base_command = setup_ffmpeg_command(self.log_level)
|
||||
|
||||
# Instantiate Handlers
|
||||
self.file_handler = FileHandler(
|
||||
logger=self.logger,
|
||||
ffmpeg_base_command=self.ffmpeg_base_command,
|
||||
create_track_subfolders=self.create_track_subfolders,
|
||||
dry_run=self.dry_run,
|
||||
)
|
||||
|
||||
self.audio_processor = AudioProcessor(
|
||||
logger=self.logger,
|
||||
log_level=self.log_level,
|
||||
log_formatter=self.log_formatter,
|
||||
model_file_dir=self.model_file_dir,
|
||||
lossless_output_format=self.lossless_output_format,
|
||||
clean_instrumental_model=clean_instrumental_model, # Passed directly from args
|
||||
backing_vocals_models=backing_vocals_models, # Passed directly from args
|
||||
other_stems_models=other_stems_models, # Passed directly from args
|
||||
ffmpeg_base_command=self.ffmpeg_base_command,
|
||||
)
|
||||
|
||||
self.lyrics_processor = LyricsProcessor(
|
||||
logger=self.logger,
|
||||
style_params_json=self.style_params_json,
|
||||
lyrics_file=self.lyrics_file,
|
||||
skip_transcription=self.skip_transcription,
|
||||
skip_transcription_review=self.skip_transcription_review,
|
||||
render_video=self.render_video,
|
||||
subtitle_offset_ms=self.subtitle_offset_ms,
|
||||
)
|
||||
|
||||
self.video_generator = VideoGenerator(
|
||||
logger=self.logger,
|
||||
ffmpeg_base_command=self.ffmpeg_base_command,
|
||||
render_bounding_boxes=self.render_bounding_boxes,
|
||||
output_png=self.output_png,
|
||||
output_jpg=self.output_jpg,
|
||||
)
|
||||
|
||||
self.logger.debug(f"Initialized title_format with extra_text: {self.title_format['extra_text']}")
|
||||
self.logger.debug(f"Initialized title_format with extra_text_region: {self.title_format['extra_text_region']}")
|
||||
|
||||
self.logger.debug(f"Initialized end_format with extra_text: {self.end_format['extra_text']}")
|
||||
self.logger.debug(f"Initialized end_format with extra_text_region: {self.end_format['extra_text_region']}")
|
||||
|
||||
self.extracted_info = None # Will be populated by extract_info_for_online_media if needed
|
||||
self.persistent_artist = None # Used for playlists
|
||||
|
||||
self.logger.debug(f"KaraokePrep lossless_output_format: {self.lossless_output_format}")
|
||||
|
||||
# Use FileHandler method to check/create output dir
|
||||
if not os.path.exists(self.output_dir):
|
||||
self.logger.debug(f"Overall output dir {self.output_dir} did not exist, creating")
|
||||
os.makedirs(self.output_dir)
|
||||
else:
|
||||
self.logger.debug(f"Overall output dir {self.output_dir} already exists")
|
||||
|
||||
# Compatibility methods for tests - these call the new functions in metadata.py
|
||||
def extract_info_for_online_media(self, input_url=None, input_artist=None, input_title=None):
|
||||
"""Compatibility method that calls the function in metadata.py"""
|
||||
self.extracted_info = extract_info_for_online_media(input_url, input_artist, input_title, self.logger)
|
||||
return self.extracted_info
|
||||
|
||||
def parse_single_track_metadata(self, input_artist, input_title):
|
||||
"""Compatibility method that calls the function in metadata.py"""
|
||||
metadata_result = parse_track_metadata(self.extracted_info, input_artist, input_title, self.persistent_artist, self.logger)
|
||||
self.url = metadata_result["url"]
|
||||
self.extractor = metadata_result["extractor"]
|
||||
self.media_id = metadata_result["media_id"]
|
||||
self.artist = metadata_result["artist"]
|
||||
self.title = metadata_result["title"]
|
||||
|
||||
async def prep_single_track(self):
|
||||
# Add signal handler at the start
|
||||
loop = asyncio.get_running_loop()
|
||||
for sig in (signal.SIGINT, signal.SIGTERM):
|
||||
loop.add_signal_handler(sig, lambda s=sig: asyncio.create_task(self.shutdown(s)))
|
||||
|
||||
try:
|
||||
self.logger.info(f"Preparing single track: {self.artist} - {self.title}")
|
||||
|
||||
# Determine extractor early based on input type
|
||||
# Assume self.extractor, self.url, self.media_id etc. are set by process() before calling this
|
||||
if self.input_media and os.path.isfile(self.input_media):
|
||||
if not self.extractor: # If extractor wasn't somehow set before (e.g., direct call)
|
||||
self.extractor = "Original"
|
||||
elif self.url: # If it's a URL (set by process)
|
||||
if not self.extractor: # Should have been set by parse_track_metadata in process()
|
||||
self.logger.warning("Extractor not set before prep_single_track for URL, attempting fallback logic.")
|
||||
# Fallback logic (less ideal, relies on potentially missing info)
|
||||
if self.extracted_info and self.extracted_info.get('extractor'):
|
||||
self.extractor = self.extracted_info['extractor']
|
||||
elif self.media_id: # Try to guess based on ID format
|
||||
# Basic youtube id check
|
||||
if re.match(r'^[a-zA-Z0-9_-]{11}$', self.media_id):
|
||||
self.extractor = "youtube"
|
||||
else:
|
||||
self.extractor = "UnknownSource" # Fallback if ID doesn't look like youtube
|
||||
else:
|
||||
self.extractor = "UnknownSource" # Final fallback
|
||||
self.logger.info(f"Fallback extractor set to: {self.extractor}")
|
||||
elif self.input_media: # Not a file, not a URL -> maybe a direct URL string?
|
||||
self.logger.warning(f"Input media '{self.input_media}' is not a file and self.url was not set. Attempting to treat as URL.")
|
||||
# This path requires calling extract/parse again, less efficient
|
||||
try:
|
||||
extracted = extract_info_for_online_media(self.input_media, self.artist, self.title, self.logger)
|
||||
if extracted:
|
||||
metadata_result = parse_track_metadata(
|
||||
extracted, self.artist, self.title, self.persistent_artist, self.logger
|
||||
)
|
||||
self.url = metadata_result["url"]
|
||||
self.extractor = metadata_result["extractor"]
|
||||
self.media_id = metadata_result["media_id"]
|
||||
self.artist = metadata_result["artist"]
|
||||
self.title = metadata_result["title"]
|
||||
self.logger.info(f"Successfully extracted metadata within prep_single_track for {self.input_media}")
|
||||
else:
|
||||
self.logger.error(f"Could not extract info for {self.input_media} within prep_single_track.")
|
||||
self.extractor = "ErrorExtracting"
|
||||
return None # Cannot proceed without metadata
|
||||
except Exception as meta_exc:
|
||||
self.logger.error(f"Error during metadata extraction/parsing within prep_single_track: {meta_exc}")
|
||||
self.extractor = "ErrorParsing"
|
||||
return None # Cannot proceed
|
||||
else:
|
||||
# If it's neither file nor URL, and input_media is None, check for existing files
|
||||
# This path is mainly for the case where files exist from previous run
|
||||
# We still need artist/title for filename generation
|
||||
if not self.artist or not self.title:
|
||||
self.logger.error("Cannot determine output path without artist/title when input_media is None and not a URL.")
|
||||
return None
|
||||
self.logger.info("Input media is None, assuming check for existing files based on artist/title.")
|
||||
# We need a nominal extractor for filename matching if files exist
|
||||
# Let's default to 'UnknownExisting' or try to infer if possible later
|
||||
if not self.extractor:
|
||||
self.extractor = "UnknownExisting"
|
||||
|
||||
if not self.extractor:
|
||||
self.logger.error("Could not determine extractor for the track.")
|
||||
return None
|
||||
|
||||
# Now self.extractor should be set correctly for path generation etc.
|
||||
|
||||
self.logger.info(f"Preparing output path for track: {self.title} by {self.artist} (Extractor: {self.extractor})")
|
||||
if self.dry_run:
|
||||
return None
|
||||
|
||||
# Delegate to FileHandler
|
||||
track_output_dir, artist_title = self.file_handler.setup_output_paths(self.output_dir, self.artist, self.title)
|
||||
|
||||
processed_track = {
|
||||
"track_output_dir": track_output_dir,
|
||||
"artist": self.artist,
|
||||
"title": self.title,
|
||||
"extractor": self.extractor,
|
||||
"extracted_info": self.extracted_info,
|
||||
"lyrics": None,
|
||||
"processed_lyrics": None,
|
||||
"separated_audio": {},
|
||||
}
|
||||
|
||||
processed_track["input_media"] = None
|
||||
processed_track["input_still_image"] = None
|
||||
processed_track["input_audio_wav"] = None
|
||||
|
||||
if self.input_media and os.path.isfile(self.input_media):
|
||||
# --- Local File Input Handling ---
|
||||
input_wav_filename_pattern = os.path.join(track_output_dir, f"{artist_title} ({self.extractor}*).wav")
|
||||
input_wav_glob = glob.glob(input_wav_filename_pattern)
|
||||
|
||||
if input_wav_glob:
|
||||
processed_track["input_audio_wav"] = input_wav_glob[0]
|
||||
self.logger.info(f"Input media WAV file already exists, skipping conversion: {processed_track['input_audio_wav']}")
|
||||
else:
|
||||
output_filename_no_extension = os.path.join(track_output_dir, f"{artist_title} ({self.extractor})")
|
||||
|
||||
self.logger.info(f"Copying input media from {self.input_media} to new directory...")
|
||||
# Delegate to FileHandler
|
||||
processed_track["input_media"] = self.file_handler.copy_input_media(self.input_media, output_filename_no_extension)
|
||||
|
||||
self.logger.info("Converting input media to WAV for audio processing...")
|
||||
# Delegate to FileHandler
|
||||
processed_track["input_audio_wav"] = self.file_handler.convert_to_wav(processed_track["input_media"], output_filename_no_extension)
|
||||
|
||||
else:
|
||||
# --- URL or Existing Files Handling ---
|
||||
# Construct patterns using the determined extractor
|
||||
base_pattern = os.path.join(track_output_dir, f"{artist_title} ({self.extractor}*)")
|
||||
input_media_glob = glob.glob(f"{base_pattern}.*webm") + glob.glob(f"{base_pattern}.*mp4") # Add other common formats if needed
|
||||
input_png_glob = glob.glob(f"{base_pattern}.png")
|
||||
input_wav_glob = glob.glob(f"{base_pattern}.wav")
|
||||
|
||||
if input_media_glob and input_png_glob and input_wav_glob:
|
||||
# Existing files found
|
||||
processed_track["input_media"] = input_media_glob[0]
|
||||
processed_track["input_still_image"] = input_png_glob[0]
|
||||
processed_track["input_audio_wav"] = input_wav_glob[0]
|
||||
self.logger.info(f"Found existing media files matching extractor '{self.extractor}', skipping download/conversion.")
|
||||
# Ensure self.extractor reflects the found files if it was a fallback
|
||||
# Extract the actual extractor string from the filename if needed, though it should match
|
||||
|
||||
elif self.url: # URL provided and files not found, proceed with download
|
||||
# Use media_id if available for better uniqueness
|
||||
filename_suffix = f"{self.extractor} {self.media_id}" if self.media_id else self.extractor
|
||||
output_filename_no_extension = os.path.join(track_output_dir, f"{artist_title} ({filename_suffix})")
|
||||
|
||||
self.logger.info(f"Downloading input media from {self.url}...")
|
||||
# Delegate to FileHandler
|
||||
processed_track["input_media"] = self.file_handler.download_video(self.url, output_filename_no_extension)
|
||||
|
||||
self.logger.info("Extracting still image from downloaded media (if input is video)...")
|
||||
# Delegate to FileHandler
|
||||
processed_track["input_still_image"] = self.file_handler.extract_still_image_from_video(
|
||||
processed_track["input_media"], output_filename_no_extension
|
||||
)
|
||||
|
||||
self.logger.info("Converting downloaded video to WAV for audio processing...")
|
||||
# Delegate to FileHandler
|
||||
processed_track["input_audio_wav"] = self.file_handler.convert_to_wav(
|
||||
processed_track["input_media"], output_filename_no_extension
|
||||
)
|
||||
else:
|
||||
# This case means input_media was None, not a URL, and no existing files found
|
||||
self.logger.error(f"Cannot proceed: No input file, no URL, and no existing files found for {artist_title}.")
|
||||
return None
|
||||
|
||||
if self.skip_lyrics:
|
||||
self.logger.info("Skipping lyrics fetch as requested.")
|
||||
processed_track["lyrics"] = None
|
||||
processed_track["processed_lyrics"] = None
|
||||
else:
|
||||
lyrics_artist = self.lyrics_artist or self.artist
|
||||
lyrics_title = self.lyrics_title or self.title
|
||||
|
||||
# Create futures for both operations
|
||||
transcription_future = None
|
||||
separation_future = None
|
||||
|
||||
self.logger.info("=== Starting Parallel Processing ===")
|
||||
|
||||
if not self.skip_lyrics:
|
||||
self.logger.info("Creating transcription future...")
|
||||
# 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
|
||||
)
|
||||
)
|
||||
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)
|
||||
|
||||
# Only create real separation future if not skipping AND no existing instrumental provided
|
||||
if not self.skip_separation and not self.existing_instrumental:
|
||||
self.logger.info("Creating separation future (not skipping and no existing instrumental)...")
|
||||
# Run separation in a separate thread
|
||||
separation_future = asyncio.create_task(
|
||||
asyncio.to_thread(
|
||||
# Delegate to AudioProcessor
|
||||
self.audio_processor.process_audio_separation,
|
||||
audio_file=processed_track["input_audio_wav"],
|
||||
artist_title=artist_title,
|
||||
track_output_dir=track_output_dir,
|
||||
)
|
||||
)
|
||||
self.logger.info(f"Separation future created, type: {type(separation_future)}")
|
||||
elif self.existing_instrumental:
|
||||
self.logger.info(f"Skipping separation future creation because existing instrumental was provided: {self.existing_instrumental}")
|
||||
elif self.skip_separation: # Check this condition explicitly for clarity
|
||||
self.logger.info("Skipping separation future creation because skip_separation is True.")
|
||||
|
||||
self.logger.info("About to await both operations with asyncio.gather...")
|
||||
# Wait for both operations to complete
|
||||
try:
|
||||
results = await asyncio.gather(
|
||||
transcription_future if transcription_future else asyncio.sleep(0), # Use placeholder if None
|
||||
separation_future, # Already defaults to placeholder if not created
|
||||
return_exceptions=True,
|
||||
)
|
||||
except asyncio.CancelledError:
|
||||
self.logger.info("Received cancellation request, cleaning up...")
|
||||
# Cancel any running futures
|
||||
if transcription_future and not transcription_future.done():
|
||||
transcription_future.cancel()
|
||||
if separation_future and not separation_future.done() and not isinstance(separation_future, asyncio.Task): # Check if it's a real task
|
||||
# Don't try to cancel the asyncio.sleep(0) placeholder
|
||||
separation_future.cancel()
|
||||
|
||||
# Wait for futures to complete cancellation
|
||||
await asyncio.gather(
|
||||
transcription_future if transcription_future else asyncio.sleep(0),
|
||||
separation_future if separation_future else asyncio.sleep(0), # Use placeholder if None/Placeholder
|
||||
return_exceptions=True,
|
||||
)
|
||||
raise
|
||||
|
||||
# Handle transcription results
|
||||
if transcription_future:
|
||||
self.logger.info("Processing transcription results...")
|
||||
try:
|
||||
# Index 0 corresponds to transcription_future in gather
|
||||
transcriber_outputs = results[0]
|
||||
# Check if the result is an exception or the actual output
|
||||
if isinstance(transcriber_outputs, Exception):
|
||||
self.logger.error(f"Error during lyrics transcription: {transcriber_outputs}")
|
||||
# Optionally log traceback: self.logger.exception("Transcription error:")
|
||||
raise transcriber_outputs # Re-raise the exception
|
||||
elif transcriber_outputs is not None and not isinstance(transcriber_outputs, asyncio.futures.Future): # Ensure it's not the placeholder future
|
||||
self.logger.info(f"Successfully received transcription outputs: {type(transcriber_outputs)}")
|
||||
# Ensure transcriber_outputs is a dictionary before calling .get()
|
||||
if isinstance(transcriber_outputs, dict):
|
||||
self.lyrics = transcriber_outputs.get("corrected_lyrics_text")
|
||||
processed_track["lyrics"] = transcriber_outputs.get("corrected_lyrics_text_filepath")
|
||||
else:
|
||||
self.logger.warning(f"Unexpected type for transcriber_outputs: {type(transcriber_outputs)}, value: {transcriber_outputs}")
|
||||
else:
|
||||
self.logger.info("Transcription task did not return results (possibly skipped or placeholder).")
|
||||
except Exception as e:
|
||||
self.logger.error(f"Error processing transcription results: {e}")
|
||||
self.logger.exception("Full traceback:")
|
||||
raise # Re-raise the exception
|
||||
|
||||
# Handle separation results only if a real future was created and ran
|
||||
# Check if separation_future was the placeholder or a real task
|
||||
# The result index in `results` depends on whether transcription_future existed
|
||||
separation_result_index = 1 if transcription_future else 0
|
||||
if separation_future is not None and not isinstance(separation_future, asyncio.Task) and len(results) > separation_result_index:
|
||||
self.logger.info("Processing separation results...")
|
||||
try:
|
||||
separation_results = results[separation_result_index]
|
||||
# Check if the result is an exception or the actual output
|
||||
if isinstance(separation_results, Exception):
|
||||
self.logger.error(f"Error during audio separation: {separation_results}")
|
||||
# Optionally log traceback: self.logger.exception("Separation error:")
|
||||
# Decide if you want to raise here or just log
|
||||
elif separation_results is not None and not isinstance(separation_results, asyncio.futures.Future): # Ensure it's not the placeholder future
|
||||
self.logger.info(f"Successfully received separation results: {type(separation_results)}")
|
||||
if isinstance(separation_results, dict):
|
||||
processed_track["separated_audio"] = separation_results
|
||||
else:
|
||||
self.logger.warning(f"Unexpected type for separation_results: {type(separation_results)}, value: {separation_results}")
|
||||
else:
|
||||
self.logger.info("Separation task did not return results (possibly skipped or placeholder).")
|
||||
except Exception as e:
|
||||
self.logger.error(f"Error processing separation results: {e}")
|
||||
self.logger.exception("Full traceback:")
|
||||
# Decide if you want to raise here or just log
|
||||
elif not self.skip_separation and not self.existing_instrumental:
|
||||
# This case means separation was supposed to run but didn't return results properly
|
||||
self.logger.warning("Separation task was expected but did not yield results or resulted in an error captured earlier.")
|
||||
else:
|
||||
# This case means separation was intentionally skipped
|
||||
self.logger.info("Skipping processing of separation results as separation was not run.")
|
||||
|
||||
self.logger.info("=== Parallel Processing Complete ===")
|
||||
|
||||
output_image_filepath_noext = os.path.join(track_output_dir, f"{artist_title} (Title)")
|
||||
processed_track["title_image_png"] = f"{output_image_filepath_noext}.png"
|
||||
processed_track["title_image_jpg"] = f"{output_image_filepath_noext}.jpg"
|
||||
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"):
|
||||
self.logger.info(f"Creating title video...")
|
||||
# Delegate to VideoGenerator
|
||||
self.video_generator.create_title_video(
|
||||
artist=self.artist,
|
||||
title=self.title,
|
||||
format=self.title_format,
|
||||
output_image_filepath_noext=output_image_filepath_noext,
|
||||
output_video_filepath=processed_track["title_video"],
|
||||
existing_title_image=self.existing_title_image,
|
||||
intro_video_duration=self.intro_video_duration,
|
||||
)
|
||||
|
||||
output_image_filepath_noext = os.path.join(track_output_dir, f"{artist_title} (End)")
|
||||
processed_track["end_image_png"] = f"{output_image_filepath_noext}.png"
|
||||
processed_track["end_image_jpg"] = f"{output_image_filepath_noext}.jpg"
|
||||
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"):
|
||||
self.logger.info(f"Creating end screen video...")
|
||||
# Delegate to VideoGenerator
|
||||
self.video_generator.create_end_video(
|
||||
artist=self.artist,
|
||||
title=self.title,
|
||||
format=self.end_format,
|
||||
output_image_filepath_noext=output_image_filepath_noext,
|
||||
output_video_filepath=processed_track["end_video"],
|
||||
existing_end_image=self.existing_end_image,
|
||||
end_video_duration=self.end_video_duration,
|
||||
)
|
||||
|
||||
if self.skip_separation:
|
||||
self.logger.info("Skipping audio separation as requested.")
|
||||
processed_track["separated_audio"] = {
|
||||
"clean_instrumental": {},
|
||||
"backing_vocals": {},
|
||||
"other_stems": {},
|
||||
"combined_instrumentals": {},
|
||||
}
|
||||
elif self.existing_instrumental:
|
||||
self.logger.info(f"Using existing instrumental file: {self.existing_instrumental}")
|
||||
existing_instrumental_extension = os.path.splitext(self.existing_instrumental)[1]
|
||||
|
||||
instrumental_path = os.path.join(track_output_dir, f"{artist_title} (Instrumental Custom){existing_instrumental_extension}")
|
||||
|
||||
# Use FileHandler._file_exists
|
||||
if not self.file_handler._file_exists(instrumental_path):
|
||||
shutil.copy2(self.existing_instrumental, instrumental_path)
|
||||
|
||||
processed_track["separated_audio"]["Custom"] = {
|
||||
"instrumental": instrumental_path,
|
||||
"vocals": None,
|
||||
}
|
||||
else:
|
||||
# Only run separation if not skipped
|
||||
if not self.skip_separation:
|
||||
self.logger.info(f"Separating audio for track: {self.title} by {self.artist}")
|
||||
# Delegate to AudioProcessor (called directly, not in thread here)
|
||||
separation_results = self.audio_processor.process_audio_separation(
|
||||
audio_file=processed_track["input_audio_wav"], artist_title=artist_title, track_output_dir=track_output_dir
|
||||
)
|
||||
processed_track["separated_audio"] = separation_results
|
||||
# We don't need an else here, if skip_separation is true, separated_audio remains the default empty dict
|
||||
|
||||
self.logger.info("Script finished, audio downloaded, lyrics fetched and audio separated!")
|
||||
|
||||
return processed_track
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Error in prep_single_track: {e}")
|
||||
raise
|
||||
finally:
|
||||
# Remove signal handlers
|
||||
for sig in (signal.SIGINT, signal.SIGTERM):
|
||||
loop.remove_signal_handler(sig)
|
||||
|
||||
async def shutdown(self, signal):
|
||||
"""Handle shutdown signals gracefully."""
|
||||
self.logger.info(f"Received exit signal {signal.name}...")
|
||||
|
||||
# Get all running tasks
|
||||
tasks = [t for t in asyncio.all_tasks() if t is not asyncio.current_task()]
|
||||
|
||||
if tasks:
|
||||
self.logger.info(f"Cancelling {len(tasks)} outstanding tasks")
|
||||
# Cancel all running tasks
|
||||
for task in tasks:
|
||||
task.cancel()
|
||||
|
||||
self.logger.info("Received cancellation request, cleaning up...")
|
||||
|
||||
# Wait for all tasks to complete with cancellation
|
||||
try:
|
||||
await asyncio.gather(*tasks, return_exceptions=True)
|
||||
except asyncio.CancelledError:
|
||||
pass
|
||||
|
||||
# Force exit after cleanup
|
||||
self.logger.info("Cleanup complete, exiting...")
|
||||
sys.exit(0) # Add this line to force exit
|
||||
|
||||
async def process_playlist(self):
|
||||
if self.artist is None or self.title is None:
|
||||
raise Exception("Error: Artist and Title are required for processing a local file.")
|
||||
|
||||
if "entries" in self.extracted_info:
|
||||
track_results = []
|
||||
self.logger.info(f"Found {len(self.extracted_info['entries'])} entries in playlist, processing each invididually...")
|
||||
for entry in self.extracted_info["entries"]:
|
||||
self.extracted_info = entry
|
||||
self.logger.info(f"Processing playlist entry with title: {self.extracted_info['title']}")
|
||||
if not self.dry_run:
|
||||
track_results.append(await self.prep_single_track())
|
||||
self.artist = self.persistent_artist
|
||||
self.title = None
|
||||
return track_results
|
||||
else:
|
||||
raise Exception(f"Failed to find 'entries' in playlist, cannot process")
|
||||
|
||||
async def process_folder(self):
|
||||
if self.filename_pattern is None or self.artist is None:
|
||||
raise Exception("Error: Filename pattern and artist are required for processing a folder.")
|
||||
|
||||
folder_path = self.input_media
|
||||
output_folder_path = os.path.join(os.getcwd(), os.path.basename(folder_path))
|
||||
|
||||
if not os.path.exists(output_folder_path):
|
||||
if not self.dry_run:
|
||||
self.logger.info(f"DRY RUN: Would create output folder: {output_folder_path}")
|
||||
os.makedirs(output_folder_path)
|
||||
else:
|
||||
self.logger.info(f"Output folder already exists: {output_folder_path}")
|
||||
|
||||
pattern = re.compile(self.filename_pattern)
|
||||
tracks = []
|
||||
|
||||
for filename in sorted(os.listdir(folder_path)):
|
||||
match = pattern.match(filename)
|
||||
if match:
|
||||
title = match.group("title")
|
||||
file_path = os.path.join(folder_path, filename)
|
||||
self.input_media = file_path
|
||||
self.title = title
|
||||
|
||||
track_index = match.group("index") if "index" in match.groupdict() else None
|
||||
|
||||
self.logger.info(f"Processing track: {track_index} with title: {title} from file: {filename}")
|
||||
|
||||
track_output_dir = os.path.join(output_folder_path, f"{track_index} - {self.artist} - {title}")
|
||||
|
||||
if not self.dry_run:
|
||||
track = await self.prep_single_track()
|
||||
tracks.append(track)
|
||||
|
||||
# Move the track folder to the output folder
|
||||
track_folder = track["track_output_dir"]
|
||||
shutil.move(track_folder, track_output_dir)
|
||||
else:
|
||||
self.logger.info(f"DRY RUN: Would move track folder to: {os.path.basename(track_output_dir)}")
|
||||
|
||||
return tracks
|
||||
|
||||
async def process(self):
|
||||
if self.input_media is not None and os.path.isdir(self.input_media):
|
||||
self.logger.info(f"Input media {self.input_media} is a local folder, processing each file individually...")
|
||||
return await self.process_folder()
|
||||
elif self.input_media is not None and os.path.isfile(self.input_media):
|
||||
self.logger.info(f"Input media {self.input_media} is a local file, youtube logic will be skipped")
|
||||
return [await self.prep_single_track()]
|
||||
else:
|
||||
self.url = self.input_media
|
||||
# Use the imported extract_info_for_online_media function
|
||||
self.extracted_info = extract_info_for_online_media(
|
||||
input_url=self.url, input_artist=self.artist, input_title=self.title, logger=self.logger
|
||||
)
|
||||
|
||||
if self.extracted_info and "playlist_count" in self.extracted_info:
|
||||
self.persistent_artist = self.artist
|
||||
self.logger.info(f"Input URL is a playlist, beginning batch operation with persistent artist: {self.persistent_artist}")
|
||||
return await self.process_playlist()
|
||||
else:
|
||||
self.logger.info(f"Input URL is not a playlist, processing single track")
|
||||
return [await self.prep_single_track()]
|
||||
@@ -1,225 +0,0 @@
|
||||
import os
|
||||
import re
|
||||
import logging
|
||||
import shutil
|
||||
from lyrics_transcriber import LyricsTranscriber, OutputConfig, TranscriberConfig, LyricsConfig
|
||||
from lyrics_transcriber.core.controller import LyricsControllerResult
|
||||
from dotenv import load_dotenv
|
||||
from .utils import sanitize_filename
|
||||
|
||||
|
||||
# Placeholder class or functions for lyrics processing
|
||||
class LyricsProcessor:
|
||||
def __init__(
|
||||
self, logger, style_params_json, lyrics_file, skip_transcription, skip_transcription_review, render_video, subtitle_offset_ms
|
||||
):
|
||||
self.logger = logger
|
||||
self.style_params_json = style_params_json
|
||||
self.lyrics_file = lyrics_file
|
||||
self.skip_transcription = skip_transcription
|
||||
self.skip_transcription_review = skip_transcription_review
|
||||
self.render_video = render_video
|
||||
self.subtitle_offset_ms = subtitle_offset_ms
|
||||
|
||||
def find_best_split_point(self, line):
|
||||
"""
|
||||
Find the best split point in a line based on the specified criteria.
|
||||
"""
|
||||
|
||||
self.logger.debug(f"Finding best_split_point for line: {line}")
|
||||
words = line.split()
|
||||
mid_word_index = len(words) // 2
|
||||
self.logger.debug(f"words: {words} mid_word_index: {mid_word_index}")
|
||||
|
||||
# Check for a comma within one or two words of the middle word
|
||||
if "," in line:
|
||||
mid_point = len(" ".join(words[:mid_word_index]))
|
||||
comma_indices = [i for i, char in enumerate(line) if char == ","]
|
||||
|
||||
for index in comma_indices:
|
||||
if abs(mid_point - index) < 20 and len(line[: index + 1].strip()) <= 36:
|
||||
self.logger.debug(
|
||||
f"Found comma at index {index} which is within 20 characters of mid_point {mid_point} and results in a suitable line length, accepting as split point"
|
||||
)
|
||||
return index + 1 # Include the comma in the first line
|
||||
|
||||
# Check for 'and'
|
||||
if " and " in line:
|
||||
mid_point = len(line) // 2
|
||||
and_indices = [m.start() for m in re.finditer(" and ", line)]
|
||||
for index in sorted(and_indices, key=lambda x: abs(x - mid_point)):
|
||||
if len(line[: index + len(" and ")].strip()) <= 36:
|
||||
self.logger.debug(f"Found 'and' at index {index} which results in a suitable line length, accepting as split point")
|
||||
return index + len(" and ")
|
||||
|
||||
# If no better split point is found, try splitting at the middle word
|
||||
if len(words) > 2 and mid_word_index > 0:
|
||||
split_at_middle = len(" ".join(words[:mid_word_index]))
|
||||
if split_at_middle <= 36:
|
||||
self.logger.debug(f"Splitting at middle word index: {mid_word_index}")
|
||||
return split_at_middle
|
||||
|
||||
# If the line is still too long, forcibly split at the maximum length
|
||||
forced_split_point = 36
|
||||
if len(line) > forced_split_point:
|
||||
self.logger.debug(f"Line is still too long, forcibly splitting at position {forced_split_point}")
|
||||
return forced_split_point
|
||||
|
||||
def process_line(self, line):
|
||||
"""
|
||||
Process a single line to ensure it's within the maximum length,
|
||||
and handle parentheses.
|
||||
"""
|
||||
processed_lines = []
|
||||
iteration_count = 0
|
||||
max_iterations = 100 # Failsafe limit
|
||||
|
||||
while len(line) > 36:
|
||||
if iteration_count > max_iterations:
|
||||
self.logger.error(f"Maximum iterations exceeded in process_line for line: {line}")
|
||||
break
|
||||
|
||||
# Check if the line contains parentheses
|
||||
if "(" in line and ")" in line:
|
||||
start_paren = line.find("(")
|
||||
end_paren = line.find(")") + 1
|
||||
if end_paren < len(line) and line[end_paren] == ",":
|
||||
end_paren += 1
|
||||
|
||||
if start_paren > 0:
|
||||
processed_lines.append(line[:start_paren].strip())
|
||||
processed_lines.append(line[start_paren:end_paren].strip())
|
||||
line = line[end_paren:].strip()
|
||||
else:
|
||||
split_point = self.find_best_split_point(line)
|
||||
processed_lines.append(line[:split_point].strip())
|
||||
line = line[split_point:].strip()
|
||||
|
||||
iteration_count += 1
|
||||
|
||||
if line: # Add the remaining part if not empty
|
||||
processed_lines.append(line)
|
||||
|
||||
return processed_lines
|
||||
|
||||
def transcribe_lyrics(self, input_audio_wav, artist, title, track_output_dir):
|
||||
self.logger.info(
|
||||
f"Transcribing lyrics for track {artist} - {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)
|
||||
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")
|
||||
|
||||
# Check lyrics directory for existing files
|
||||
lyrics_dir = os.path.join(track_output_dir, "lyrics")
|
||||
lyrics_video_path = os.path.join(lyrics_dir, f"{sanitized_artist} - {sanitized_title} (With Vocals).mkv")
|
||||
lyrics_lrc_path = os.path.join(lyrics_dir, f"{sanitized_artist} - {sanitized_title} (Karaoke).lrc")
|
||||
|
||||
# If files exist in parent directory, return early
|
||||
if os.path.exists(parent_video_path) and os.path.exists(parent_lrc_path):
|
||||
self.logger.info(f"Found existing video and LRC files in parent directory, skipping transcription")
|
||||
return {
|
||||
"lrc_filepath": parent_lrc_path,
|
||||
"ass_filepath": parent_video_path,
|
||||
}
|
||||
|
||||
# If files exist in lyrics directory, copy to parent and return
|
||||
if os.path.exists(lyrics_video_path) and os.path.exists(lyrics_lrc_path):
|
||||
self.logger.info(f"Found existing video and LRC files in lyrics directory, copying to parent")
|
||||
os.makedirs(track_output_dir, exist_ok=True)
|
||||
shutil.copy2(lyrics_video_path, parent_video_path)
|
||||
shutil.copy2(lyrics_lrc_path, parent_lrc_path)
|
||||
return {
|
||||
"lrc_filepath": parent_lrc_path,
|
||||
"ass_filepath": parent_video_path,
|
||||
}
|
||||
|
||||
# Create lyrics subdirectory for new transcription
|
||||
os.makedirs(lyrics_dir, exist_ok=True)
|
||||
self.logger.info(f"Created lyrics directory: {lyrics_dir}")
|
||||
|
||||
# Load environment variables
|
||||
load_dotenv()
|
||||
env_config = {
|
||||
"audioshake_api_token": os.getenv("AUDIOSHAKE_API_TOKEN"),
|
||||
"genius_api_token": os.getenv("GENIUS_API_TOKEN"),
|
||||
"spotify_cookie": os.getenv("SPOTIFY_COOKIE_SP_DC"),
|
||||
"runpod_api_key": os.getenv("RUNPOD_API_KEY"),
|
||||
"whisper_runpod_id": os.getenv("WHISPER_RUNPOD_ID"),
|
||||
}
|
||||
|
||||
# Create config objects for LyricsTranscriber
|
||||
transcriber_config = TranscriberConfig(
|
||||
audioshake_api_token=env_config.get("audioshake_api_token"),
|
||||
)
|
||||
|
||||
lyrics_config = LyricsConfig(
|
||||
genius_api_token=env_config.get("genius_api_token"),
|
||||
spotify_cookie=env_config.get("spotify_cookie"),
|
||||
lyrics_file=self.lyrics_file,
|
||||
)
|
||||
|
||||
output_config = OutputConfig(
|
||||
output_styles_json=self.style_params_json,
|
||||
output_dir=lyrics_dir,
|
||||
render_video=self.render_video,
|
||||
fetch_lyrics=True,
|
||||
run_transcription=not self.skip_transcription,
|
||||
run_correction=True,
|
||||
generate_plain_text=True,
|
||||
generate_lrc=True,
|
||||
generate_cdg=True,
|
||||
video_resolution="4k",
|
||||
enable_review=not self.skip_transcription_review,
|
||||
subtitle_offset_ms=self.subtitle_offset_ms,
|
||||
)
|
||||
|
||||
# Add this log entry to debug the OutputConfig
|
||||
self.logger.info(f"Instantiating LyricsTranscriber with OutputConfig: {output_config}")
|
||||
|
||||
# Initialize transcriber with new config objects
|
||||
transcriber = LyricsTranscriber(
|
||||
audio_filepath=input_audio_wav,
|
||||
artist=artist,
|
||||
title=title,
|
||||
transcriber_config=transcriber_config,
|
||||
lyrics_config=lyrics_config,
|
||||
output_config=output_config,
|
||||
logger=self.logger,
|
||||
)
|
||||
|
||||
# Process and get results
|
||||
results: LyricsControllerResult = transcriber.process()
|
||||
self.logger.info(f"Transcriber Results Filepaths:")
|
||||
for key, value in results.__dict__.items():
|
||||
if key.endswith("_filepath"):
|
||||
self.logger.info(f" {key}: {value}")
|
||||
|
||||
# Build output dictionary
|
||||
transcriber_outputs = {}
|
||||
if results.lrc_filepath:
|
||||
transcriber_outputs["lrc_filepath"] = results.lrc_filepath
|
||||
self.logger.info(f"Moving LRC file from {results.lrc_filepath} to {parent_lrc_path}")
|
||||
shutil.copy2(results.lrc_filepath, parent_lrc_path)
|
||||
|
||||
if results.ass_filepath:
|
||||
transcriber_outputs["ass_filepath"] = results.ass_filepath
|
||||
self.logger.info(f"Moving video file from {results.video_filepath} to {parent_video_path}")
|
||||
shutil.copy2(results.video_filepath, parent_video_path)
|
||||
|
||||
if results.transcription_corrected:
|
||||
transcriber_outputs["corrected_lyrics_text"] = "\n".join(
|
||||
segment.text for segment in results.transcription_corrected.corrected_segments
|
||||
)
|
||||
transcriber_outputs["corrected_lyrics_text_filepath"] = results.corrected_txt
|
||||
|
||||
if transcriber_outputs:
|
||||
self.logger.info(f"*** Transcriber Filepath Outputs: ***")
|
||||
for key, value in transcriber_outputs.items():
|
||||
if key.endswith("_filepath"):
|
||||
self.logger.info(f" {key}: {value}")
|
||||
|
||||
return transcriber_outputs
|
||||
@@ -1,105 +0,0 @@
|
||||
import logging
|
||||
import yt_dlp.YoutubeDL as ydl
|
||||
|
||||
def extract_info_for_online_media(input_url, input_artist, input_title, logger):
|
||||
"""Extracts metadata using yt-dlp, either from a URL or via search."""
|
||||
logger.info(f"Extracting info for input_url: {input_url} input_artist: {input_artist} input_title: {input_title}")
|
||||
extracted_info = None
|
||||
if input_url is not None:
|
||||
# If a URL is provided, use it to extract the metadata
|
||||
with ydl({"quiet": True}) as ydl_instance:
|
||||
extracted_info = ydl_instance.extract_info(input_url, download=False)
|
||||
else:
|
||||
# If no URL is provided, use the query to search for the top result
|
||||
ydl_opts = {"quiet": "True", "format": "bestaudio", "noplaylist": "True", "extract_flat": True}
|
||||
with ydl(ydl_opts) as ydl_instance:
|
||||
query = f"{input_artist} {input_title}"
|
||||
search_results = ydl_instance.extract_info(f"ytsearch1:{query}", download=False)
|
||||
if search_results and "entries" in search_results and search_results["entries"]:
|
||||
extracted_info = search_results["entries"][0]
|
||||
else:
|
||||
# Raise IndexError to match the expected exception in tests
|
||||
raise IndexError(f"No search results found on YouTube for query: {input_artist} {input_title}")
|
||||
|
||||
if not extracted_info:
|
||||
raise Exception(f"Failed to extract info for query: {input_artist} {input_title} or URL: {input_url}")
|
||||
|
||||
return extracted_info
|
||||
|
||||
|
||||
def parse_track_metadata(extracted_info, current_artist, current_title, persistent_artist, logger):
|
||||
"""
|
||||
Parses extracted_info to determine URL, extractor, ID, artist, and title.
|
||||
Returns a dictionary with the parsed values.
|
||||
"""
|
||||
parsed_data = {
|
||||
"url": None,
|
||||
"extractor": None,
|
||||
"media_id": None,
|
||||
"artist": current_artist,
|
||||
"title": current_title,
|
||||
}
|
||||
|
||||
metadata_artist = ""
|
||||
metadata_title = ""
|
||||
|
||||
if "url" in extracted_info:
|
||||
parsed_data["url"] = extracted_info["url"]
|
||||
elif "webpage_url" in extracted_info:
|
||||
parsed_data["url"] = extracted_info["webpage_url"]
|
||||
else:
|
||||
raise Exception(f"Failed to extract URL from input media metadata: {extracted_info}")
|
||||
|
||||
if "extractor_key" in extracted_info:
|
||||
parsed_data["extractor"] = extracted_info["extractor_key"]
|
||||
elif "ie_key" in extracted_info:
|
||||
parsed_data["extractor"] = extracted_info["ie_key"]
|
||||
else:
|
||||
raise Exception(f"Failed to find extractor name from input media metadata: {extracted_info}")
|
||||
|
||||
if "id" in extracted_info:
|
||||
parsed_data["media_id"] = extracted_info["id"]
|
||||
|
||||
# Example: "Artist - Title"
|
||||
if "title" in extracted_info and "-" in extracted_info["title"]:
|
||||
try:
|
||||
metadata_artist, metadata_title = extracted_info["title"].split("-", 1)
|
||||
metadata_artist = metadata_artist.strip()
|
||||
metadata_title = metadata_title.strip()
|
||||
except ValueError:
|
||||
logger.warning(f"Could not split title '{extracted_info['title']}' on '-', using full title.")
|
||||
metadata_title = extracted_info["title"].strip()
|
||||
if "uploader" in extracted_info:
|
||||
metadata_artist = extracted_info["uploader"]
|
||||
|
||||
elif "uploader" in extracted_info:
|
||||
# Fallback to uploader as artist if title parsing fails
|
||||
metadata_artist = extracted_info["uploader"]
|
||||
if "title" in extracted_info:
|
||||
metadata_title = extracted_info["title"].strip()
|
||||
|
||||
# If unable to parse, log an appropriate message
|
||||
if not metadata_artist or not metadata_title:
|
||||
logger.warning("Could not parse artist and title from the input media metadata.")
|
||||
|
||||
if not parsed_data["artist"] and metadata_artist:
|
||||
logger.warning(f"Artist not provided as input, setting to {metadata_artist} from input media metadata...")
|
||||
parsed_data["artist"] = metadata_artist
|
||||
|
||||
if not parsed_data["title"] and metadata_title:
|
||||
logger.warning(f"Title not provided as input, setting to {metadata_title} from input media metadata...")
|
||||
parsed_data["title"] = metadata_title
|
||||
|
||||
if persistent_artist:
|
||||
logger.debug(
|
||||
f"Resetting artist from {parsed_data['artist']} to persistent artist: {persistent_artist} for consistency while processing playlist..."
|
||||
)
|
||||
parsed_data["artist"] = persistent_artist
|
||||
|
||||
if parsed_data["artist"] and parsed_data["title"]:
|
||||
logger.info(f"Extracted url: {parsed_data['url']}, artist: {parsed_data['artist']}, title: {parsed_data['title']}")
|
||||
else:
|
||||
logger.debug(extracted_info)
|
||||
raise Exception("Failed to extract artist and title from the input media metadata.")
|
||||
|
||||
return parsed_data
|
||||
@@ -1,18 +0,0 @@
|
||||
import re
|
||||
|
||||
def sanitize_filename(filename):
|
||||
"""Replace or remove characters that are unsafe for filenames."""
|
||||
if filename is None:
|
||||
return None
|
||||
# Replace problematic characters with underscores
|
||||
for char in ["\\", "/", ":", "*", "?", '"', "<", ">", "|"]:
|
||||
filename = filename.replace(char, "_")
|
||||
# Remove any trailing periods or spaces
|
||||
filename = filename.rstrip(". ") # Added period here as well
|
||||
# Remove any leading periods or spaces
|
||||
filename = filename.lstrip(". ")
|
||||
# Replace multiple underscores with a single one
|
||||
filename = re.sub(r'_+', '_', filename)
|
||||
# Replace multiple spaces with a single one
|
||||
filename = re.sub(r' +', ' ', filename)
|
||||
return filename
|
||||
@@ -1,483 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
import argparse
|
||||
import logging
|
||||
import pkg_resources
|
||||
import os
|
||||
import csv
|
||||
import asyncio
|
||||
import json
|
||||
import sys
|
||||
from karaoke_prep import KaraokePrep
|
||||
from karaoke_prep.karaoke_finalise import KaraokeFinalise
|
||||
|
||||
# Global logger
|
||||
logger = logging.getLogger(__name__)
|
||||
logger.setLevel(logging.INFO) # Set initial log level
|
||||
|
||||
|
||||
async def process_track_prep(row, args, logger, log_formatter):
|
||||
"""First phase: Process a track through prep stage only, without video rendering"""
|
||||
original_dir = os.getcwd()
|
||||
try:
|
||||
artist = row["Artist"].strip()
|
||||
title = row["Title"].strip()
|
||||
guide_file = row["Mixed Audio Filename"].strip()
|
||||
instrumental_file = row["Instrumental Audio Filename"].strip()
|
||||
|
||||
logger.info(f"Initial prep phase for track: {artist} - {title}")
|
||||
|
||||
kprep = KaraokePrep(
|
||||
artist=artist,
|
||||
title=title,
|
||||
input_media=guide_file,
|
||||
existing_instrumental=instrumental_file,
|
||||
style_params_json=args.style_params_json,
|
||||
logger=logger,
|
||||
log_level=args.log_level,
|
||||
dry_run=args.dry_run,
|
||||
render_video=False, # First phase: no video rendering
|
||||
create_track_subfolders=True,
|
||||
)
|
||||
|
||||
tracks = await kprep.process()
|
||||
return True
|
||||
except Exception as e:
|
||||
logger.error(f"Failed initial prep for {artist} - {title}: {str(e)}")
|
||||
return False
|
||||
finally:
|
||||
os.chdir(original_dir)
|
||||
|
||||
|
||||
async def process_track_render(row, args, logger, log_formatter):
|
||||
"""Phase 2: Process a track through karaoke-finalise."""
|
||||
# First, load CDG styles if CDG generation is enabled
|
||||
cdg_styles = None
|
||||
if args.enable_cdg:
|
||||
if not args.style_params_json:
|
||||
# Raise ValueError instead of sys.exit
|
||||
raise ValueError("CDG styles JSON file path (--style_params_json) is required when --enable_cdg is used")
|
||||
try:
|
||||
with open(args.style_params_json, "r") as f:
|
||||
style_params = json.load(f) # Use json.load directly with file object
|
||||
# Check if 'cdg' key exists
|
||||
if "cdg" not in style_params:
|
||||
raise ValueError(f"'cdg' key not found in style parameters file: {args.style_params_json}")
|
||||
cdg_styles = style_params["cdg"]
|
||||
except FileNotFoundError:
|
||||
# Re-raise FileNotFoundError
|
||||
raise FileNotFoundError(f"CDG styles configuration file not found: {args.style_params_json}")
|
||||
except json.JSONDecodeError as e:
|
||||
# Raise ValueError for invalid JSON
|
||||
raise ValueError(f"Invalid JSON in CDG styles configuration file: {str(e)}")
|
||||
|
||||
original_dir = os.getcwd()
|
||||
artist = row["Artist"].strip()
|
||||
title = row["Title"].strip()
|
||||
guide_file = row["Mixed Audio Filename"].strip()
|
||||
instrumental_file = row["Instrumental Audio Filename"].strip()
|
||||
|
||||
try:
|
||||
# Initialize KaraokeFinalise first (needed for test assertions)
|
||||
kfinalise = KaraokeFinalise(
|
||||
log_formatter=log_formatter,
|
||||
log_level=args.log_level,
|
||||
dry_run=args.dry_run,
|
||||
enable_cdg=args.enable_cdg,
|
||||
enable_txt=args.enable_txt,
|
||||
cdg_styles=cdg_styles,
|
||||
non_interactive=True
|
||||
)
|
||||
|
||||
# Try to find the track directory
|
||||
track_dir_found = False
|
||||
|
||||
# Try several directory naming patterns
|
||||
possible_dirs = [
|
||||
os.path.join(args.output_dir, f"{artist} - {title}"),
|
||||
os.path.join(args.output_dir, f"{artist} - {title}"), # Original artist/title from row
|
||||
os.path.join(args.output_dir, f"{artist} - {title}") # With space replace (same here)
|
||||
]
|
||||
|
||||
for track_dir in possible_dirs:
|
||||
if os.path.exists(track_dir):
|
||||
track_dir_found = True
|
||||
break
|
||||
|
||||
if not track_dir_found:
|
||||
logger.error(f"Track directory not found. Tried: {', '.join(possible_dirs)}")
|
||||
return True # Return True to continue with other tracks
|
||||
|
||||
# First run KaraokePrep with video rendering enabled
|
||||
# This is so the human can review all of the lyrics for the entire batch fairly quickly,
|
||||
# then leave the script running to render the videos for all of them.
|
||||
logger.info(f"Video rendering for track: {artist} - {title}")
|
||||
kprep = KaraokePrep(
|
||||
artist=artist,
|
||||
title=title,
|
||||
input_media=guide_file,
|
||||
existing_instrumental=instrumental_file,
|
||||
style_params_json=args.style_params_json,
|
||||
logger=logger,
|
||||
log_level=args.log_level,
|
||||
dry_run=args.dry_run,
|
||||
render_video=True, # Second phase: with video rendering
|
||||
create_track_subfolders=True,
|
||||
skip_transcription_review=True,
|
||||
)
|
||||
|
||||
tracks = await kprep.process()
|
||||
|
||||
# Process with KaraokeFinalise in the track directory
|
||||
for track_dir in possible_dirs:
|
||||
if os.path.exists(track_dir):
|
||||
try:
|
||||
os.chdir(track_dir)
|
||||
# Process with KaraokeFinalise
|
||||
kfinalise.process()
|
||||
return True
|
||||
except Exception as e:
|
||||
logger.error(f"Error during finalisation: {str(e)}")
|
||||
raise # Re-raise to be caught by outer try/except
|
||||
finally:
|
||||
# Always go back to original directory
|
||||
os.chdir(original_dir)
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Failed render/finalise for {artist} - {title}: {str(e)}")
|
||||
os.chdir(original_dir) # Make sure we go back to original directory
|
||||
return False
|
||||
|
||||
|
||||
def update_csv_status(csv_path, row_index, new_status, dry_run=False):
|
||||
"""Update the status of a processed row in the CSV file.
|
||||
|
||||
Args:
|
||||
csv_path (str): Path to the CSV file
|
||||
row_index (int): Index of the row to update
|
||||
new_status (str): New status to set
|
||||
dry_run (bool): If True, log the update but don't modify the file
|
||||
|
||||
Returns:
|
||||
bool: True if updated, False if in dry run mode or error occurred
|
||||
"""
|
||||
if dry_run:
|
||||
logger.info(f"DRY RUN: Would update row {row_index} in {csv_path} to status '{new_status}'")
|
||||
return False
|
||||
|
||||
try:
|
||||
# Read all rows
|
||||
with open(csv_path, "r") as f:
|
||||
reader = csv.DictReader(f)
|
||||
rows = list(reader)
|
||||
|
||||
# Check if CSV has any rows
|
||||
if not rows:
|
||||
logger.error(f"CSV file {csv_path} is empty or has no data rows")
|
||||
return False
|
||||
|
||||
# Update status for the processed row
|
||||
if row_index < 0 or row_index >= len(rows):
|
||||
logger.error(f"Row index {row_index} is out of range for CSV with {len(rows)} rows")
|
||||
return False
|
||||
|
||||
rows[row_index]["Status"] = new_status
|
||||
|
||||
# Write back to CSV
|
||||
fieldnames = rows[0].keys()
|
||||
with open(csv_path, "w", newline="") as f:
|
||||
writer = csv.DictWriter(f, fieldnames=fieldnames)
|
||||
writer.writeheader()
|
||||
writer.writerows(rows)
|
||||
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error updating CSV status: {str(e)}")
|
||||
return False
|
||||
|
||||
|
||||
def parse_arguments():
|
||||
"""Parse command line arguments"""
|
||||
parser = argparse.ArgumentParser(
|
||||
description="Process multiple karaoke tracks in bulk from a CSV file.",
|
||||
formatter_class=lambda prog: argparse.RawTextHelpFormatter(prog, max_help_position=54),
|
||||
)
|
||||
|
||||
# Basic information
|
||||
parser.add_argument(
|
||||
"input_csv",
|
||||
help="Path to CSV file containing tracks to process. CSV should have columns: Artist,Title,Mixed Audio Filename,Instrumental Audio Filename,Status",
|
||||
)
|
||||
|
||||
package_version = pkg_resources.get_distribution("karaoke-gen").version
|
||||
parser.add_argument("-v", "--version", action="version", version=f"%(prog)s {package_version}")
|
||||
|
||||
# Required arguments
|
||||
parser.add_argument(
|
||||
"--style_params_json",
|
||||
required=True,
|
||||
help="Path to style parameters JSON file",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--output_dir",
|
||||
default=".",
|
||||
help="Optional: directory to write output files (default: <current dir>). Example: --output_dir=/app/karaoke",
|
||||
)
|
||||
|
||||
# Finalise-specific arguments
|
||||
parser.add_argument(
|
||||
"--enable_cdg",
|
||||
action="store_true",
|
||||
help="Optional: Enable CDG ZIP generation during finalisation. Example: --enable_cdg",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--enable_txt",
|
||||
action="store_true",
|
||||
help="Optional: Enable TXT ZIP generation during finalisation. Example: --enable_txt",
|
||||
)
|
||||
|
||||
# Logging & Debugging
|
||||
parser.add_argument(
|
||||
"--log_level",
|
||||
default="info",
|
||||
help="Optional: logging level, e.g. info, debug, warning (default: %(default)s). Example: --log_level=debug",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--dry_run",
|
||||
action="store_true",
|
||||
help="Optional: perform a dry run without making any changes (default: %(default)s). Example: --dry_run",
|
||||
)
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
# Convert input_csv to absolute path early
|
||||
args.input_csv = os.path.abspath(args.input_csv)
|
||||
|
||||
# Validate and convert log level
|
||||
if isinstance(args.log_level, str):
|
||||
try:
|
||||
log_level_int = getattr(logging, args.log_level.upper())
|
||||
args.log_level = log_level_int # Store the numeric log level back in args
|
||||
except AttributeError:
|
||||
# Raise ValueError for invalid log level string
|
||||
raise ValueError(f"Invalid log level string: {args.log_level}")
|
||||
elif not isinstance(args.log_level, int):
|
||||
# If it's neither string nor int, raise error
|
||||
raise ValueError(f"Invalid log level type: {type(args.log_level)}")
|
||||
|
||||
return args
|
||||
|
||||
|
||||
def _parse_and_validate_args():
|
||||
"""Parses arguments and performs initial validation."""
|
||||
args = parse_arguments() # Calls the modified parse_arguments
|
||||
|
||||
# Validate input CSV existence (raises FileNotFoundError if invalid)
|
||||
if not validate_input_csv(args.input_csv):
|
||||
raise FileNotFoundError(f"Input CSV file not found: {args.input_csv}")
|
||||
|
||||
# Validate style params JSON existence if CDG is enabled
|
||||
if args.enable_cdg:
|
||||
if not args.style_params_json:
|
||||
raise ValueError("CDG styles JSON file path (--style_params_json) is required when --enable_cdg is used")
|
||||
if not os.path.isfile(args.style_params_json):
|
||||
raise FileNotFoundError(f"CDG styles configuration file not found: {args.style_params_json}")
|
||||
# Basic JSON validation can also happen here if desired, or deferred to process_track_render
|
||||
try:
|
||||
with open(args.style_params_json, 'r') as f:
|
||||
json.load(f)
|
||||
except json.JSONDecodeError as e:
|
||||
raise ValueError(f"Invalid JSON in CDG styles configuration file: {args.style_params_json} - {e}")
|
||||
except FileNotFoundError: # Should be caught above, but belt-and-suspenders
|
||||
raise FileNotFoundError(f"CDG styles configuration file not found: {args.style_params_json}")
|
||||
|
||||
return args
|
||||
|
||||
|
||||
def validate_input_csv(csv_path):
|
||||
"""Validate that the input CSV file exists.
|
||||
|
||||
Args:
|
||||
csv_path (str): Path to the CSV file
|
||||
|
||||
Returns:
|
||||
bool: True if the file exists, False otherwise
|
||||
"""
|
||||
if not os.path.isfile(csv_path):
|
||||
logger.error(f"Input CSV file not found: {csv_path}")
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def _read_csv_file(csv_path):
|
||||
"""Reads the CSV file and returns rows as a list of dictionaries."""
|
||||
try:
|
||||
with open(csv_path, "r", newline='') as f: # Added newline=''
|
||||
reader = csv.DictReader(f)
|
||||
# Check for required columns before reading all rows
|
||||
required_columns = {"Artist", "Title", "Mixed Audio Filename", "Instrumental Audio Filename", "Status"}
|
||||
if not required_columns.issubset(reader.fieldnames):
|
||||
missing = required_columns - set(reader.fieldnames)
|
||||
raise ValueError(f"CSV file missing required columns: {', '.join(missing)}")
|
||||
rows = list(reader)
|
||||
if not rows:
|
||||
logger.warning(f"CSV file {csv_path} is empty or contains only headers.")
|
||||
return rows
|
||||
except FileNotFoundError:
|
||||
# This should ideally be caught earlier by validate_input_csv, but handle defensively
|
||||
logger.error(f"CSV file not found during read: {csv_path}")
|
||||
raise # Re-raise the exception
|
||||
except Exception as e:
|
||||
logger.error(f"Error reading CSV file {csv_path}: {e}")
|
||||
raise # Re-raise other read errors
|
||||
|
||||
|
||||
async def process_csv_rows(csv_path, rows, args, logger, log_formatter):
|
||||
"""Process all rows in a CSV file.
|
||||
|
||||
Args:
|
||||
csv_path (str): Path to the CSV file
|
||||
rows (list): List of CSV rows as dictionaries
|
||||
args (argparse.Namespace): Command line arguments
|
||||
logger (logging.Logger): Logger instance
|
||||
log_formatter (logging.Formatter): Log formatter
|
||||
|
||||
Returns:
|
||||
dict: A summary of the processing results
|
||||
"""
|
||||
results = {
|
||||
"prep_success": 0,
|
||||
"prep_failed": 0,
|
||||
"render_success": 0,
|
||||
"render_failed": 0,
|
||||
"skipped": 0
|
||||
}
|
||||
|
||||
# Phase 1: Initial prep for all tracks
|
||||
logger.info("Starting Phase 1: Initial prep for all tracks")
|
||||
for i, row in enumerate(rows):
|
||||
status = row["Status"].lower() if "Status" in row else ""
|
||||
if status != "uploaded":
|
||||
logger.info(f"Skipping {row.get('Artist', 'Unknown')} - {row.get('Title', 'Unknown')} (Status: {row.get('Status', 'Unknown')})")
|
||||
results["skipped"] += 1
|
||||
continue
|
||||
|
||||
success = await process_track_prep(row, args, logger, log_formatter)
|
||||
if success:
|
||||
results["prep_success"] += 1
|
||||
if not args.dry_run:
|
||||
update_csv_status(csv_path, i, "Prep_Complete", args.dry_run)
|
||||
else:
|
||||
results["prep_failed"] += 1
|
||||
if not args.dry_run:
|
||||
update_csv_status(csv_path, i, "Prep_Failed", args.dry_run)
|
||||
|
||||
# Phase 2: Render and finalise all tracks
|
||||
logger.info("Starting Phase 2: Render and finalise for all tracks")
|
||||
for i, row in enumerate(rows):
|
||||
status = row["Status"].lower() if "Status" in row else ""
|
||||
if status not in ["prep_complete", "uploaded"]:
|
||||
logger.info(f"Skipping {row.get('Artist', 'Unknown')} - {row.get('Title', 'Unknown')} (Status: {row.get('Status', 'Unknown')})")
|
||||
continue
|
||||
|
||||
success = await process_track_render(row, args, logger, log_formatter)
|
||||
if success:
|
||||
results["render_success"] += 1
|
||||
if not args.dry_run:
|
||||
update_csv_status(csv_path, i, "Completed", args.dry_run)
|
||||
else:
|
||||
results["render_failed"] += 1
|
||||
if not args.dry_run:
|
||||
update_csv_status(csv_path, i, "Render_Failed", args.dry_run)
|
||||
|
||||
return results
|
||||
|
||||
|
||||
async def async_main():
|
||||
"""Main async function to process bulk tracks from CSV"""
|
||||
# Parse and validate arguments first (raises exceptions on failure)
|
||||
args = _parse_and_validate_args()
|
||||
|
||||
# Set log level based on validated args (logger should already be partially set up by main)
|
||||
logger.setLevel(args.log_level)
|
||||
logger.info(f"Log level set to {logging.getLevelName(args.log_level)}")
|
||||
if args.dry_run:
|
||||
logger.info("Dry run mode enabled. No changes will be made.")
|
||||
|
||||
logger.info(f"Starting bulk processing with input CSV: {args.input_csv}")
|
||||
|
||||
# Read CSV (raises exceptions on failure)
|
||||
rows = _read_csv_file(args.input_csv)
|
||||
|
||||
# Check if log_formatter is available (should be set by main)
|
||||
global log_formatter
|
||||
if log_formatter is None:
|
||||
# This case should ideally not happen if main() calls setup_logging correctly
|
||||
logger.warning("Log formatter not found, setting up default.")
|
||||
log_formatter = setup_logging(args.log_level)
|
||||
|
||||
|
||||
# Process the CSV rows
|
||||
results = await process_csv_rows(args.input_csv, rows, args, logger, log_formatter)
|
||||
|
||||
# Log summary
|
||||
logger.info(f"Processing complete. Summary: {results}")
|
||||
return results
|
||||
|
||||
|
||||
def setup_logging(log_level=logging.INFO):
|
||||
"""Set up logging with the given log level.
|
||||
|
||||
Args:
|
||||
log_level (int): Logging level (e.g., logging.INFO, logging.DEBUG)
|
||||
|
||||
Returns:
|
||||
logging.Formatter: The log formatter for use by other functions
|
||||
"""
|
||||
global log_formatter # Make log_formatter accessible to other functions
|
||||
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)
|
||||
logger.setLevel(log_level)
|
||||
return log_formatter
|
||||
|
||||
|
||||
def main():
|
||||
"""Main entry point for the CLI."""
|
||||
log_formatter = None # Initialize log_formatter
|
||||
try:
|
||||
# Set up logging early to capture potential errors during setup/parsing
|
||||
# Get initial args just for log level if provided, otherwise default
|
||||
temp_args, _ = argparse.ArgumentParser(add_help=False).parse_known_args()
|
||||
initial_log_level_str = getattr(temp_args, 'log_level', 'info')
|
||||
try:
|
||||
initial_log_level = getattr(logging, initial_log_level_str.upper())
|
||||
except AttributeError:
|
||||
initial_log_level = logging.INFO
|
||||
print(f"Warning: Invalid initial log level '{initial_log_level_str}'. Using INFO.", file=sys.stderr)
|
||||
|
||||
log_formatter = setup_logging(initial_log_level)
|
||||
|
||||
# Run the async main function using asyncio
|
||||
asyncio.run(async_main())
|
||||
logger.info("Bulk processing finished successfully.")
|
||||
sys.exit(0)
|
||||
except (FileNotFoundError, ValueError, argparse.ArgumentError) as e:
|
||||
# Log specific configuration/setup errors before exiting
|
||||
if logger.handlers: # Check if logger was set up
|
||||
logger.error(f"Configuration error: {str(e)}")
|
||||
else: # Fallback if logging setup failed
|
||||
print(f"Error: {str(e)}", file=sys.stderr)
|
||||
sys.exit(1)
|
||||
except Exception as e:
|
||||
# Catch any other unexpected errors during processing
|
||||
if logger.handlers:
|
||||
logger.exception(f"An unexpected error occurred during bulk processing: {str(e)}") # Use exception for traceback
|
||||
else:
|
||||
print(f"An unexpected error occurred: {str(e)}", file=sys.stderr)
|
||||
sys.exit(1)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,873 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
print("DEBUG: gen_cli.py starting imports...")
|
||||
import argparse
|
||||
import logging
|
||||
from importlib import metadata
|
||||
import tempfile
|
||||
import os
|
||||
import sys
|
||||
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.")
|
||||
|
||||
|
||||
def is_url(string):
|
||||
"""Simple check to determine if a string is a URL."""
|
||||
return string.startswith("http://") or string.startswith("https://")
|
||||
|
||||
|
||||
def is_file(string):
|
||||
"""Check if a string is a valid file."""
|
||||
return os.path.isfile(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),
|
||||
)
|
||||
|
||||
# Basic information
|
||||
parser.add_argument(
|
||||
"args",
|
||||
nargs="*",
|
||||
help="[Media or playlist URL] [Artist] [Title] of song to process. If URL is provided, Artist and Title are optional but increase chance of fetching the correct lyrics. If Artist and Title are provided with no URL, the top YouTube search result will be fetched.",
|
||||
)
|
||||
|
||||
# Get version using importlib.metadata
|
||||
try:
|
||||
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}")
|
||||
|
||||
# Workflow control
|
||||
workflow_group = parser.add_argument_group("Workflow Control")
|
||||
workflow_group.add_argument(
|
||||
"--prep-only",
|
||||
action="store_true",
|
||||
help="Only run the preparation phase (download audio, lyrics, separate stems, create title screens). Example: --prep-only",
|
||||
)
|
||||
workflow_group.add_argument(
|
||||
"--finalise-only",
|
||||
action="store_true",
|
||||
help="Only run the finalisation phase (remux, encode, organize). Must be run in a directory prepared by the prep phase. Example: --finalise-only",
|
||||
)
|
||||
workflow_group.add_argument(
|
||||
"--skip-transcription",
|
||||
action="store_true",
|
||||
help="Skip automatic lyrics transcription/synchronization. Use this to fall back to manual syncing. Example: --skip-transcription",
|
||||
)
|
||||
workflow_group.add_argument(
|
||||
"--skip-separation",
|
||||
action="store_true",
|
||||
help="Skip audio separation process. Example: --skip-separation",
|
||||
)
|
||||
workflow_group.add_argument(
|
||||
"--skip-lyrics",
|
||||
action="store_true",
|
||||
help="Skip fetching and processing lyrics. Example: --skip-lyrics",
|
||||
)
|
||||
workflow_group.add_argument(
|
||||
"--lyrics-only",
|
||||
action="store_true",
|
||||
help="Only process lyrics, skipping audio separation and title/end screen generation. Example: --lyrics-only",
|
||||
)
|
||||
workflow_group.add_argument(
|
||||
"--edit-lyrics",
|
||||
action="store_true",
|
||||
help="Edit lyrics of an existing track. This will backup existing outputs, re-run the lyrics transcription process, and update all outputs. Example: --edit-lyrics",
|
||||
)
|
||||
|
||||
# Logging & Debugging
|
||||
debug_group = parser.add_argument_group("Logging & Debugging")
|
||||
debug_group.add_argument(
|
||||
"--log_level",
|
||||
default="info",
|
||||
help="Optional: logging level, e.g. info, debug, warning (default: %(default)s). Example: --log_level=debug",
|
||||
)
|
||||
debug_group.add_argument(
|
||||
"--dry_run",
|
||||
action="store_true",
|
||||
help="Optional: perform a dry run without making any changes. Example: --dry_run",
|
||||
)
|
||||
debug_group.add_argument(
|
||||
"--render_bounding_boxes",
|
||||
action="store_true",
|
||||
help="Optional: render bounding boxes around text regions for debugging. Example: --render_bounding_boxes",
|
||||
)
|
||||
|
||||
# Input/Output Configuration
|
||||
io_group = parser.add_argument_group("Input/Output Configuration")
|
||||
io_group.add_argument(
|
||||
"--filename_pattern",
|
||||
help="Required if processing a folder: Python regex pattern to extract track names from filenames. Must contain a named group 'title'. Example: --filename_pattern='(?P<index>\\d+) - (?P<title>.+).mp3'",
|
||||
)
|
||||
io_group.add_argument(
|
||||
"--output_dir",
|
||||
default=".",
|
||||
help="Optional: directory to write output files (default: <current dir>). Example: --output_dir=/app/karaoke",
|
||||
)
|
||||
io_group.add_argument(
|
||||
"--no_track_subfolders",
|
||||
action="store_false",
|
||||
dest="no_track_subfolders",
|
||||
help="Optional: do NOT create a named subfolder for each track. Example: --no_track_subfolders",
|
||||
)
|
||||
io_group.add_argument(
|
||||
"--lossless_output_format",
|
||||
default="FLAC",
|
||||
help="Optional: lossless output format for separated audio (default: FLAC). Example: --lossless_output_format=WAV",
|
||||
)
|
||||
io_group.add_argument(
|
||||
"--output_png",
|
||||
type=lambda x: (str(x).lower() == "true"),
|
||||
default=True,
|
||||
help="Optional: output PNG format for title and end images (default: %(default)s). Example: --output_png=False",
|
||||
)
|
||||
io_group.add_argument(
|
||||
"--output_jpg",
|
||||
type=lambda x: (str(x).lower() == "true"),
|
||||
default=True,
|
||||
help="Optional: output JPG format for title and end images (default: %(default)s). Example: --output_jpg=False",
|
||||
)
|
||||
|
||||
# Audio Processing Configuration
|
||||
audio_group = parser.add_argument_group("Audio Processing Configuration")
|
||||
audio_group.add_argument(
|
||||
"--clean_instrumental_model",
|
||||
default="model_bs_roformer_ep_317_sdr_12.9755.ckpt",
|
||||
help="Optional: Model for clean instrumental separation (default: %(default)s).",
|
||||
)
|
||||
audio_group.add_argument(
|
||||
"--backing_vocals_models",
|
||||
nargs="+",
|
||||
default=["mel_band_roformer_karaoke_aufr33_viperx_sdr_10.1956.ckpt"],
|
||||
help="Optional: List of models for backing vocals separation (default: %(default)s).",
|
||||
)
|
||||
audio_group.add_argument(
|
||||
"--other_stems_models",
|
||||
nargs="+",
|
||||
default=["htdemucs_6s.yaml"],
|
||||
help="Optional: List of models for other stems separation (default: %(default)s).",
|
||||
)
|
||||
|
||||
default_model_dir_unix = "/tmp/audio-separator-models/"
|
||||
if os.name == "posix" and os.path.exists(default_model_dir_unix):
|
||||
default_model_dir = default_model_dir_unix
|
||||
else:
|
||||
# Use tempfile to get the platform-independent temp directory
|
||||
default_model_dir = os.path.join(tempfile.gettempdir(), "audio-separator-models")
|
||||
|
||||
audio_group.add_argument(
|
||||
"--model_file_dir",
|
||||
default=default_model_dir,
|
||||
help="Optional: model files directory (default: %(default)s). Example: --model_file_dir=/app/models",
|
||||
)
|
||||
audio_group.add_argument(
|
||||
"--existing_instrumental",
|
||||
help="Optional: Path to an existing instrumental audio file. If provided, audio separation will be skipped.",
|
||||
)
|
||||
audio_group.add_argument(
|
||||
"--instrumental_format",
|
||||
default="flac",
|
||||
help="Optional: format / file extension for instrumental track to use for remux (default: %(default)s). Example: --instrumental_format=mp3",
|
||||
)
|
||||
|
||||
# Lyrics Configuration
|
||||
lyrics_group = parser.add_argument_group("Lyrics Configuration")
|
||||
lyrics_group.add_argument(
|
||||
"--lyrics_artist",
|
||||
help="Optional: Override the artist name used for lyrics search. Example: --lyrics_artist='The Beatles'",
|
||||
)
|
||||
lyrics_group.add_argument(
|
||||
"--lyrics_title",
|
||||
help="Optional: Override the song title used for lyrics search. Example: --lyrics_title='Hey Jude'",
|
||||
)
|
||||
lyrics_group.add_argument(
|
||||
"--lyrics_file",
|
||||
help="Optional: Path to a file containing lyrics to use instead of fetching from online. Example: --lyrics_file='/path/to/lyrics.txt'",
|
||||
)
|
||||
lyrics_group.add_argument(
|
||||
"--subtitle_offset_ms",
|
||||
type=int,
|
||||
default=0,
|
||||
help="Optional: Adjust subtitle timing by N milliseconds (+ve delays, -ve advances). Example: --subtitle_offset_ms=500",
|
||||
)
|
||||
lyrics_group.add_argument(
|
||||
"--skip_transcription_review",
|
||||
action="store_true",
|
||||
help="Optional: Skip the review step after transcription. Example: --skip_transcription_review",
|
||||
)
|
||||
|
||||
# Style Configuration
|
||||
style_group = parser.add_argument_group("Style Configuration")
|
||||
style_group.add_argument(
|
||||
"--style_params_json",
|
||||
help="Optional: Path to JSON file containing style configuration. Example: --style_params_json='/path/to/style_params.json'",
|
||||
)
|
||||
|
||||
# Finalisation Configuration
|
||||
finalise_group = parser.add_argument_group("Finalisation Configuration")
|
||||
finalise_group.add_argument(
|
||||
"--enable_cdg",
|
||||
action="store_true",
|
||||
help="Optional: Enable CDG ZIP generation during finalisation. Example: --enable_cdg",
|
||||
)
|
||||
finalise_group.add_argument(
|
||||
"--enable_txt",
|
||||
action="store_true",
|
||||
help="Optional: Enable TXT ZIP generation during finalisation. Example: --enable_txt",
|
||||
)
|
||||
finalise_group.add_argument(
|
||||
"--brand_prefix",
|
||||
help="Optional: Your brand prefix to calculate the next sequential number. Example: --brand_prefix=BRAND",
|
||||
)
|
||||
finalise_group.add_argument(
|
||||
"--organised_dir",
|
||||
help="Optional: Target directory where the processed folder will be moved. Example: --organised_dir='/path/to/Tracks-Organized'",
|
||||
)
|
||||
finalise_group.add_argument(
|
||||
"--organised_dir_rclone_root",
|
||||
help="Optional: Rclone path which maps to your organised_dir. Example: --organised_dir_rclone_root='dropbox:Media/Karaoke/Tracks-Organized'",
|
||||
)
|
||||
finalise_group.add_argument(
|
||||
"--public_share_dir",
|
||||
help="Optional: Public share directory for final files. Example: --public_share_dir='/path/to/Tracks-PublicShare'",
|
||||
)
|
||||
finalise_group.add_argument(
|
||||
"--youtube_client_secrets_file",
|
||||
help="Optional: Path to youtube client secrets file. Example: --youtube_client_secrets_file='/path/to/client_secret.json'",
|
||||
)
|
||||
finalise_group.add_argument(
|
||||
"--youtube_description_file",
|
||||
help="Optional: Path to youtube description template. Example: --youtube_description_file='/path/to/description.txt'",
|
||||
)
|
||||
finalise_group.add_argument(
|
||||
"--rclone_destination",
|
||||
help="Optional: Rclone destination for public_share_dir sync. Example: --rclone_destination='googledrive:KaraokeFolder'",
|
||||
)
|
||||
finalise_group.add_argument(
|
||||
"--discord_webhook_url",
|
||||
help="Optional: Discord webhook URL for notifications. Example: --discord_webhook_url='https://discord.com/api/webhooks/...'",
|
||||
)
|
||||
finalise_group.add_argument(
|
||||
"--email_template_file",
|
||||
help="Optional: Path to email template file. Example: --email_template_file='/path/to/template.txt'",
|
||||
)
|
||||
finalise_group.add_argument(
|
||||
"--keep-brand-code",
|
||||
action="store_true",
|
||||
help="Optional: Use existing brand code from current directory instead of generating new one. Example: --keep-brand-code",
|
||||
)
|
||||
finalise_group.add_argument(
|
||||
"-y",
|
||||
"--yes",
|
||||
action="store_true",
|
||||
help="Optional: Run in non-interactive mode, assuming yes to all prompts. Example: -y",
|
||||
)
|
||||
finalise_group.add_argument(
|
||||
"--test_email_template",
|
||||
action="store_true",
|
||||
help="Optional: Test the email template functionality with fake data. Example: --test_email_template",
|
||||
)
|
||||
|
||||
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())
|
||||
logger.setLevel(log_level)
|
||||
logger.info("Testing email template functionality...")
|
||||
kfinalise = KaraokeFinalise(
|
||||
log_formatter=log_formatter,
|
||||
log_level=log_level,
|
||||
email_template_file=args.email_template_file,
|
||||
)
|
||||
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())
|
||||
logger.setLevel(log_level)
|
||||
logger.info("Running in edit-lyrics mode...")
|
||||
|
||||
# Get the current directory name to extract artist and title
|
||||
current_dir = os.path.basename(os.getcwd())
|
||||
logger.info(f"Current directory: {current_dir}")
|
||||
|
||||
# Extract artist and title from directory name
|
||||
# Format could be either "Artist - Title" or "BRAND-XXXX - Artist - Title"
|
||||
if " - " not in current_dir:
|
||||
logger.error("Current directory name does not contain ' - ' separator. Cannot extract artist and title.")
|
||||
sys.exit(1)
|
||||
return # Explicit return for testing
|
||||
|
||||
parts = current_dir.split(" - ")
|
||||
if len(parts) == 2:
|
||||
artist, title = parts
|
||||
elif len(parts) >= 3:
|
||||
# Handle brand code format: "BRAND-XXXX - Artist - Title"
|
||||
artist = parts[1]
|
||||
title = " - ".join(parts[2:])
|
||||
else:
|
||||
logger.error(f"Could not parse artist and title from directory name: {current_dir}")
|
||||
sys.exit(1)
|
||||
return # Explicit return for testing
|
||||
|
||||
logger.info(f"Extracted artist: {artist}, title: {title}")
|
||||
|
||||
# Initialize KaraokePrep
|
||||
kprep_coroutine = KaraokePrep(
|
||||
artist=artist,
|
||||
title=title,
|
||||
input_media=None, # Will be set by backup_existing_outputs
|
||||
dry_run=args.dry_run,
|
||||
log_formatter=log_formatter,
|
||||
log_level=log_level,
|
||||
render_bounding_boxes=args.render_bounding_boxes,
|
||||
output_dir=".", # We're already in the track directory
|
||||
create_track_subfolders=False, # Don't create subfolders, we're already in one
|
||||
lossless_output_format=args.lossless_output_format,
|
||||
output_png=args.output_png,
|
||||
output_jpg=args.output_jpg,
|
||||
clean_instrumental_model=args.clean_instrumental_model,
|
||||
backing_vocals_models=args.backing_vocals_models,
|
||||
other_stems_models=args.other_stems_models,
|
||||
model_file_dir=args.model_file_dir,
|
||||
skip_separation=True, # Skip separation as we already have the audio files
|
||||
lyrics_artist=args.lyrics_artist or artist,
|
||||
lyrics_title=args.lyrics_title or title,
|
||||
lyrics_file=args.lyrics_file,
|
||||
skip_lyrics=False, # We want to process lyrics
|
||||
skip_transcription=False, # We want to transcribe
|
||||
skip_transcription_review=args.skip_transcription_review,
|
||||
subtitle_offset_ms=args.subtitle_offset_ms,
|
||||
style_params_json=args.style_params_json,
|
||||
)
|
||||
# No await needed for constructor
|
||||
kprep = kprep_coroutine
|
||||
|
||||
# Backup existing outputs and get the input audio file
|
||||
track_output_dir = os.getcwd()
|
||||
input_audio_wav = kprep.file_handler.backup_existing_outputs(track_output_dir, artist, title)
|
||||
kprep.input_media = input_audio_wav
|
||||
|
||||
# Run KaraokePrep
|
||||
tracks = await kprep.process()
|
||||
|
||||
# Load CDG styles if CDG generation is enabled
|
||||
cdg_styles = None
|
||||
if args.enable_cdg:
|
||||
if not args.style_params_json:
|
||||
logger.error("CDG styles JSON file path (--style_params_json) is required when --enable_cdg is used")
|
||||
sys.exit(1)
|
||||
return # Explicit return for testing
|
||||
try:
|
||||
with open(args.style_params_json, "r") as f:
|
||||
style_params = json.loads(f.read())
|
||||
cdg_styles = style_params["cdg"]
|
||||
except FileNotFoundError:
|
||||
logger.error(f"CDG styles configuration file not found: {args.style_params_json}")
|
||||
sys.exit(1)
|
||||
return # Explicit return for testing
|
||||
except json.JSONDecodeError as e:
|
||||
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
|
||||
|
||||
# Run KaraokeFinalise with keep_brand_code=True and replace_existing=True
|
||||
kfinalise = KaraokeFinalise(
|
||||
log_formatter=log_formatter,
|
||||
log_level=log_level,
|
||||
dry_run=args.dry_run,
|
||||
instrumental_format=args.instrumental_format,
|
||||
enable_cdg=args.enable_cdg,
|
||||
enable_txt=args.enable_txt,
|
||||
brand_prefix=args.brand_prefix,
|
||||
organised_dir=args.organised_dir,
|
||||
organised_dir_rclone_root=args.organised_dir_rclone_root,
|
||||
public_share_dir=args.public_share_dir,
|
||||
youtube_client_secrets_file=args.youtube_client_secrets_file,
|
||||
youtube_description_file=args.youtube_description_file,
|
||||
rclone_destination=args.rclone_destination,
|
||||
discord_webhook_url=args.discord_webhook_url,
|
||||
email_template_file=args.email_template_file,
|
||||
cdg_styles=cdg_styles,
|
||||
keep_brand_code=True, # Always keep brand code in edit mode
|
||||
non_interactive=args.yes,
|
||||
)
|
||||
|
||||
try:
|
||||
final_track = kfinalise.process(replace_existing=True) # Replace existing YouTube video
|
||||
logger.info(f"Successfully completed editing lyrics for: {artist} - {title}")
|
||||
|
||||
# Display summary of outputs
|
||||
logger.info(f"Karaoke lyrics edit complete! Output files:")
|
||||
logger.info(f"")
|
||||
logger.info(f"Track: {final_track['artist']} - {final_track['title']}")
|
||||
logger.info(f"")
|
||||
logger.info(f"Working Files:")
|
||||
logger.info(f" Video With Vocals: {final_track['video_with_vocals']}")
|
||||
logger.info(f" Video With Instrumental: {final_track['video_with_instrumental']}")
|
||||
logger.info(f"")
|
||||
logger.info(f"Final Videos:")
|
||||
logger.info(f" Lossless 4K MP4 (PCM): {final_track['final_video']}")
|
||||
logger.info(f" Lossless 4K MKV (FLAC): {final_track['final_video_mkv']}")
|
||||
logger.info(f" Lossy 4K MP4 (AAC): {final_track['final_video_lossy']}")
|
||||
logger.info(f" Lossy 720p MP4 (AAC): {final_track['final_video_720p']}")
|
||||
|
||||
if "final_karaoke_cdg_zip" in final_track or "final_karaoke_txt_zip" in final_track:
|
||||
logger.info(f"")
|
||||
logger.info(f"Karaoke Files:")
|
||||
|
||||
if "final_karaoke_cdg_zip" in final_track:
|
||||
logger.info(f" CDG+MP3 ZIP: {final_track['final_karaoke_cdg_zip']}")
|
||||
|
||||
if "final_karaoke_txt_zip" in final_track:
|
||||
logger.info(f" TXT+MP3 ZIP: {final_track['final_karaoke_txt_zip']}")
|
||||
|
||||
if final_track["brand_code"]:
|
||||
logger.info(f"")
|
||||
logger.info(f"Organization:")
|
||||
logger.info(f" Brand Code: {final_track['brand_code']}")
|
||||
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"")
|
||||
logger.info(f"Sharing:")
|
||||
|
||||
if final_track["brand_code_dir_sharing_link"]:
|
||||
logger.info(f" Folder Link: {final_track['brand_code_dir_sharing_link']}")
|
||||
try:
|
||||
time.sleep(1) # Brief pause between clipboard operations
|
||||
pyperclip.copy(final_track["brand_code_dir_sharing_link"])
|
||||
logger.info(f" (Folder link copied to clipboard)")
|
||||
except Exception as e:
|
||||
logger.warning(f" Failed to copy folder link to clipboard: {str(e)}")
|
||||
|
||||
if final_track["youtube_url"]:
|
||||
logger.info(f" YouTube URL: {final_track['youtube_url']}")
|
||||
try:
|
||||
pyperclip.copy(final_track["youtube_url"])
|
||||
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)}")
|
||||
raise e
|
||||
|
||||
return
|
||||
|
||||
print("DEBUG: async_main() continuing after edit_lyrics check.")
|
||||
|
||||
# Handle finalise-only mode
|
||||
if args.finalise_only:
|
||||
log_level = getattr(logging, args.log_level.upper())
|
||||
logger.setLevel(log_level)
|
||||
logger.info("Running in finalise-only mode...")
|
||||
|
||||
# Load CDG styles if CDG generation is enabled
|
||||
cdg_styles = None
|
||||
if args.enable_cdg:
|
||||
if not args.style_params_json:
|
||||
logger.error("CDG styles JSON file path (--style_params_json) is required when --enable_cdg is used")
|
||||
sys.exit(1)
|
||||
return # Explicit return for testing
|
||||
try:
|
||||
with open(args.style_params_json, "r") as f:
|
||||
style_params = json.loads(f.read())
|
||||
cdg_styles = style_params["cdg"]
|
||||
except FileNotFoundError:
|
||||
logger.error(f"CDG styles configuration file not found: {args.style_params_json}")
|
||||
sys.exit(1)
|
||||
return # Explicit return for testing
|
||||
except json.JSONDecodeError as e:
|
||||
logger.error(f"Invalid JSON in CDG styles configuration file: {e}")
|
||||
sys.exit(1)
|
||||
return # Explicit return for testing
|
||||
|
||||
kfinalise = KaraokeFinalise(
|
||||
log_formatter=log_formatter,
|
||||
log_level=log_level,
|
||||
dry_run=args.dry_run,
|
||||
instrumental_format=args.instrumental_format,
|
||||
enable_cdg=args.enable_cdg,
|
||||
enable_txt=args.enable_txt,
|
||||
brand_prefix=args.brand_prefix,
|
||||
organised_dir=args.organised_dir,
|
||||
organised_dir_rclone_root=args.organised_dir_rclone_root,
|
||||
public_share_dir=args.public_share_dir,
|
||||
youtube_client_secrets_file=args.youtube_client_secrets_file,
|
||||
youtube_description_file=args.youtube_description_file,
|
||||
rclone_destination=args.rclone_destination,
|
||||
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,
|
||||
non_interactive=args.yes,
|
||||
)
|
||||
|
||||
try:
|
||||
track = kfinalise.process()
|
||||
logger.info(f"Karaoke finalisation processing complete! Output files:")
|
||||
logger.info(f"")
|
||||
logger.info(f"Track: {track['artist']} - {track['title']}")
|
||||
logger.info(f"")
|
||||
logger.info(f"Working Files:")
|
||||
logger.info(f" Video With Vocals: {track['video_with_vocals']}")
|
||||
logger.info(f" Video With Instrumental: {track['video_with_instrumental']}")
|
||||
logger.info(f"")
|
||||
logger.info(f"Final Videos:")
|
||||
logger.info(f" Lossless 4K MP4 (PCM): {track['final_video']}")
|
||||
logger.info(f" Lossless 4K MKV (FLAC): {track['final_video_mkv']}")
|
||||
logger.info(f" Lossy 4K MP4 (AAC): {track['final_video_lossy']}")
|
||||
logger.info(f" Lossy 720p MP4 (AAC): {track['final_video_720p']}")
|
||||
|
||||
if "final_karaoke_cdg_zip" in track or "final_karaoke_txt_zip" in track:
|
||||
logger.info(f"")
|
||||
logger.info(f"Karaoke Files:")
|
||||
|
||||
if "final_karaoke_cdg_zip" in track:
|
||||
logger.info(f" CDG+MP3 ZIP: {track['final_karaoke_cdg_zip']}")
|
||||
|
||||
if "final_karaoke_txt_zip" in track:
|
||||
logger.info(f" TXT+MP3 ZIP: {track['final_karaoke_txt_zip']}")
|
||||
|
||||
if track["brand_code"]:
|
||||
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']}")
|
||||
|
||||
if track["youtube_url"] or track["brand_code_dir_sharing_link"]:
|
||||
logger.info(f"")
|
||||
logger.info(f"Sharing:")
|
||||
|
||||
if track["brand_code_dir_sharing_link"]:
|
||||
logger.info(f" Folder Link: {track['brand_code_dir_sharing_link']}")
|
||||
try:
|
||||
time.sleep(1) # Brief pause between clipboard operations
|
||||
pyperclip.copy(track["brand_code_dir_sharing_link"])
|
||||
logger.info(f" (Folder link copied to clipboard)")
|
||||
except Exception as e:
|
||||
logger.warning(f" Failed to copy folder link to clipboard: {str(e)}")
|
||||
|
||||
if track["youtube_url"]:
|
||||
logger.info(f" YouTube URL: {track['youtube_url']}")
|
||||
try:
|
||||
pyperclip.copy(track["youtube_url"])
|
||||
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"An error occurred during finalisation, see stack trace below: {str(e)}")
|
||||
raise e
|
||||
|
||||
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
|
||||
|
||||
if not args.args:
|
||||
parser.print_help()
|
||||
sys.exit(1)
|
||||
return # Explicit return for testing
|
||||
|
||||
# Allow 3 forms of positional arguments:
|
||||
# 1. URL or Media File only (may be single track URL, playlist URL, or local file)
|
||||
# 2. Artist and Title only
|
||||
# 3. URL, Artist, and Title
|
||||
if args.args and (is_url(args.args[0]) or is_file(args.args[0])):
|
||||
input_media = args.args[0]
|
||||
if len(args.args) > 2:
|
||||
artist = args.args[1]
|
||||
title = args.args[2]
|
||||
elif len(args.args) > 1:
|
||||
artist = args.args[1]
|
||||
else:
|
||||
logger.warning("Input media provided without Artist and Title, both will be guessed from title")
|
||||
|
||||
elif os.path.isdir(args.args[0]):
|
||||
if not args.filename_pattern:
|
||||
logger.error("Filename pattern is required when processing a folder.")
|
||||
sys.exit(1)
|
||||
return # Explicit return for testing
|
||||
if len(args.args) <= 1:
|
||||
logger.error("Second parameter provided must be Artist name; Artist is required when processing a folder.")
|
||||
sys.exit(1)
|
||||
return # Explicit return for testing
|
||||
|
||||
input_media = args.args[0]
|
||||
artist = args.args[1]
|
||||
filename_pattern = args.filename_pattern
|
||||
|
||||
elif len(args.args) > 1:
|
||||
artist = args.args[0]
|
||||
title = args.args[1]
|
||||
logger.warning(f"No input media provided, the top YouTube search result for {artist} - {title} will be used.")
|
||||
|
||||
else:
|
||||
parser.print_help()
|
||||
sys.exit(1)
|
||||
return # Explicit return for testing
|
||||
|
||||
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"
|
||||
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(
|
||||
artist=artist,
|
||||
title=title,
|
||||
input_media=input_media,
|
||||
filename_pattern=filename_pattern,
|
||||
dry_run=args.dry_run,
|
||||
log_formatter=log_formatter,
|
||||
log_level=log_level,
|
||||
render_bounding_boxes=args.render_bounding_boxes,
|
||||
output_dir=args.output_dir,
|
||||
create_track_subfolders=args.no_track_subfolders,
|
||||
lossless_output_format=args.lossless_output_format,
|
||||
output_png=args.output_png,
|
||||
output_jpg=args.output_jpg,
|
||||
clean_instrumental_model=args.clean_instrumental_model,
|
||||
backing_vocals_models=args.backing_vocals_models,
|
||||
other_stems_models=args.other_stems_models,
|
||||
model_file_dir=args.model_file_dir,
|
||||
existing_instrumental=args.existing_instrumental,
|
||||
skip_separation=args.skip_separation,
|
||||
lyrics_artist=args.lyrics_artist,
|
||||
lyrics_title=args.lyrics_title,
|
||||
lyrics_file=args.lyrics_file,
|
||||
skip_lyrics=args.skip_lyrics,
|
||||
skip_transcription=args.skip_transcription,
|
||||
skip_transcription_review=args.skip_transcription_review,
|
||||
subtitle_offset_ms=args.subtitle_offset_ms,
|
||||
style_params_json=args.style_params_json,
|
||||
)
|
||||
# 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
|
||||
|
||||
print("DEBUG: async_main() kprep.process() finished.")
|
||||
|
||||
# If prep-only mode, display detailed output and exit
|
||||
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.")
|
||||
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
|
||||
track_dir = track["track_output_dir"]
|
||||
if not os.path.exists(track_dir):
|
||||
logger.error(f"Track directory not found: {track_dir}")
|
||||
continue
|
||||
|
||||
logger.info(f"Changing to directory: {track_dir}")
|
||||
os.chdir(track_dir)
|
||||
|
||||
# Load CDG styles if CDG generation is enabled
|
||||
cdg_styles = None
|
||||
if args.enable_cdg:
|
||||
if not args.style_params_json:
|
||||
logger.error("CDG styles JSON file path (--style_params_json) is required when --enable_cdg is used")
|
||||
sys.exit(1)
|
||||
return # Explicit return for testing
|
||||
try:
|
||||
with open(args.style_params_json, "r") as f:
|
||||
style_params = json.loads(f.read())
|
||||
cdg_styles = style_params["cdg"]
|
||||
except FileNotFoundError:
|
||||
logger.error(f"CDG styles configuration file not found: {args.style_params_json}")
|
||||
sys.exit(1)
|
||||
return # Explicit return for testing
|
||||
except json.JSONDecodeError as e:
|
||||
logger.error(f"Invalid JSON in CDG styles configuration file: {e}")
|
||||
sys.exit(1)
|
||||
return # Explicit return for testing
|
||||
|
||||
# Initialize KaraokeFinalise
|
||||
kfinalise = KaraokeFinalise(
|
||||
log_formatter=log_formatter,
|
||||
log_level=log_level,
|
||||
dry_run=args.dry_run,
|
||||
instrumental_format=args.instrumental_format,
|
||||
enable_cdg=args.enable_cdg,
|
||||
enable_txt=args.enable_txt,
|
||||
brand_prefix=args.brand_prefix,
|
||||
organised_dir=args.organised_dir,
|
||||
organised_dir_rclone_root=args.organised_dir_rclone_root,
|
||||
public_share_dir=args.public_share_dir,
|
||||
youtube_client_secrets_file=args.youtube_client_secrets_file,
|
||||
youtube_description_file=args.youtube_description_file,
|
||||
rclone_destination=args.rclone_destination,
|
||||
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,
|
||||
non_interactive=args.yes,
|
||||
)
|
||||
|
||||
try:
|
||||
final_track = kfinalise.process()
|
||||
logger.info(f"Successfully completed processing for: {track['artist']} - {track['title']}")
|
||||
|
||||
# Display summary of outputs
|
||||
logger.info(f"Karaoke processing complete! Output files:")
|
||||
logger.info(f"")
|
||||
logger.info(f"Track: {final_track['artist']} - {final_track['title']}")
|
||||
logger.info(f"")
|
||||
logger.info(f"Working Files:")
|
||||
logger.info(f" Video With Vocals: {final_track['video_with_vocals']}")
|
||||
logger.info(f" Video With Instrumental: {final_track['video_with_instrumental']}")
|
||||
logger.info(f"")
|
||||
logger.info(f"Final Videos:")
|
||||
logger.info(f" Lossless 4K MP4 (PCM): {final_track['final_video']}")
|
||||
logger.info(f" Lossless 4K MKV (FLAC): {final_track['final_video_mkv']}")
|
||||
logger.info(f" Lossy 4K MP4 (AAC): {final_track['final_video_lossy']}")
|
||||
logger.info(f" Lossy 720p MP4 (AAC): {final_track['final_video_720p']}")
|
||||
|
||||
if "final_karaoke_cdg_zip" in final_track or "final_karaoke_txt_zip" in final_track:
|
||||
logger.info(f"")
|
||||
logger.info(f"Karaoke Files:")
|
||||
|
||||
if "final_karaoke_cdg_zip" in final_track:
|
||||
logger.info(f" CDG+MP3 ZIP: {final_track['final_karaoke_cdg_zip']}")
|
||||
|
||||
if "final_karaoke_txt_zip" in final_track:
|
||||
logger.info(f" TXT+MP3 ZIP: {final_track['final_karaoke_txt_zip']}")
|
||||
|
||||
if final_track["brand_code"]:
|
||||
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']}")
|
||||
|
||||
if final_track["youtube_url"] or final_track["brand_code_dir_sharing_link"]:
|
||||
logger.info(f"")
|
||||
logger.info(f"Sharing:")
|
||||
|
||||
if final_track["brand_code_dir_sharing_link"]:
|
||||
logger.info(f" Folder Link: {final_track['brand_code_dir_sharing_link']}")
|
||||
try:
|
||||
time.sleep(1) # Brief pause between clipboard operations
|
||||
pyperclip.copy(final_track["brand_code_dir_sharing_link"])
|
||||
logger.info(f" (Folder link copied to clipboard)")
|
||||
except Exception as e:
|
||||
logger.warning(f" Failed to copy folder link to clipboard: {str(e)}")
|
||||
|
||||
if final_track["youtube_url"]:
|
||||
logger.info(f" YouTube URL: {final_track['youtube_url']}")
|
||||
try:
|
||||
pyperclip.copy(final_track["youtube_url"])
|
||||
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)}")
|
||||
raise e
|
||||
|
||||
print("DEBUG: async_main() finished.")
|
||||
|
||||
|
||||
def main():
|
||||
print("DEBUG: main() started.")
|
||||
asyncio.run(async_main())
|
||||
print("DEBUG: main() finished.")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
print("DEBUG: __main__ block executing.")
|
||||
main()
|
||||
@@ -1,424 +0,0 @@
|
||||
import os
|
||||
import logging
|
||||
import importlib.resources as pkg_resources
|
||||
import shutil
|
||||
from PIL import Image, ImageDraw, ImageFont
|
||||
|
||||
|
||||
# Placeholder class or functions for video/image generation
|
||||
class VideoGenerator:
|
||||
def __init__(self, logger, ffmpeg_base_command, render_bounding_boxes, output_png, output_jpg):
|
||||
self.logger = logger
|
||||
self.ffmpeg_base_command = ffmpeg_base_command
|
||||
self.render_bounding_boxes = render_bounding_boxes
|
||||
self.output_png = output_png
|
||||
self.output_jpg = output_jpg
|
||||
|
||||
def parse_region(self, region_str):
|
||||
if region_str:
|
||||
try:
|
||||
parts = region_str.split(",")
|
||||
if len(parts) != 4:
|
||||
raise ValueError(f"Invalid region format: {region_str}. Expected 4 elements: 'x,y,width,height'")
|
||||
return tuple(map(int, parts))
|
||||
except ValueError as e:
|
||||
# Re-raise specific format errors or general ValueError for int conversion issues
|
||||
if "Expected 4 elements" in str(e):
|
||||
raise e
|
||||
raise ValueError(f"Invalid region format: {region_str}. Could not convert to integers. Expected format: 'x,y,width,height'") from e
|
||||
return None
|
||||
|
||||
def hex_to_rgb(self, hex_color):
|
||||
"""Convert hex color to RGB tuple."""
|
||||
hex_color = hex_color.lstrip("#")
|
||||
return tuple(int(hex_color[i : i + 2], 16) for i in (0, 2, 4))
|
||||
|
||||
# Placeholder methods - to be filled by user moving code
|
||||
def create_video(
|
||||
self,
|
||||
extra_text,
|
||||
title_text,
|
||||
artist_text,
|
||||
format,
|
||||
output_image_filepath_noext,
|
||||
output_video_filepath,
|
||||
existing_image=None,
|
||||
duration=5,
|
||||
):
|
||||
"""Create a video with title, artist, and optional extra text."""
|
||||
self.logger.debug(f"Creating video with extra_text: '{extra_text}'")
|
||||
self.logger.debug(f"Format settings: {format}")
|
||||
|
||||
resolution = (3840, 2160) # 4K resolution
|
||||
self.logger.info(f"Creating video with format: {format}")
|
||||
self.logger.info(f"extra_text: {extra_text}, artist_text: {artist_text}, title_text: {title_text}")
|
||||
|
||||
if existing_image:
|
||||
return self._handle_existing_image(existing_image, output_image_filepath_noext, output_video_filepath, duration)
|
||||
|
||||
# Create or load background
|
||||
background = self._create_background(format, resolution)
|
||||
draw = ImageDraw.Draw(background)
|
||||
|
||||
if format["font"] is not None:
|
||||
self.logger.info(f"Using font: {format['font']}")
|
||||
# Check if the font path is absolute
|
||||
if os.path.isabs(format["font"]):
|
||||
font_path = format["font"]
|
||||
if not os.path.exists(font_path):
|
||||
self.logger.warning(f"Font file not found at {font_path}, falling back to default font")
|
||||
font_path = None
|
||||
else:
|
||||
# Try to load from package resources
|
||||
try:
|
||||
with pkg_resources.path("karaoke_prep.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")
|
||||
font_path = None
|
||||
|
||||
# Render all text elements
|
||||
self._render_all_text(
|
||||
draw,
|
||||
font_path,
|
||||
title_text,
|
||||
artist_text,
|
||||
format,
|
||||
self.render_bounding_boxes,
|
||||
)
|
||||
else:
|
||||
self.logger.info("No font specified, skipping text rendering")
|
||||
|
||||
# Save images and create video
|
||||
self._save_output_files(
|
||||
background, output_image_filepath_noext, output_video_filepath, duration, resolution
|
||||
)
|
||||
|
||||
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()
|
||||
|
||||
def get_text_size(text, font):
|
||||
bbox = draw.textbbox((0, 0), text, font=font)
|
||||
# Use the actual text height without the font's internal padding
|
||||
return bbox[2], bbox[3] - bbox[1]
|
||||
|
||||
text_width, text_height = get_text_size(text, font)
|
||||
target_height = region[3] # Use full region height as target
|
||||
|
||||
while text_width > region[2] or text_height > target_height:
|
||||
font_size -= 10
|
||||
if font_size <= 150:
|
||||
# Split the text into two lines
|
||||
words = text.split()
|
||||
mid = len(words) // 2
|
||||
line1 = " ".join(words[:mid])
|
||||
line2 = " ".join(words[mid:])
|
||||
|
||||
# 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()
|
||||
|
||||
while True:
|
||||
text_width1, text_height1 = get_text_size(line1, font)
|
||||
text_width2, text_height2 = get_text_size(line2, font)
|
||||
total_height = text_height1 + text_height2
|
||||
|
||||
# Add a small gap between lines (10% of line height)
|
||||
line_gap = text_height1 * 0.1
|
||||
total_height_with_gap = total_height + line_gap
|
||||
|
||||
if max(text_width1, text_width2) <= region[2] and total_height_with_gap <= target_height:
|
||||
return font, (line1, line2)
|
||||
|
||||
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 os.path.exists(font_path) else ImageFont.load_default()
|
||||
text_width, text_height = get_text_size(text, font)
|
||||
|
||||
return font, text
|
||||
|
||||
def _render_text_in_region(self, draw, text, font_path, region, color, gradient=None, font=None):
|
||||
"""Helper method to render text within a specified region."""
|
||||
self.logger.debug(f"Rendering text: '{text}' in region: {region} with color: {color} gradient: {gradient}")
|
||||
|
||||
if text is None:
|
||||
self.logger.debug("Text is None, skipping rendering")
|
||||
return region
|
||||
|
||||
if region is None:
|
||||
self.logger.debug("Region is None, skipping rendering")
|
||||
return region
|
||||
|
||||
if font is None:
|
||||
font, text_lines = self.calculate_text_size_to_fit(draw, text, font_path, region)
|
||||
else:
|
||||
text_lines = text
|
||||
|
||||
self.logger.debug(f"Using text_lines: {text_lines}")
|
||||
|
||||
x, y, width, height = region
|
||||
|
||||
# Get font metrics
|
||||
ascent, descent = font.getmetrics()
|
||||
font_height = ascent + descent
|
||||
|
||||
def render_text_with_gradient(text, position, bbox):
|
||||
# Convert position coordinates to integers
|
||||
position = (int(position[0]), int(position[1]))
|
||||
|
||||
if gradient is None:
|
||||
draw.text(position, text, fill=color, font=font)
|
||||
else:
|
||||
# Create a temporary image for this text
|
||||
text_layer = Image.new("RGBA", (bbox[2], bbox[3]), (0, 0, 0, 0))
|
||||
text_draw = ImageDraw.Draw(text_layer)
|
||||
|
||||
# Draw text in first color
|
||||
text_draw.text((0, 0), text, fill=gradient["color1"], font=font)
|
||||
|
||||
# Create and apply gradient mask
|
||||
mask = self._create_gradient_mask((bbox[2], bbox[3]), gradient)
|
||||
|
||||
# Create second color layer
|
||||
color2_layer = Image.new("RGBA", (bbox[2], bbox[3]), (0, 0, 0, 0))
|
||||
color2_draw = ImageDraw.Draw(color2_layer)
|
||||
color2_draw.text((0, 0), text, fill=gradient["color2"], font=font)
|
||||
|
||||
# Composite using gradient mask
|
||||
text_layer.paste(color2_layer, mask=mask)
|
||||
|
||||
# Paste onto main image
|
||||
draw._image.paste(text_layer, position, text_layer)
|
||||
|
||||
if isinstance(text_lines, tuple): # Two lines
|
||||
line1, line2 = text_lines
|
||||
bbox1 = draw.textbbox((0, 0), line1, font=font)
|
||||
bbox2 = draw.textbbox((0, 0), line2, font=font)
|
||||
|
||||
# Calculate line heights using bounding boxes
|
||||
line1_height = bbox1[3] - bbox1[1]
|
||||
line2_height = bbox2[3] - bbox2[1]
|
||||
|
||||
# Use a small gap between lines (20% of average line height)
|
||||
line_gap = int((line1_height + line2_height) * 0.1)
|
||||
|
||||
# Calculate total height needed
|
||||
total_height = line1_height + line_gap + line2_height
|
||||
|
||||
# Center the entire text block vertically in the region
|
||||
y_start = y + (height - total_height) // 2
|
||||
|
||||
# Draw first line
|
||||
pos1 = (x + (width - bbox1[2]) // 2, y_start)
|
||||
render_text_with_gradient(line1, pos1, bbox1)
|
||||
|
||||
# Draw second line
|
||||
pos2 = (x + (width - bbox2[2]) // 2, y_start + line1_height + line_gap)
|
||||
render_text_with_gradient(line2, pos2, bbox2)
|
||||
else:
|
||||
# Single line
|
||||
bbox = draw.textbbox((0, 0), text_lines, font=font)
|
||||
|
||||
# Center text vertically using font metrics
|
||||
y_pos = y + (height - font_height) // 2
|
||||
|
||||
position = (x + (width - bbox[2]) // 2, y_pos)
|
||||
render_text_with_gradient(text_lines, position, bbox)
|
||||
|
||||
return region
|
||||
|
||||
def _draw_bounding_box(self, draw, region, color):
|
||||
"""Helper method to draw a bounding box around a region."""
|
||||
if region is None:
|
||||
self.logger.debug("Region is None, skipping drawing bounding box")
|
||||
return
|
||||
|
||||
x, y, width, height = region
|
||||
draw.rectangle([x, y, x + width, y + height], outline=color, width=2)
|
||||
|
||||
def _create_gradient_mask(self, size, gradient_config):
|
||||
"""Create a gradient mask for text coloring.
|
||||
|
||||
Args:
|
||||
size (tuple): (width, height) of the mask
|
||||
gradient_config (dict): Configuration with keys:
|
||||
- color1: First color (hex)
|
||||
- color2: Second color (hex)
|
||||
- direction: 'horizontal' or 'vertical'
|
||||
- start: Start point of gradient transition (0-1)
|
||||
- stop: Stop point of gradient transition (0-1)
|
||||
"""
|
||||
mask = Image.new("L", size)
|
||||
draw = ImageDraw.Draw(mask)
|
||||
|
||||
width, height = size
|
||||
start = gradient_config["start"]
|
||||
stop = gradient_config["stop"]
|
||||
|
||||
if gradient_config["direction"] == "horizontal":
|
||||
for x in range(width):
|
||||
# Calculate position in gradient (0 to 1)
|
||||
pos = x / width
|
||||
|
||||
# Calculate color intensity
|
||||
if pos < start:
|
||||
intensity = 0
|
||||
elif pos > stop:
|
||||
intensity = 255
|
||||
else:
|
||||
# Linear interpolation between start and stop
|
||||
intensity = int(255 * (pos - start) / (stop - start))
|
||||
|
||||
draw.line([(x, 0), (x, height)], fill=intensity)
|
||||
else: # vertical
|
||||
for y in range(height):
|
||||
pos = y / height
|
||||
if pos < start:
|
||||
intensity = 0
|
||||
elif pos > stop:
|
||||
intensity = 255
|
||||
else:
|
||||
intensity = int(255 * (pos - start) / (stop - start))
|
||||
|
||||
draw.line([(0, y), (width, y)], fill=intensity)
|
||||
|
||||
return mask
|
||||
|
||||
def _handle_existing_image(self, existing_image, output_image_filepath_noext, output_video_filepath, duration):
|
||||
"""Handle case where an existing image is provided."""
|
||||
self.logger.info(f"Using existing image file: {existing_image}")
|
||||
existing_extension = os.path.splitext(existing_image)[1]
|
||||
|
||||
if existing_extension == ".png":
|
||||
self.logger.info(f"Copying existing PNG image file: {existing_image}")
|
||||
shutil.copy2(existing_image, output_image_filepath_noext + existing_extension)
|
||||
else:
|
||||
self.logger.info(f"Converting existing image to PNG")
|
||||
existing_image_obj = Image.open(existing_image)
|
||||
existing_image_obj.save(output_image_filepath_noext + ".png")
|
||||
|
||||
if existing_extension != ".jpg":
|
||||
self.logger.info(f"Converting existing image to JPG")
|
||||
existing_image_obj = Image.open(existing_image)
|
||||
if existing_image_obj.mode == "RGBA":
|
||||
existing_image_obj = existing_image_obj.convert("RGB")
|
||||
existing_image_obj.save(output_image_filepath_noext + ".jpg", quality=95)
|
||||
|
||||
if duration > 0:
|
||||
self._create_video_from_image(output_image_filepath_noext + ".png", output_video_filepath, duration)
|
||||
|
||||
def _create_background(self, format, resolution):
|
||||
"""Create or load the background image."""
|
||||
if format["background_image"] and os.path.exists(format["background_image"]):
|
||||
self.logger.info(f"Using background image file: {format['background_image']}")
|
||||
background = Image.open(format["background_image"])
|
||||
else:
|
||||
self.logger.info(f"Using background color: {format['background_color']}")
|
||||
background = Image.new("RGB", resolution, color=self.hex_to_rgb(format["background_color"]))
|
||||
|
||||
return background.resize(resolution)
|
||||
|
||||
def _render_all_text(self, draw, font_path, title_text, artist_text, format, render_bounding_boxes):
|
||||
"""Render all text elements on the image."""
|
||||
# Render title
|
||||
if format["title_region"]:
|
||||
region_parsed = self.parse_region(format["title_region"])
|
||||
region = self._render_text_in_region(
|
||||
draw, title_text, font_path, region_parsed, format["title_color"], gradient=format.get("title_gradient")
|
||||
)
|
||||
if render_bounding_boxes:
|
||||
self._draw_bounding_box(draw, region, format["title_color"])
|
||||
|
||||
# Render artist
|
||||
if format["artist_region"]:
|
||||
region_parsed = self.parse_region(format["artist_region"])
|
||||
region = self._render_text_in_region(
|
||||
draw, artist_text, font_path, region_parsed, format["artist_color"], gradient=format.get("artist_gradient")
|
||||
)
|
||||
if render_bounding_boxes:
|
||||
self._draw_bounding_box(draw, region, format["artist_color"])
|
||||
|
||||
# Render extra text if provided
|
||||
if format["extra_text"]:
|
||||
region_parsed = self.parse_region(format["extra_text_region"])
|
||||
region = self._render_text_in_region(
|
||||
draw, format["extra_text"], font_path, region_parsed, format["extra_text_color"], gradient=format.get("extra_text_gradient")
|
||||
)
|
||||
if render_bounding_boxes:
|
||||
self._draw_bounding_box(draw, region, format["extra_text_color"])
|
||||
|
||||
def _save_output_files(
|
||||
self, background, output_image_filepath_noext, output_video_filepath, duration, resolution
|
||||
):
|
||||
"""Save the output image files and create video if needed."""
|
||||
# Save static background image
|
||||
if self.output_png:
|
||||
background.save(f"{output_image_filepath_noext}.png")
|
||||
|
||||
if self.output_jpg:
|
||||
# Save static background image as JPG for smaller filesize
|
||||
background_rgb = background.convert("RGB")
|
||||
background_rgb.save(f"{output_image_filepath_noext}.jpg", quality=95)
|
||||
|
||||
if duration > 0:
|
||||
self._create_video_from_image(f"{output_image_filepath_noext}.png", output_video_filepath, duration, resolution)
|
||||
|
||||
def _create_video_from_image(self, image_path, video_path, duration, resolution=(3840, 2160)):
|
||||
"""Create a video from a static image."""
|
||||
ffmpeg_command = (
|
||||
f'{self.ffmpeg_base_command} -y -loop 1 -framerate 30 -i "{image_path}" '
|
||||
f"-f lavfi -i anullsrc -c:v libx264 -r 30 -t {duration} -pix_fmt yuv420p "
|
||||
f'-vf scale={resolution[0]}:{resolution[1]} -c:a aac -shortest "{video_path}"'
|
||||
)
|
||||
|
||||
self.logger.info("Generating video...")
|
||||
self.logger.debug(f"Running command: {ffmpeg_command}")
|
||||
os.system(ffmpeg_command)
|
||||
|
||||
def _transform_text(self, text, transform_type):
|
||||
"""Helper method to transform text based on specified type."""
|
||||
if text is None:
|
||||
return None # Return None if input is None
|
||||
if transform_type == "uppercase":
|
||||
return text.upper()
|
||||
elif transform_type == "lowercase":
|
||||
return text.lower()
|
||||
elif transform_type == "propercase":
|
||||
return text.title()
|
||||
return text # "none" or any other value returns original text
|
||||
|
||||
def create_title_video(
|
||||
self, artist, title, format, output_image_filepath_noext, output_video_filepath, existing_title_image, intro_video_duration
|
||||
):
|
||||
title_text = self._transform_text(title, format["title_text_transform"])
|
||||
artist_text = self._transform_text(artist, format["artist_text_transform"])
|
||||
self.create_video(
|
||||
title_text=title_text,
|
||||
artist_text=artist_text,
|
||||
extra_text=format["extra_text"],
|
||||
format=format,
|
||||
output_image_filepath_noext=output_image_filepath_noext,
|
||||
output_video_filepath=output_video_filepath,
|
||||
existing_image=existing_title_image,
|
||||
duration=intro_video_duration,
|
||||
)
|
||||
|
||||
def create_end_video(
|
||||
self, artist, title, format, output_image_filepath_noext, output_video_filepath, existing_end_image, end_video_duration
|
||||
):
|
||||
title_text = self._transform_text(title, format["title_text_transform"])
|
||||
artist_text = self._transform_text(artist, format["artist_text_transform"])
|
||||
self.create_video(
|
||||
title_text=title_text,
|
||||
artist_text=artist_text,
|
||||
extra_text=format["extra_text"],
|
||||
format=format,
|
||||
output_image_filepath_noext=output_image_filepath_noext,
|
||||
output_video_filepath=output_video_filepath,
|
||||
existing_image=existing_end_image,
|
||||
duration=end_video_duration,
|
||||
)
|
||||
Generated
+685
-848
File diff suppressed because it is too large.
Load diff
+7
-16
@@ -22,7 +22,7 @@ from email.mime.text import MIMEText
|
||||
from lyrics_transcriber.output.cdg import CDGGenerator
|
||||
|
||||
|
||||
class KaraokeFinalise:
|
||||
class OldKaraokeFinalise:
|
||||
def __init__(
|
||||
self,
|
||||
logger=None,
|
||||
@@ -559,9 +559,9 @@ class KaraokeFinalise:
|
||||
self.logger.info(f"Searching for files in current directory containing {search_string}")
|
||||
|
||||
all_instrumental_files = [f for f in os.listdir(".") if search_string in f]
|
||||
flac_files = set(f.rsplit(".", 1)[0] for f in all_instrumental_files if f.endswith(".flac"))
|
||||
mp3_files = set(f.rsplit(".", 1)[0] for f in all_instrumental_files if f.endswith(".mp3"))
|
||||
wav_files = set(f.rsplit(".", 1)[0] for f in all_instrumental_files if f.endswith(".wav"))
|
||||
flac_files = set(f.rsplit(".", 1)[0] for f in all_instrumental_files if f.lower().endswith(".flac"))
|
||||
mp3_files = set(f.rsplit(".", 1)[0] for f in all_instrumental_files if f.lower().endswith(".mp3"))
|
||||
wav_files = set(f.rsplit(".", 1)[0] for f in all_instrumental_files if f.lower().endswith(".wav"))
|
||||
|
||||
self.logger.debug(f"FLAC files found: {flac_files}")
|
||||
self.logger.debug(f"MP3 files found: {mp3_files}")
|
||||
@@ -572,9 +572,9 @@ class KaraokeFinalise:
|
||||
filtered_files = [
|
||||
f
|
||||
for f in all_instrumental_files
|
||||
if f.endswith(".flac")
|
||||
or (f.endswith(".wav") and f.rsplit(".", 1)[0] not in flac_files)
|
||||
or (f.endswith(".mp3") and f.rsplit(".", 1)[0] not in flac_files and f.rsplit(".", 1)[0] not in wav_files)
|
||||
if f.lower().endswith(".flac")
|
||||
or (f.lower().endswith(".wav") and f.rsplit(".", 1)[0] not in flac_files)
|
||||
or (f.lower().endswith(".mp3") and f.rsplit(".", 1)[0] not in flac_files and f.rsplit(".", 1)[0] not in wav_files)
|
||||
]
|
||||
|
||||
self.logger.debug(f"Filtered instrumental files: {filtered_files}")
|
||||
@@ -878,15 +878,6 @@ class KaraokeFinalise:
|
||||
else:
|
||||
os.rename(orig_dir, self.new_brand_code_dir_path)
|
||||
|
||||
# Update output_files dictionary with the new paths after moving
|
||||
self.logger.info(f"Updating output file paths to reflect move to {self.new_brand_code_dir_path}")
|
||||
for key in output_files:
|
||||
if output_files[key]: # Check if the path exists (e.g., optional files)
|
||||
old_basename = os.path.basename(output_files[key])
|
||||
new_path = os.path.join(self.new_brand_code_dir_path, old_basename)
|
||||
output_files[key] = new_path
|
||||
self.logger.debug(f" Updated {key}: {new_path}")
|
||||
|
||||
def copy_final_files_to_public_share_dirs(self, brand_code, base_name, output_files):
|
||||
self.logger.info(f"Copying final MP4, 720p MP4, and ZIP to public share directory...")
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,91 @@
|
||||
# Karaoke Prep Functionality Map
|
||||
|
||||
This document maps the functionality in the original `old_prep.py` file, showing the line ranges for different functional components.
|
||||
|
||||
## Class Definition and Initialization
|
||||
- **Class Definition**: Lines 25-1808
|
||||
- **Constructor `__init__`**: Lines 26-306
|
||||
- Parameter initialization: Lines 26-91
|
||||
- Logger setup: Lines 92-123
|
||||
- Basic parameters: Lines 125-133
|
||||
- Audio processing parameters: Lines 135-141
|
||||
- Input/Output parameters: Lines 143-148
|
||||
- Lyrics parameters: Lines 150-160
|
||||
- Style parameters and loading: Lines 162-237
|
||||
- Title/End format setup: Lines 239-280
|
||||
- Video settings: Lines 282-286
|
||||
- FFmpeg configuration: Lines 288-296
|
||||
- Debug logging: Lines 298-302
|
||||
- Initialization of output directory: Lines 304-306
|
||||
|
||||
## Helper Methods
|
||||
- **`parse_region`**: Lines 308-315 - Parses region string to tuple
|
||||
- **`sanitize_filename`**: Lines 530-536 - Sanitizes filenames for safe use
|
||||
- **`hex_to_rgb`**: Lines 1181-1184 - Converts hex color to RGB tuple
|
||||
- **`_file_exists`**: Lines 1499-1505 - Checks if file exists and logs result
|
||||
- **`_transform_text`**: Lines 1174-1181 - Transforms text based on specified type
|
||||
|
||||
## Media Information Extraction
|
||||
- **`extract_info_for_online_media`**: Lines 317-330 - Extracts info from online media
|
||||
- **`parse_single_track_metadata`**: Lines 332-382 - Parses metadata from extracted info
|
||||
|
||||
## Media Handling
|
||||
- **`copy_input_media`**: Lines 384-401 - Copies local media file
|
||||
- **`download_video`**: Lines 403-427 - Downloads video from URL
|
||||
- **`extract_still_image_from_video`**: Lines 429-436 - Extracts still image from video
|
||||
- **`convert_to_wav`**: Lines 438-462 - Converts media to WAV format
|
||||
|
||||
## Lyrics Processing
|
||||
- **`find_best_split_point`**: Lines 464-497 - Finds optimal split points for long lines
|
||||
- **`process_line`**: Lines 499-532 - Processes lyrics lines for optimal display
|
||||
- **`transcribe_lyrics`**: Lines 538-637 - Handles lyrics transcription via external module
|
||||
- **`backup_existing_outputs`**: Lines 538-599 - Backs up existing outputs to versioned folder
|
||||
|
||||
## Audio Separation
|
||||
- **`separate_audio`**: Lines 601-653 - Separates audio using audio-separator
|
||||
- **`process_audio_separation`**: Lines 1186-1311 - Main audio separation process
|
||||
- **`_create_stems_directory`**: Lines 1313-1318 - Creates stems directory
|
||||
- **`_separate_clean_instrumental`**: Lines 1320-1344 - Separates clean instrumental
|
||||
- **`_separate_other_stems`**: Lines 1346-1379 - Separates other stems
|
||||
- **`_separate_backing_vocals`**: Lines 1381-1405 - Separates backing vocals
|
||||
- **`_generate_combined_instrumentals`**: Lines 1407-1429 - Combines instrumentals with backing vocals
|
||||
- **`_normalize_audio_files`**: Lines 1431-1457 - Normalizes audio files
|
||||
- **`_normalize_audio`**: Lines 1459-1497 - Performs audio normalization
|
||||
|
||||
## Output Path Handling
|
||||
- **`setup_output_paths`**: Lines 655-677 - Sets up output paths for track
|
||||
|
||||
## Video and Image Generation
|
||||
- **`_create_gradient_mask`**: Lines 679-718 - Creates gradient mask for text coloring
|
||||
- **`calculate_text_size_to_fit`**: Lines 720-771 - Calculates text size to fit in region
|
||||
- **`_render_text_in_region`**: Lines 773-876 - Renders text in specified region
|
||||
- **`_draw_bounding_box`**: Lines 878-887 - Draws bounding box around region
|
||||
- **`create_video`**: Lines 889-934 - Creates video with title, artist, and text
|
||||
- **`_handle_existing_image`**: Lines 936-960 - Handles existing image for video
|
||||
- **`_create_background`**: Lines 962-972 - Creates or loads background image
|
||||
- **`_render_all_text`**: Lines 974-1000 - Renders all text elements on image
|
||||
- **`_save_output_files`**: Lines 1002-1017 - Saves output image files and creates video
|
||||
- **`_create_video_from_image`**: Lines 1019-1032 - Creates video from static image
|
||||
- **`create_title_video`**: Lines 1133-1149 - Creates title video
|
||||
- **`create_end_video`**: Lines 1151-1167 - Creates end video
|
||||
|
||||
## Main Processing Methods
|
||||
- **`prep_single_track`**: Lines 1507-1661 - Prepares a single track
|
||||
- **`shutdown`**: Lines 1663-1690 - Handles shutdown signals gracefully
|
||||
- **`process_playlist`**: Lines 1692-1708 - Processes a playlist
|
||||
- **`process_folder`**: Lines 1710-1748 - Processes a folder of audio files
|
||||
- **`process`**: Lines 1750-1782 - Main entry point for processing
|
||||
|
||||
## Concurrency and Error Handling
|
||||
- Signal handling in `prep_single_track`: Lines 1508-1510, 1655-1659
|
||||
- Task management: Lines 1580-1606
|
||||
- Exception handling: Throughout methods
|
||||
|
||||
## External Dependencies
|
||||
- Media handling: yt-dlp.YoutubeDL
|
||||
- Audio processing: audio_separator.separator
|
||||
- Image processing: PIL (Image, ImageDraw, ImageFont)
|
||||
- Lyrics transcription: lyrics_transcriber
|
||||
- Audio manipulation: pydub.AudioSegment
|
||||
- System utilities: os, sys, re, glob, logging, tempfile, shutil, asyncio, signal, time, fcntl, errno, psutil
|
||||
- Others: dotenv, json, datetime
|
||||
+4
-7
@@ -5,7 +5,7 @@ description = "Generate karaoke videos with synchronized lyrics. Handles the ent
|
||||
authors = ["Andrew Beveridge <andrew@beveridge.uk>"]
|
||||
license = "MIT"
|
||||
readme = "README.md"
|
||||
packages = [{ include = "karaoke_prep" }]
|
||||
packages = [{ include = "karaoke_gen" }]
|
||||
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"
|
||||
@@ -25,7 +25,7 @@ google-auth = "*"
|
||||
google-auth-oauthlib = "*"
|
||||
google-auth-httplib2 = "*"
|
||||
thefuzz = ">=0.22"
|
||||
numpy = "^1"
|
||||
numpy = ">=1"
|
||||
audio-separator = { version = ">=0.21.0", extras = ["cpu"] }
|
||||
lyrics-converter = ">=0.2.1"
|
||||
lyrics-transcriber = ">=0.34"
|
||||
@@ -36,17 +36,14 @@ toml = ">=0.10"
|
||||
argparse = ">=1.4.0"
|
||||
psutil = "^7.0.0"
|
||||
pyperclip = "*"
|
||||
pytest-asyncio = "^0.23.5"
|
||||
ffmpeg-python = "^0.2.0"
|
||||
|
||||
[tool.poetry.group.dev.dependencies]
|
||||
black = ">=23"
|
||||
poetry = "*"
|
||||
pytest-mock = "*"
|
||||
|
||||
[tool.poetry.scripts]
|
||||
karaoke-gen = 'karaoke_prep.utils.gen_cli:main'
|
||||
karaoke-bulk = 'karaoke_prep.utils.bulk_cli:main'
|
||||
karaoke-gen = 'karaoke_gen.cli:main'
|
||||
karaoke-bulk = 'karaoke_gen.cli.bulk_cli:main'
|
||||
|
||||
[tool.black]
|
||||
line-length = 140
|
||||
|
||||
@@ -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"
|
||||
@@ -0,0 +1,3 @@
|
||||
"""
|
||||
Test package for the karaoke_gen package.
|
||||
"""
|
||||
@@ -1,121 +0,0 @@
|
||||
{
|
||||
"intro": {
|
||||
"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",
|
||||
"artist_color": "#ffdf6b",
|
||||
"artist_text_transform": "uppercase",
|
||||
"title_color": "#ffffff",
|
||||
"title_gradient": null,
|
||||
"title_text_transform": "uppercase",
|
||||
"title_region": "370,980,3100,350",
|
||||
"artist_region": "370,1400,3100,450",
|
||||
"artist_gradient": null,
|
||||
"extra_text": null,
|
||||
"extra_text_color": "#ffffff",
|
||||
"extra_text_gradient": null,
|
||||
"extra_text_region": null,
|
||||
"extra_text_text_transform": "uppercase"
|
||||
},
|
||||
"karaoke": {
|
||||
"background_image": "/Users/andrew/AB Dropbox/Andrew Beveridge/MediaUnsynced/Karaoke/NomadBranding/karaoke-background-image-nomad-4k.png",
|
||||
"background_color": "#000000",
|
||||
"font_path": "/Users/andrew/AB Dropbox/Andrew Beveridge/MediaUnsynced/Karaoke/NomadBranding/AvenirNext-Bold.ttf",
|
||||
"font": "Avenir Next Bold",
|
||||
"ass_name": "Nomad",
|
||||
"primary_color": "112, 112, 247, 255",
|
||||
"secondary_color": "255, 255, 255, 255",
|
||||
"outline_color": "26, 58, 235, 255",
|
||||
"back_color": "0, 255, 0, 255",
|
||||
"bold": false,
|
||||
"italic": false,
|
||||
"underline": false,
|
||||
"strike_out": false,
|
||||
"scale_x": 100,
|
||||
"scale_y": 100,
|
||||
"spacing": 0,
|
||||
"angle": 0.0,
|
||||
"border_style": 1,
|
||||
"outline": 1,
|
||||
"shadow": 0,
|
||||
"margin_l": 0,
|
||||
"margin_r": 0,
|
||||
"margin_v": 0,
|
||||
"encoding": 0
|
||||
},
|
||||
"end": {
|
||||
"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",
|
||||
"artist_color": "#ffdf6b",
|
||||
"artist_text_transform": "uppercase",
|
||||
"title_color": "#ffffff",
|
||||
"title_gradient": null,
|
||||
"title_text_transform": "uppercase",
|
||||
"title_region": "370,900,3100,350",
|
||||
"artist_region": "370,1450,3100,200",
|
||||
"artist_gradient": null,
|
||||
"extra_text": "THANK YOU FOR SINGING!",
|
||||
"extra_text_color": "#ff7acc",
|
||||
"extra_text_region": "370,400,3100,400",
|
||||
"extra_text_text_transform": "uppercase",
|
||||
"extra_text_gradient": null
|
||||
},
|
||||
"cdg": {
|
||||
"//sync": "Display timing and sync",
|
||||
"clear_mode": "eager",
|
||||
"sync_offset": 0,
|
||||
"lead_in_threshold": 300,
|
||||
"lead_in_duration": 30,
|
||||
"lead_in_total": 200,
|
||||
"lead_in_symbols": ["/>", ">", ">", ">"],
|
||||
|
||||
"//layout": "Layout and dimensions",
|
||||
"row": 4,
|
||||
"line_tile_height": 3,
|
||||
"lines_per_page": 4,
|
||||
|
||||
"//colors": "Colors",
|
||||
"title_color": "#ffffff",
|
||||
"artist_color": "#ffdf6b",
|
||||
"background_color": "#111427",
|
||||
"border_color": "#111427",
|
||||
"active_fill": "#7070F7",
|
||||
"active_stroke": "#000000",
|
||||
"inactive_fill": "#ff7acc",
|
||||
"inactive_stroke": "#000000",
|
||||
"instrumental_font_color": "#ffdf6b",
|
||||
|
||||
"//font": "Font settings",
|
||||
"font_path": "/Users/andrew/AB Dropbox/Andrew Beveridge/MediaUnsynced/Karaoke/NomadBranding/AvenirNext-Bold.ttf",
|
||||
"font_size": 18,
|
||||
"stroke_width": 0,
|
||||
"stroke_style": "octagon",
|
||||
|
||||
"//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_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_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_transition": "largecentertexttoplogo",
|
||||
"outro_text_line1": "THANK YOU FOR SINGING!",
|
||||
"outro_text_line2": "nomadkaraoke.com",
|
||||
"outro_line1_color": "#ffffff",
|
||||
"outro_line2_color": "#ffdf6b",
|
||||
"outro_line1_line2_gap": 30
|
||||
}
|
||||
}
|
||||
@@ -1,229 +0,0 @@
|
||||
import os
|
||||
import pytest
|
||||
import sys
|
||||
import json
|
||||
from karaoke_prep.karaoke_prep import KaraokePrep
|
||||
from karaoke_prep.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
|
||||
|
||||
# Register the asyncio marker
|
||||
pytest.mark.asyncio = pytest.mark.asyncio
|
||||
|
||||
# Set the default event loop policy to 'auto'
|
||||
pytest_configure = lambda config: config.addinivalue_line("markers", "asyncio: mark test as async")
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
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 ---
|
||||
artist = "Mock Edit Artist"
|
||||
title = "Mock Edit Title"
|
||||
brand_prefix = "EDIT"
|
||||
brand_code = f"{brand_prefix}-9998" # Use a distinct code
|
||||
existing_track_dir_name = f"{brand_code} - {artist} - {title}"
|
||||
mock_track_dir_path = f"/fake/path/to/{existing_track_dir_name}" # Mock path
|
||||
|
||||
# --- 2. Mock Core Components and External Interactions ---
|
||||
|
||||
# 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
|
||||
# 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
|
||||
mock_prep_result = {
|
||||
'artist': artist,
|
||||
'title': title,
|
||||
'track_output_dir': mock_track_dir_path,
|
||||
'lyrics_results': { # Include dummy lyrics results needed by finalise path
|
||||
'corrected_lyrics_text_filepath': f'{mock_track_dir_path}/{artist} - {title} (Lyrics Corrected).txt',
|
||||
'lrc_file': f'{mock_track_dir_path}/{artist} - {title} (Karaoke).lrc',
|
||||
'ass_file': f'{mock_track_dir_path}/{artist} - {title} (Karaoke).ass',
|
||||
},
|
||||
'input_audio_wav': f'{mock_track_dir_path}/{artist} - {title} (Original).wav', # Dummy path
|
||||
'base_name': f'{artist} - {title}',
|
||||
'input_media_path': f'{mock_track_dir_path}/{artist} - {title} (Original).wav',
|
||||
# Add other keys if KaraokeFinalise strictly requires them
|
||||
}
|
||||
prep_process_mock = mocker.patch.object(KaraokePrep, 'process', new_callable=AsyncMock, return_value=[mock_prep_result]) # Return list
|
||||
|
||||
# Mock FileHandler backup method - Use patch.object instead of spy
|
||||
# backup_spy = mocker.spy(FileHandler, \'backup_existing_outputs\')
|
||||
mock_backup = mocker.patch.object(FileHandler, 'backup_existing_outputs', return_value=f'{mock_track_dir_path}/{artist} - {title} (Original).wav')
|
||||
|
||||
# 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\',
|
||||
# new_callable=AsyncMock, # Make it async
|
||||
# return_value={
|
||||
# \'corrected_lyrics_text\': \'Edited lyrics line 1\\nEdited lyrics line 2\',
|
||||
# \'corrected_lyrics_text_filepath\': f\'{mock_track_dir_path}/{artist} - {title} (Lyrics Corrected).txt\',
|
||||
# \'lyrics_output_dir\': f\'{mock_track_dir_path}/lyrics\',
|
||||
# \'lrc_file\': f\'{mock_track_dir_path}/{artist} - {title} (Karaoke).lrc\',
|
||||
# \'ass_file\': f\'{mock_track_dir_path}/{artist} - {title} (Karaoke).ass\',
|
||||
# }
|
||||
# )
|
||||
|
||||
# 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')
|
||||
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 = {
|
||||
'artist': artist,
|
||||
'title': title,
|
||||
'video_with_vocals': f'{mock_track_dir_path}/{artist} - {title} (With Vocals).mkv',
|
||||
'video_with_instrumental': f'{mock_track_dir_path}/{artist} - {title} (Karaoke).mp4',
|
||||
'final_video': f'{mock_track_dir_path}/{artist} - {title} (Final Karaoke Lossless 4k).mp4',
|
||||
'final_video_mkv': f'{mock_track_dir_path}/{artist} - {title} (Final Karaoke Lossless 4k).mkv',
|
||||
'final_video_lossy': f'{mock_track_dir_path}/{artist} - {title} (Final Karaoke Lossy 4k).mp4',
|
||||
'final_video_720p': f'{mock_track_dir_path}/{artist} - {title} (Final Karaoke Lossy 720p).mp4',
|
||||
'final_karaoke_cdg_zip': f'{mock_track_dir_path}/{artist} - {title} (Final Karaoke CDG).zip',
|
||||
'final_karaoke_txt_zip': f'{mock_track_dir_path}/{artist} - {title} (Final Karaoke TXT).zip',
|
||||
'youtube_url': 'https://youtu.be/mock_replaced_id',
|
||||
'dropbox_url': 'https://fake.sharing.link/mock_edit_folder', # Keep for potential future use
|
||||
'brand_code': brand_code, # Important for edit mode
|
||||
'new_brand_code_dir_path': mock_track_dir_path, # In edit mode, dir path doesn't change
|
||||
'brand_code_dir_sharing_link': 'https://fake.sharing.link/mock_edit_folder'
|
||||
}
|
||||
finalise_process_mock = mocker.patch.object(KaraokeFinalise, 'process', return_value=mock_finalise_result)
|
||||
|
||||
# Mock necessary imports or high-level functions causing issues
|
||||
mocker.patch('importlib.metadata.version', return_value="0.0.0-mock") # Prevent email.parser error
|
||||
|
||||
# Mock file system interactions needed by the CLI/core logic *before* mocks take over
|
||||
mocker.patch('os.getcwd', return_value=mock_track_dir_path)
|
||||
mocker.patch('os.path.isdir', return_value=True) # Assume dirs exist
|
||||
mocker.patch('os.path.isfile', return_value=True) # Assume files exist (e.g., configs)
|
||||
mocker.patch('os.path.exists', return_value=True) # Assume paths exist
|
||||
mocker.patch('os.listdir', return_value=[f"{artist} - {title} (With Vocals).mkv"]) # Make find_with_vocals_file happy
|
||||
# Use mocker.mock_open to simulate reading empty bytes (enough for gettext magic number)
|
||||
mock_opener = mocker.mock_open(read_data=b'\x00\x00\x00\x00')
|
||||
mocker.patch('builtins.open', mock_opener)
|
||||
mocker.patch('io.open', mock_opener)
|
||||
mocker.patch('json.load', return_value={}) # Prevent reading JSON config
|
||||
mocker.patch('json.loads', return_value={"cdg": {}}) # Prevent decoding JSON string
|
||||
mocker.patch('json.dump', MagicMock()) # Prevent writing JSON
|
||||
|
||||
# Mock shutil operations
|
||||
mocker.patch('shutil.move', MagicMock())
|
||||
mocker.patch('shutil.copytree', MagicMock())
|
||||
mocker.patch('shutil.rmtree', MagicMock())
|
||||
mocker.patch('shutil.copy2', MagicMock())
|
||||
|
||||
# Mock os operations
|
||||
mocker.patch('os.makedirs', MagicMock())
|
||||
mocker.patch('os.remove', MagicMock())
|
||||
mocker.patch('os.rename', MagicMock())
|
||||
mocker.patch('os.system', MagicMock(return_value=0)) # Return success
|
||||
|
||||
# Mock external calls
|
||||
mocker.patch('subprocess.run', return_value=MagicMock(returncode=0, stdout="", stderr=""))
|
||||
mocker.patch('requests.post', MagicMock())
|
||||
mocker.patch('pyperclip.copy', MagicMock())
|
||||
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")
|
||||
|
||||
# Mock pydub
|
||||
mocker.patch('pydub.AudioSegment.from_file', return_value=MagicMock(duration_seconds=10)) # Need duration
|
||||
mocker.patch('pydub.audio_segment.mediainfo_json', return_value={"format": {"duration": "10.0"}})
|
||||
|
||||
# Mock lyrics review server
|
||||
# mocker.patch(\'lyrics_transcriber.review.server.ReviewServer.start\', MagicMock()) # REMOVED - Not needed with prep.process mocked
|
||||
|
||||
# Mock input
|
||||
mocker.patch('builtins.input', return_value="y") # Auto-confirm prompts if any slip through
|
||||
|
||||
# --- 3. Construct Args and Call async_main ---
|
||||
discord_webhook_url = "https://discord.com/api/webhooks/FAKE/EDIT_URL"
|
||||
rclone_destination = "googledrive:TestNomadKaraokeEdit"
|
||||
# Use mock paths for file arguments
|
||||
mock_style_params_path = "/fake/data/styles.json"
|
||||
mock_yt_secrets_path = "/fake/data/kgenclientsecret_edit.json"
|
||||
mock_yt_desc_path = "/fake/data/ytdesc_edit.txt"
|
||||
mock_email_template_path = "/fake/data/emailtemplate_edit.txt"
|
||||
mock_organised_dir = "/fake/organised"
|
||||
mock_public_share_dir = "/fake/public_share_edit"
|
||||
|
||||
test_argv = [
|
||||
"gen_cli.py",
|
||||
"--edit-lyrics",
|
||||
"--style_params_json", mock_style_params_path,
|
||||
"--enable_cdg", # Keep features enabled to test paths
|
||||
"--enable_txt",
|
||||
"--organised_dir", mock_organised_dir,
|
||||
"--organised_dir_rclone_root", f"andrewdropboxfull:organised", # Use simplified root
|
||||
"--public_share_dir", mock_public_share_dir,
|
||||
"--brand_prefix", brand_prefix,
|
||||
"--youtube_client_secrets_file", mock_yt_secrets_path,
|
||||
"--rclone_destination", rclone_destination,
|
||||
"--youtube_description_file", mock_yt_desc_path,
|
||||
"--discord_webhook_url", discord_webhook_url,
|
||||
"--email_template_file", mock_email_template_path,
|
||||
"-y", # Non-interactive
|
||||
]
|
||||
|
||||
mocker.patch.object(sys, 'argv', test_argv)
|
||||
|
||||
print("--- Calling async_main (edit-lyrics simplified test) ---")
|
||||
await async_main()
|
||||
print("--- async_main finished (edit-lyrics simplified test) ---")
|
||||
|
||||
# --- 4. Assertions ---
|
||||
# Verify KaraokePrep initialization and process call
|
||||
prep_init_spy.assert_called_once()
|
||||
_, prep_init_kwargs = prep_init_spy.call_args
|
||||
assert prep_init_kwargs.get('artist') == artist
|
||||
assert prep_init_kwargs.get('title') == title
|
||||
assert prep_init_kwargs.get('skip_separation') is True # Edit mode should skip separation
|
||||
assert prep_init_kwargs.get('create_track_subfolders') is False # Edit mode processes in place
|
||||
# Check that KaraokePrep.process was called (we mocked its return value)
|
||||
prep_process_mock.assert_called_once()
|
||||
|
||||
# Verify backup was called (important for edit mode)
|
||||
# The first argument to backup_existing_outputs is 'self' (the FileHandler instance)
|
||||
mock_backup.assert_called_once_with(mock_track_dir_path, artist, title)
|
||||
|
||||
# Verify lyrics transcription was called (important for edit mode)
|
||||
# mock_transcribe.assert_called_once() # REMOVED - Not called because KaraokePrep.process is mocked
|
||||
|
||||
# Verify KaraokeFinalise initialization and process call
|
||||
finalise_init_spy.assert_called_once()
|
||||
_, finalise_init_kwargs = finalise_init_spy.call_args
|
||||
# Assert only the kwargs that are actually passed to __init__ and relevant
|
||||
# assert finalise_init_kwargs.get(\'artist\') == artist # Not an init arg
|
||||
# assert finalise_init_kwargs.get(\'title\') == title # Not an init arg
|
||||
# assert finalise_init_kwargs.get(\'base_name\') == f\"{artist} - {title}\" # Not an init arg
|
||||
# assert finalise_init_kwargs.get(\'brand_code\') == brand_code # Not an init arg
|
||||
# assert finalise_init_kwargs.get(\'track_output_dir\') == mock_track_dir_path # Not an init arg
|
||||
assert finalise_init_kwargs.get('keep_brand_code') is True # Edit mode should keep brand code
|
||||
assert finalise_init_kwargs.get('non_interactive') is True
|
||||
|
||||
# Check that KaraokeFinalise.process was called with replace_existing=True
|
||||
finalise_process_mock.assert_called_once()
|
||||
finalise_call_args, finalise_call_kwargs = finalise_process_mock.call_args
|
||||
assert finalise_call_kwargs.get('replace_existing') is True # Crucial check for edit mode
|
||||
|
||||
# Optional: Verify specific external mocks if needed (e.g., YouTube upload called)
|
||||
# Example: Check if the mocked upload function was called within the finalise logic path
|
||||
# Need to mock the specific upload function called by finalise.process if not mocking process itself.
|
||||
# Since we mocked finalise.process, we can't assert calls *within* it easily.
|
||||
# If asserting internal calls is critical, mock *those* methods instead of the whole process method.
|
||||
|
||||
# For this simplified test, verifying the process calls with correct flags is sufficient.
|
||||
|
||||
# Remove all the previous complex code below this line if it existed.
|
||||
# The test above is self-contained.
|
||||
@@ -0,0 +1,98 @@
|
||||
"""
|
||||
Tests for the core components.
|
||||
"""
|
||||
|
||||
import unittest
|
||||
from unittest.mock import MagicMock, patch
|
||||
|
||||
from karaoke_gen.core import ProjectConfig, Track, KaraokeGenError
|
||||
|
||||
|
||||
class TestProjectConfig(unittest.TestCase):
|
||||
"""Test ProjectConfig class."""
|
||||
|
||||
def test_init_with_minimal_args(self):
|
||||
"""Test initialization with minimal arguments."""
|
||||
config = ProjectConfig()
|
||||
|
||||
# Check default values
|
||||
self.assertIsNone(config.artist)
|
||||
self.assertIsNone(config.title)
|
||||
self.assertIsNone(config.input_media)
|
||||
self.assertFalse(config.dry_run)
|
||||
self.assertEqual(config.output_dir, ".")
|
||||
|
||||
def test_init_with_all_args(self):
|
||||
"""Test initialization with all arguments."""
|
||||
logger = MagicMock()
|
||||
|
||||
config = ProjectConfig(
|
||||
artist="Test Artist",
|
||||
title="Test Title",
|
||||
input_media="test.mp3",
|
||||
dry_run=True,
|
||||
logger=logger,
|
||||
output_dir="/tmp",
|
||||
create_track_subfolders=True,
|
||||
)
|
||||
|
||||
# Check values
|
||||
self.assertEqual(config.artist, "Test Artist")
|
||||
self.assertEqual(config.title, "Test Title")
|
||||
self.assertEqual(config.input_media, "test.mp3")
|
||||
self.assertTrue(config.dry_run)
|
||||
self.assertEqual(config.logger, logger)
|
||||
self.assertEqual(config.output_dir, "/tmp")
|
||||
self.assertTrue(config.create_track_subfolders)
|
||||
|
||||
|
||||
class TestTrack(unittest.TestCase):
|
||||
"""Test Track class."""
|
||||
|
||||
def test_init_with_minimal_args(self):
|
||||
"""Test initialization with minimal arguments."""
|
||||
track = Track(artist="Test Artist", title="Test Title")
|
||||
|
||||
# Check values
|
||||
self.assertEqual(track.artist, "Test Artist")
|
||||
self.assertEqual(track.title, "Test Title")
|
||||
self.assertIsNone(track.input_media)
|
||||
|
||||
def test_init_with_all_args(self):
|
||||
"""Test initialization with all arguments."""
|
||||
track = Track(
|
||||
artist="Test Artist",
|
||||
title="Test Title",
|
||||
input_media="test.mp3",
|
||||
input_audio_wav="test.wav",
|
||||
input_still_image="test.jpg",
|
||||
lyrics="Test lyrics",
|
||||
)
|
||||
|
||||
# Check values
|
||||
self.assertEqual(track.artist, "Test Artist")
|
||||
self.assertEqual(track.title, "Test Title")
|
||||
self.assertEqual(track.input_media, "test.mp3")
|
||||
self.assertEqual(track.input_audio_wav, "test.wav")
|
||||
self.assertEqual(track.input_still_image, "test.jpg")
|
||||
self.assertEqual(track.lyrics, "Test lyrics")
|
||||
|
||||
|
||||
class TestKaraokeGenError(unittest.TestCase):
|
||||
"""Test KaraokeGenError class."""
|
||||
|
||||
def test_error_message(self):
|
||||
"""Test error message."""
|
||||
error = KaraokeGenError("Test error")
|
||||
self.assertEqual(str(error), "Test error")
|
||||
|
||||
def test_error_with_cause(self):
|
||||
"""Test error with cause."""
|
||||
cause = ValueError("Original error")
|
||||
error = KaraokeGenError("Test error", cause=cause)
|
||||
self.assertEqual(str(error), "Test error")
|
||||
self.assertEqual(error.__cause__, cause)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Executable
+103
@@ -0,0 +1,103 @@
|
||||
#! /usr/bin/env python3
|
||||
|
||||
import os
|
||||
import json
|
||||
import logging
|
||||
from karaoke_gen.karaoke_gen import KaraokePrep
|
||||
|
||||
# Set up logging
|
||||
logger = logging.getLogger(__name__)
|
||||
log_handler = logging.StreamHandler()
|
||||
log_formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
|
||||
log_handler.setFormatter(log_formatter)
|
||||
logger.addHandler(log_handler)
|
||||
logger.setLevel(logging.DEBUG)
|
||||
|
||||
|
||||
# Define the artist/title combinations
|
||||
def total_length(tuple):
|
||||
artist, title = tuple
|
||||
return len(artist) + len(title)
|
||||
|
||||
|
||||
with open("data/artist-titles.json", "r", encoding="utf-8") as f:
|
||||
all_combinations = json.load(f)
|
||||
|
||||
# Sort by length and get shortest and longest 20
|
||||
sorted_combinations = sorted(all_combinations, key=total_length)
|
||||
artist_title_combinations = sorted_combinations[:20] + sorted_combinations[-20:]
|
||||
|
||||
# Define the format dictionary with expanded configurations
|
||||
formats = [
|
||||
{
|
||||
"name": "nomadkaraoke",
|
||||
"style_params_json": "/Users/andrew/AB Dropbox/Andrew Beveridge/MediaUnsynced/Karaoke/NomadBranding/karaoke-prep-styles-nomad.json",
|
||||
},
|
||||
{
|
||||
"name": "vocalstar",
|
||||
"style_params_json": "/Users/andrew/AB Dropbox/Andrew Beveridge/MediaUnsynced/Karaoke/Tracks-NonPublished/VocalStar/Resources/karaoke-prep-styles-vocalstar.json",
|
||||
},
|
||||
{
|
||||
"name": "minimal",
|
||||
"style_params_json": None,
|
||||
},
|
||||
]
|
||||
|
||||
# Define other parameters
|
||||
base_output_dir = "outputs"
|
||||
os.makedirs(base_output_dir, exist_ok=True)
|
||||
|
||||
# Process each format
|
||||
for format in formats:
|
||||
# Create format-specific output directory
|
||||
format_output_dir = os.path.join(base_output_dir, format["name"])
|
||||
os.makedirs(format_output_dir, exist_ok=True)
|
||||
|
||||
style_params = None
|
||||
if format["style_params_json"]:
|
||||
with open(format["style_params_json"], "r") as f:
|
||||
style_params = json.loads(f.read())
|
||||
|
||||
# Instantiate KaraokePrep for this format
|
||||
kprep = KaraokePrep(
|
||||
log_level=logging.INFO,
|
||||
log_formatter=log_formatter,
|
||||
output_dir=format_output_dir,
|
||||
style_params=style_params,
|
||||
render_bounding_boxes=False,
|
||||
output_jpg=False,
|
||||
output_png=True,
|
||||
)
|
||||
|
||||
# Run the create_title_video and create_end_video functions for each combination
|
||||
for artist, title in artist_title_combinations:
|
||||
sanitized_artist = kprep.sanitize_filename(artist)
|
||||
sanitized_title = kprep.sanitize_filename(title)
|
||||
|
||||
# Generate title video
|
||||
title_image_filepath_noext = os.path.join(format_output_dir, f"{sanitized_artist}_{sanitized_title}_title")
|
||||
title_video_filepath = os.path.join(format_output_dir, f"{sanitized_artist}_{sanitized_title}_title.mov")
|
||||
|
||||
kprep.intro_video_duration = 0
|
||||
kprep.create_title_video(
|
||||
artist=artist,
|
||||
title=title,
|
||||
format=kprep.title_format,
|
||||
output_image_filepath_noext=title_image_filepath_noext,
|
||||
output_video_filepath=title_video_filepath,
|
||||
)
|
||||
logger.info(f"Created title video for {artist} - {title} using {format['name']} format")
|
||||
|
||||
# Generate end video
|
||||
end_image_filepath_noext = os.path.join(format_output_dir, f"{sanitized_artist}_{sanitized_title}_end")
|
||||
end_video_filepath = os.path.join(format_output_dir, f"{sanitized_artist}_{sanitized_title}_end.mov")
|
||||
|
||||
kprep.end_video_duration = 0
|
||||
kprep.create_end_video(
|
||||
artist=artist,
|
||||
title=title,
|
||||
format=kprep.end_format,
|
||||
output_image_filepath_noext=end_image_filepath_noext,
|
||||
output_video_filepath=end_video_filepath,
|
||||
)
|
||||
logger.info(f"Created end video for {artist} - {title} using {format['name']} format")
|
||||
@@ -1,884 +0,0 @@
|
||||
import os
|
||||
import pytest
|
||||
import tempfile
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import json
|
||||
from karaoke_prep.karaoke_prep import KaraokePrep
|
||||
from unittest.mock import MagicMock, call, patch, AsyncMock, ANY
|
||||
from karaoke_prep.utils.gen_cli import async_main
|
||||
import shlex
|
||||
import asyncio
|
||||
from googleapiclient.http import MediaFileUpload
|
||||
from karaoke_prep.karaoke_finalise.karaoke_finalise import KaraokeFinalise
|
||||
|
||||
# Register the asyncio marker
|
||||
pytest.mark.asyncio = pytest.mark.asyncio
|
||||
|
||||
# Set the default event loop policy to 'auto'
|
||||
pytest_configure = lambda config: config.addinivalue_line("markers", "asyncio: mark test as async")
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_karaoke_prep_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)
|
||||
input_file = os.path.join(temp_dir, "input.wav")
|
||||
# Use ffmpeg to generate a small WAV file with a sine wave
|
||||
subprocess.run(["ffmpeg", "-f", "lavfi", "-i", "sine=frequency=1000:duration=1", input_file], check=True)
|
||||
|
||||
# Instantiate KaraokePrep with the dummy input file
|
||||
kp = KaraokePrep(
|
||||
input_media=input_file,
|
||||
artist="Test Artist",
|
||||
title="Test Title",
|
||||
output_dir=temp_dir,
|
||||
skip_lyrics=True, # Skip lyrics processing for this test
|
||||
skip_separation=True, # Skip audio separation for this test
|
||||
dry_run=False,
|
||||
log_level="INFO"
|
||||
)
|
||||
|
||||
# Function to simulate file creation
|
||||
def create_dummy_files(output_image_filepath_noext, output_video_filepath, **kwargs):
|
||||
# Create empty files for PNG, JPG, and MOV
|
||||
for ext in ['.png', '.jpg']:
|
||||
try:
|
||||
# Ensure directory exists
|
||||
os.makedirs(os.path.dirname(f"{output_image_filepath_noext}{ext}"), exist_ok=True)
|
||||
with open(f"{output_image_filepath_noext}{ext}", 'w') as f:
|
||||
f.write('dummy') # Write something small
|
||||
except Exception as e:
|
||||
print(f"Error creating dummy file {output_image_filepath_noext}{ext}: {e}") # Debug print
|
||||
try:
|
||||
# Ensure directory exists
|
||||
os.makedirs(os.path.dirname(output_video_filepath), exist_ok=True)
|
||||
with open(output_video_filepath, 'w') as f:
|
||||
f.write('dummy') # Write something small
|
||||
except Exception as e:
|
||||
print(f"Error creating dummy file {output_video_filepath}: {e}") # Debug print
|
||||
|
||||
# Function to simulate WAV creation
|
||||
def create_dummy_wav(input_media_path, output_filename_no_extension):
|
||||
wav_path = f"{output_filename_no_extension} ({kp.extractor}).wav" # Construct expected path
|
||||
try:
|
||||
os.makedirs(os.path.dirname(wav_path), exist_ok=True)
|
||||
with open(wav_path, 'w') as f:
|
||||
f.write('dummy_wav') # Write something small
|
||||
return wav_path # Return the created path
|
||||
except Exception as e:
|
||||
print(f"Error creating dummy WAV file {wav_path}: {e}")
|
||||
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, \
|
||||
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, \
|
||||
patch.object(kp.file_handler, 'download_video') as mock_download, \
|
||||
patch.object(kp.file_handler, 'extract_still_image_from_video') as mock_extract_image, \
|
||||
patch.object(kp.file_handler, '_file_exists', return_value=False) as mock_file_exists, \
|
||||
patch.object(kp.lyrics_processor, 'transcribe_lyrics', AsyncMock(return_value={'corrected_lyrics_text': 'lyrics text', 'corrected_lyrics_text_filepath': 'lyrics.txt'})) as mock_transcribe, \
|
||||
patch.object(kp.audio_processor, 'process_audio_separation', AsyncMock(return_value={})) as mock_separate, \
|
||||
patch.object(kp.video_generator, 'create_title_video', side_effect=create_dummy_files) as mock_create_title, \
|
||||
patch.object(kp.video_generator, 'create_end_video', side_effect=create_dummy_files) as mock_create_end, \
|
||||
patch('os.system') as mock_os_system:
|
||||
|
||||
# Run the process
|
||||
results = await kp.process()
|
||||
|
||||
# Verify that the result is a list (even for a single track)
|
||||
assert isinstance(results, list)
|
||||
assert len(results) > 0
|
||||
|
||||
# Get the first track result
|
||||
track = results[0]
|
||||
assert isinstance(track, dict)
|
||||
assert "track_output_dir" in track
|
||||
assert "artist" in track
|
||||
assert "title" in track
|
||||
|
||||
# Verify mocks were called as expected
|
||||
mock_transcribe.assert_not_called()
|
||||
mock_separate.assert_not_called()
|
||||
mock_create_title.assert_called_once() # Check if video creation was called
|
||||
mock_create_end.assert_called_once() # Check if video creation was called
|
||||
|
||||
# Verify that the expected output files exist and have non-zero sizes
|
||||
expected_files = [
|
||||
os.path.join(track["track_output_dir"], f"{track['artist']} - {track['title']} (Title).mov"),
|
||||
os.path.join(track["track_output_dir"], f"{track['artist']} - {track['title']} (End).mov"),
|
||||
os.path.join(track["track_output_dir"], f"{track['artist']} - {track['title']} (Title).png"),
|
||||
os.path.join(track["track_output_dir"], f"{track['artist']} - {track['title']} (Title).jpg"),
|
||||
os.path.join(track["track_output_dir"], f"{track['artist']} - {track['title']} (End).png"),
|
||||
os.path.join(track["track_output_dir"], f"{track['artist']} - {track['title']} (End).jpg")
|
||||
]
|
||||
|
||||
for file_path in expected_files:
|
||||
assert os.path.exists(file_path), f"Expected file {file_path} does not exist."
|
||||
assert os.path.getsize(file_path) > 0, f"Expected file {file_path} is empty."
|
||||
|
||||
# Optional: Verify that the input audio WAV file was created
|
||||
input_wav = track.get("input_audio_wav")
|
||||
if input_wav:
|
||||
assert os.path.exists(input_wav), f"Input WAV file {input_wav} does not exist."
|
||||
assert os.path.getsize(input_wav) > 0, f"Input WAV file {input_wav} is empty."
|
||||
|
||||
# Optional: Verify that the separated audio files exist (if not skipped)
|
||||
if not kp.skip_separation:
|
||||
separated_audio = track.get("separated_audio", {})
|
||||
for category, files in separated_audio.items():
|
||||
if isinstance(files, dict):
|
||||
for file_path in files.values():
|
||||
if file_path:
|
||||
assert os.path.exists(file_path), f"Separated audio file {file_path} does not exist."
|
||||
assert os.path.getsize(file_path) > 0, f"Separated audio file {file_path} is empty."
|
||||
|
||||
# Optional: Verify that the lyrics file exists (if not skipped)
|
||||
if not kp.skip_lyrics:
|
||||
lyrics_file = track.get("lyrics")
|
||||
if lyrics_file:
|
||||
assert os.path.exists(lyrics_file), f"Lyrics file {lyrics_file} does not exist."
|
||||
assert os.path.getsize(lyrics_file) > 0, f"Lyrics file {lyrics_file} is empty."
|
||||
|
||||
# Clean up the temporary directory (optional, as it will be removed automatically)
|
||||
# shutil.rmtree(temp_dir)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@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."""
|
||||
|
||||
# --- 1. Setup Temporary Directories and Files ---
|
||||
data_dir = tmp_path / "data"
|
||||
data_dir.mkdir()
|
||||
# output_dir = tmp_path / "output" # KaraokePrep will create this based on args
|
||||
# output_dir.mkdir()
|
||||
organised_dir = tmp_path / "organised"
|
||||
organised_dir.mkdir()
|
||||
public_share_dir = tmp_path / "public_share"
|
||||
public_share_dir.mkdir()
|
||||
public_share_mp4_dir = public_share_dir / "MP4"
|
||||
public_share_mp4_dir.mkdir()
|
||||
public_share_720p_dir = public_share_dir / "MP4-720p"
|
||||
public_share_720p_dir.mkdir()
|
||||
public_share_cdg_dir = public_share_dir / "CDG"
|
||||
public_share_cdg_dir.mkdir()
|
||||
|
||||
# Copy input audio
|
||||
source_audio = "tests/data/waterloo10sec.flac"
|
||||
input_audio = data_dir / os.path.basename(source_audio)
|
||||
shutil.copy2(source_audio, input_audio)
|
||||
|
||||
# Copy real style params file instead of creating dummy
|
||||
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)
|
||||
|
||||
# Create dummy youtube client secrets file
|
||||
yt_secrets_path = data_dir / "kgenclientsecret.json"
|
||||
yt_secrets_content = {"installed": {"client_id": "dummy", "client_secret": "dummy"}}
|
||||
with open(yt_secrets_path, "w") as f:
|
||||
json.dump(yt_secrets_content, f)
|
||||
|
||||
# Create dummy youtube description file
|
||||
yt_desc_path = data_dir / "ytdesc.txt"
|
||||
with open(yt_desc_path, "w") as f:
|
||||
f.write("Test Description {artist} - {title}")
|
||||
|
||||
# Create dummy email template file
|
||||
email_template_path = data_dir / "emailtemplate.txt"
|
||||
with open(email_template_path, "w") as f:
|
||||
f.write("Subject: Test Email\n\nYT: {youtube_url}\nDB: {dropbox_url}")
|
||||
|
||||
# --- 2. Mock External Interactions ---
|
||||
# Mock YouTube API
|
||||
mock_youtube_service = MagicMock()
|
||||
mock_youtube_insert = MagicMock()
|
||||
mock_youtube_insert.execute.return_value = {'id': 'mock_video_id'}
|
||||
mock_youtube_service.videos().insert.return_value = mock_youtube_insert
|
||||
mock_youtube_service.thumbnails().set().execute.return_value = {}
|
||||
mock_build = mocker.patch('googleapiclient.discovery.build', return_value=mock_youtube_service)
|
||||
|
||||
# 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)
|
||||
|
||||
# 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')
|
||||
# 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
|
||||
instance.youtube_video_id = 'manual_mock_video_id'
|
||||
instance.youtube_url = f"https://youtu.be/manual_mock_video_id"
|
||||
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)
|
||||
|
||||
# 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)
|
||||
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
|
||||
|
||||
# Mock Discord requests
|
||||
mock_requests_post = mocker.patch('requests.post')
|
||||
mock_requests_post.return_value.raise_for_status.return_value = None
|
||||
|
||||
# Store original functions needed for mocks
|
||||
original_os_system = os.system
|
||||
original_subprocess_run = subprocess.run
|
||||
original_os_chdir = os.chdir
|
||||
original_os_getcwd = os.getcwd
|
||||
original_os_listdir = os.listdir
|
||||
original_os_rename = os.rename
|
||||
|
||||
# Mock os.system and subprocess.run for external calls (Rclone, ffmpeg etc)
|
||||
mock_os_system = mocker.patch('os.system')
|
||||
mock_subprocess_run = mocker.patch('subprocess.run')
|
||||
def rclone_side_effect(*args, **kwargs):
|
||||
# args[0] is the command (either string for os.system or list for subprocess.run)
|
||||
cmd_arg = args[0]
|
||||
cmd_str = cmd_arg if isinstance(cmd_arg, str) else " ".join(map(shlex.quote, cmd_arg))
|
||||
|
||||
# --- Commands to execute with original subprocess ---
|
||||
execute_commands = ["ffmpeg", "ffprobe", "uname"]
|
||||
should_execute = False
|
||||
if isinstance(cmd_arg, list) and cmd_arg and cmd_arg[0] in execute_commands:
|
||||
should_execute = True
|
||||
elif isinstance(cmd_arg, str) and any(cmd in cmd_arg for cmd in execute_commands):
|
||||
# Be a bit careful with string matching for execute commands
|
||||
# Only execute if it clearly starts with ffmpeg etc.
|
||||
# This covers the os.system call for ffmpeg
|
||||
if cmd_arg.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):
|
||||
print(f"SIDE_EFFECT: Simulating ffmpeg WAV conversion instead of executing: {cmd_str}")
|
||||
# Extract the output WAV path
|
||||
output_wav_path = None
|
||||
for i, arg in enumerate(cmd_arg):
|
||||
if arg.endswith(".wav") and i > 0 and cmd_arg[i-1] != "-i":
|
||||
output_wav_path = arg
|
||||
break
|
||||
|
||||
if output_wav_path:
|
||||
# Create the output directory if it doesn't exist
|
||||
os.makedirs(os.path.dirname(output_wav_path), exist_ok=True)
|
||||
# Create a dummy WAV file with minimal header (44 bytes, 8000Hz, mono, PCM)
|
||||
with open(output_wav_path, 'wb') as f:
|
||||
# Simple WAV header + minimal audio data
|
||||
f.write(b'RIFF\x24\x00\x00\x00WAVEfmt \x10\x00\x00\x00\x01\x00\x01\x00@\x1f\x00\x00@\x1f\x00\x00\x01\x00\x08\x00data\x00\x00\x00\x00')
|
||||
# Add some silence (1 second at 8000Hz)
|
||||
f.write(b'\x80' * 8000)
|
||||
print(f"SIDE_EFFECT: Created dummy WAV file at {output_wav_path}")
|
||||
return subprocess.CompletedProcess(args=cmd_arg, returncode=0, stdout="", stderr="")
|
||||
|
||||
# For other ffmpeg commands, or if we couldn't extract the WAV path, proceed to normal execution
|
||||
if should_execute:
|
||||
print(f"SIDE_EFFECT: Executing original: {cmd_str}")
|
||||
# Pass original args and kwargs to the original function
|
||||
# Use shell=True only if the original command was a string (likely from os.system)
|
||||
use_shell = isinstance(cmd_arg, str)
|
||||
result = None
|
||||
try:
|
||||
# Use original_subprocess_run for consistency, handling shell arg
|
||||
run_kwargs = kwargs.copy() # Copy kwargs to avoid modifying original
|
||||
|
||||
# Remove our custom flag that subprocess.run doesn't understand
|
||||
if '_os_system_call' in run_kwargs:
|
||||
del run_kwargs['_os_system_call']
|
||||
|
||||
# Determine if output should be captured based on original kwargs or if it's ffmpeg/ffprobe
|
||||
should_capture = False
|
||||
if isinstance(cmd_arg, list) and cmd_arg[0] in ["ffmpeg", "ffprobe"]:
|
||||
# Check if the original call already requested capture
|
||||
if run_kwargs.get('stdout') == subprocess.PIPE or run_kwargs.get('stderr') == subprocess.PIPE or run_kwargs.get('capture_output'):
|
||||
should_capture = True # Original call wants capture, let it happen
|
||||
# Ensure we don't add capture_output=True if stdout/stderr are set
|
||||
run_kwargs.pop('capture_output', None)
|
||||
else:
|
||||
# Original call didn't request capture, but we want to for logging
|
||||
should_capture = True
|
||||
run_kwargs['capture_output'] = True
|
||||
run_kwargs['text'] = True # Assume text if we're capturing
|
||||
|
||||
# Adjust run_kwargs based on capture decision
|
||||
if should_capture and 'capture_output' not in run_kwargs:
|
||||
# If original used stdout/stderr=PIPE, we need text=True to decode
|
||||
if run_kwargs.get('stdout') == subprocess.PIPE or run_kwargs.get('stderr') == subprocess.PIPE:
|
||||
run_kwargs['text'] = True
|
||||
|
||||
# Get the mocked CWD for ffmpeg/ffprobe execution
|
||||
current_mocked_dir = mock_current_dir_state()
|
||||
print(f"SIDE_EFFECT: Executing {cmd_arg[0]} in mocked CWD: {current_mocked_dir}")
|
||||
|
||||
# Call the original subprocess run within the mocked CWD
|
||||
result = original_subprocess_run(*args, shell=use_shell, cwd=current_mocked_dir, **run_kwargs)
|
||||
|
||||
# Log results if captured
|
||||
if should_capture and hasattr(result, 'returncode'): # Check if it's a CompletedProcess
|
||||
is_ffmpeg_or_probe = isinstance(cmd_arg, list) and cmd_arg[0] in ["ffmpeg", "ffprobe"]
|
||||
|
||||
print(f"SIDE_EFFECT: Original {cmd_arg[0]} command finished. Return Code: {result.returncode}")
|
||||
|
||||
# Print full ffmpeg/ffprobe args for debugging
|
||||
if is_ffmpeg_or_probe:
|
||||
print(f"SIDE_EFFECT: Full {cmd_arg[0]} Args: {cmd_arg}")
|
||||
|
||||
# Print stdout/stderr for ffmpeg/ffprobe even on success for detailed debugging
|
||||
if is_ffmpeg_or_probe and result.stdout:
|
||||
print(f"SIDE_EFFECT: {cmd_arg[0]} stdout (first 500 chars):\n{result.stdout[:500]}...")
|
||||
if result.stderr: # Always print stderr if it exists
|
||||
print(f"SIDE_EFFECT: {cmd_arg[0]} stderr (first 500 chars):\n{result.stderr[:500]}...")
|
||||
elif result.returncode == 0 and not is_ffmpeg_or_probe:
|
||||
print(f"SIDE_EFFECT: Original {cmd_arg[0]} executed successfully (No stderr).")
|
||||
|
||||
return result
|
||||
|
||||
except Exception as e:
|
||||
print(f"SIDE_EFFECT: Error executing original command '{cmd_str}': {e}")
|
||||
# Log traceback for unexpected errors during subprocess execution
|
||||
import traceback
|
||||
print(traceback.format_exc())
|
||||
# Reraise or return an error code/object depending on context
|
||||
if isinstance(cmd_arg, str):
|
||||
return 1
|
||||
else: # For subprocess.run mocks
|
||||
return subprocess.CompletedProcess(args=cmd_arg if isinstance(cmd_arg, list) else [cmd_arg], returncode=1, stderr=str(e))
|
||||
|
||||
# --- Rclone commands to mock ---
|
||||
# Rclone link (string from os.system OR subprocess.run with shell=True)
|
||||
if isinstance(cmd_arg, str) and cmd_arg.startswith('rclone link'):
|
||||
print(f"SIDE_EFFECT: Mocking rclone link (string cmd): {cmd_str}")
|
||||
# Return CompletedProcess even for string command if subprocess.run was likely used
|
||||
# Check if original call used subprocess.run (we can guess based on kwargs)
|
||||
is_subprocess_run = not kwargs.get('_os_system_call', False) # Add a flag or check args
|
||||
if is_subprocess_run:
|
||||
return subprocess.CompletedProcess(args=cmd_arg, returncode=0, stdout="https://fake.sharing.link/mock_folder", stderr="")
|
||||
else: # Assume os.system call
|
||||
return 0 # Simulate success code
|
||||
|
||||
# Rclone link (list from subprocess.run without shell=True)
|
||||
elif isinstance(cmd_arg, list) and cmd_arg[0:2] == ['rclone', 'link']:
|
||||
print(f"SIDE_EFFECT: Mocking rclone link (list cmd): {cmd_str}")
|
||||
return subprocess.CompletedProcess(args=cmd_arg, returncode=0, stdout="https://fake.sharing.link/mock_folder", stderr="")
|
||||
|
||||
# Rclone sync (string for os.system OR subprocess.run with shell=True)
|
||||
elif isinstance(cmd_arg, str) and cmd_arg.startswith('rclone sync'):
|
||||
print(f"SIDE_EFFECT: Mocking rclone sync (string cmd): {cmd_str}")
|
||||
is_subprocess_run = not kwargs.get('_os_system_call', False)
|
||||
if is_subprocess_run:
|
||||
return subprocess.CompletedProcess(args=cmd_arg, returncode=0, stdout="", stderr="")
|
||||
else: # Assume os.system call
|
||||
return 0 # Simulate success code
|
||||
|
||||
# Rclone sync (list for subprocess.run without shell=True)
|
||||
elif isinstance(cmd_arg, list) and cmd_arg[0:2] == ['rclone', 'sync']:
|
||||
print(f"SIDE_EFFECT: Mocking rclone sync (list cmd): {cmd_str}")
|
||||
return subprocess.CompletedProcess(args=cmd_arg, returncode=0, stdout="", stderr="")
|
||||
|
||||
# --- Default mock behavior for other commands (like 'open -a Audacity') ---
|
||||
print(f"SIDE_EFFECT: Default mock return for unhandled command: {cmd_str}")
|
||||
if isinstance(cmd_arg, list): # Likely from subprocess.run
|
||||
# Check if check=True was passed, raise if so, otherwise return success
|
||||
if kwargs.get('check'):
|
||||
raise subprocess.CalledProcessError(returncode=1, cmd=cmd_arg, stderr="Mocked process failed check")
|
||||
return subprocess.CompletedProcess(args=cmd_arg, returncode=0, stdout="", stderr="")
|
||||
else: # Likely from os.system
|
||||
return 0 # Default success code
|
||||
|
||||
# We need to differentiate calls to the side effect from os.system vs subprocess.run
|
||||
# A simple way is to wrap the side effect
|
||||
def os_system_wrapper(*args, **kwargs):
|
||||
# Create a copy of kwargs to avoid modifying the original
|
||||
kwargs_copy = kwargs.copy()
|
||||
kwargs_copy['_os_system_call'] = True
|
||||
return rclone_side_effect(*args, **kwargs_copy)
|
||||
|
||||
def subprocess_run_wrapper(*args, **kwargs):
|
||||
# Create a copy of kwargs to avoid modifying the original
|
||||
kwargs_copy = kwargs.copy()
|
||||
kwargs_copy['_os_system_call'] = False
|
||||
return rclone_side_effect(*args, **kwargs_copy)
|
||||
|
||||
mock_os_system.side_effect = os_system_wrapper
|
||||
mock_subprocess_run.side_effect = subprocess_run_wrapper
|
||||
|
||||
# Mock pyperclip
|
||||
mock_pyperclip = mocker.patch('pyperclip.copy')
|
||||
|
||||
# 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"
|
||||
base_name = f"{artist} - {title}"
|
||||
|
||||
# Create a simple mock for MediaFileUpload since we're bypassing the upload method
|
||||
mock_media_file_upload = MagicMock()
|
||||
mock_media_file_upload.filename.return_value = str(final_track_output_dir / f"{base_name} (Final Karaoke Lossless 4k).mkv")
|
||||
mocker.patch('googleapiclient.http.MediaFileUpload', return_value=mock_media_file_upload)
|
||||
|
||||
# Use a separate mock object to hold the mocked current directory state
|
||||
# Initialize it with the actual starting CWD
|
||||
mock_current_dir_state = mocker.Mock(return_value=original_os_getcwd())
|
||||
|
||||
def chdir_side_effect(path):
|
||||
abs_path = os.path.abspath(path) # Ensure consistent path format
|
||||
print(f"MOCK os.chdir: Setting mocked cwd state to: {abs_path}")
|
||||
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()
|
||||
# Resolve src relative to the *mocked* CWD to get the actual source path
|
||||
# This assumes the file was created in the mocked CWD
|
||||
# Resolve src relative to mocked CWD if it's not absolute
|
||||
actual_src_path = src if os.path.isabs(src) else os.path.abspath(os.path.join(current_mocked_dir, src))
|
||||
# Resolve dst relative to mocked CWD if it's not absolute
|
||||
actual_dst_path = dst if os.path.isabs(dst) else os.path.abspath(os.path.join(current_mocked_dir, dst))
|
||||
|
||||
print(f"MOCK os.rename: Called with src='{src}', dst='{dst}'. Mocked CWD='{current_mocked_dir}'")
|
||||
print(f"MOCK os.rename: Resolved actual paths: src='{actual_src_path}', dst='{actual_dst_path}'.")
|
||||
|
||||
try:
|
||||
# Check if source file actually exists before attempting rename
|
||||
# Note: This check uses the *real* filesystem
|
||||
if os.path.exists(actual_src_path):
|
||||
print(f"MOCK os.rename: Source file '{actual_src_path}' exists. Attempting rename...")
|
||||
# Ensure the destination directory exists (e.g., the 'stems' dir)
|
||||
os.makedirs(os.path.dirname(actual_dst_path), exist_ok=True)
|
||||
original_os_rename(actual_src_path, actual_dst_path)
|
||||
print(f"MOCK os.rename: Actual rename successful.")
|
||||
else:
|
||||
# This can happen if the file creation step failed or was skipped.
|
||||
print(f"MOCK os.rename: Source file '{actual_src_path}' does NOT exist. Skipping actual rename.")
|
||||
# In a test, if the file *should* exist, this indicates a problem earlier
|
||||
# or a flaw in the mocking logic for where files are created.
|
||||
|
||||
except Exception as e:
|
||||
print(f"MOCK os.rename: Actual rename failed for src='{actual_src_path}', dst='{actual_dst_path}': {e}")
|
||||
# Optionally re-raise if the rename failure should fail the test
|
||||
# raise e
|
||||
|
||||
return None
|
||||
|
||||
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)
|
||||
mocker.patch('os.rename', side_effect=rename_side_effect)
|
||||
|
||||
# Mock os.path.isfile to use the mocked CWD
|
||||
original_os_path_isfile = os.path.isfile
|
||||
def isfile_side_effect(path):
|
||||
current_mocked_dir = mock_current_dir_state()
|
||||
# Resolve path relative to mocked CWD if it's not absolute
|
||||
abs_path_to_check = path if os.path.isabs(path) else os.path.abspath(os.path.join(current_mocked_dir, path))
|
||||
print(f"MOCK os.path.isfile: Checking path='{path}'. Mocked CWD='{current_mocked_dir}'. Resolved='{abs_path_to_check}'")
|
||||
# Call the *original* isfile on the resolved absolute path in the temp FS
|
||||
exists = original_os_path_isfile(abs_path_to_check)
|
||||
print(f"MOCK os.path.isfile: Original check returned: {exists}")
|
||||
return exists
|
||||
mocker.patch('os.path.isfile', side_effect=isfile_side_effect)
|
||||
|
||||
# Mock os.path.exists to use the mocked CWD
|
||||
original_os_path_exists = os.path.exists
|
||||
def exists_side_effect(path):
|
||||
current_mocked_dir = mock_current_dir_state()
|
||||
# Resolve path relative to mocked CWD if it's not absolute
|
||||
abs_path_to_check = path if os.path.isabs(path) else os.path.abspath(os.path.join(current_mocked_dir, path))
|
||||
print(f"MOCK os.path.exists: Checking path='{path}'. Mocked CWD='{current_mocked_dir}'. Resolved='{abs_path_to_check}'")
|
||||
# Call the *original* exists on the resolved absolute path in the temp FS
|
||||
exists = original_os_path_exists(abs_path_to_check)
|
||||
print(f"MOCK os.path.exists: Original check returned: {exists}")
|
||||
return exists
|
||||
mocker.patch('os.path.exists', side_effect=exists_side_effect)
|
||||
|
||||
# Mock builtins.open to use the mocked CWD
|
||||
original_builtin_open = open
|
||||
def open_side_effect(file, mode='r', *args, **kwargs):
|
||||
# Check if 'file' is an integer (file descriptor)
|
||||
if isinstance(file, int):
|
||||
print(f"MOCK builtins/io.open: Received integer FD={file}. Calling original open.")
|
||||
return original_builtin_open(file, mode, *args, **kwargs)
|
||||
|
||||
# If it's not an int, assume it's a path and proceed with path resolution
|
||||
current_mocked_dir = mock_current_dir_state()
|
||||
# Resolve file path relative to mocked CWD if it's not absolute
|
||||
path_to_open = file if os.path.isabs(file) else os.path.abspath(os.path.join(current_mocked_dir, file))
|
||||
print(f"MOCK builtins/io.open: Requested path='{file}', Mode='{mode}'. Mocked CWD='{current_mocked_dir}'. Resolved='{path_to_open}'")
|
||||
# Call the *original* open on the resolved absolute path in the temp FS
|
||||
try:
|
||||
# Ensure the directory exists if opening for writing
|
||||
if 'w' in mode or 'a' in mode or 'x' in mode:
|
||||
os.makedirs(os.path.dirname(path_to_open), exist_ok=True)
|
||||
return original_builtin_open(path_to_open, mode, *args, **kwargs)
|
||||
except FileNotFoundError as e:
|
||||
print(f"MOCK builtins.open: Original open FAILED for path '{path_to_open}': {e}")
|
||||
# Re-raise the exception so the calling code sees it
|
||||
raise e
|
||||
except Exception as e:
|
||||
print(f"MOCK builtins.open: Original open FAILED unexpectedly for path '{path_to_open}': {e}")
|
||||
raise e
|
||||
mocker.patch('builtins.open', side_effect=open_side_effect)
|
||||
# Also mock io.open as zipfile might use it directly
|
||||
mocker.patch('io.open', side_effect=open_side_effect)
|
||||
|
||||
# Mock os.stat to use the mocked CWD
|
||||
original_os_stat = os.stat
|
||||
def stat_side_effect(path, *args, **kwargs):
|
||||
current_mocked_dir = mock_current_dir_state()
|
||||
# Resolve path relative to mocked CWD if it's not absolute
|
||||
path_to_stat = path if os.path.isabs(path) else os.path.abspath(os.path.join(current_mocked_dir, path))
|
||||
print(f"MOCK os.stat: Requested path='{path}'. Mocked CWD='{current_mocked_dir}'. Resolved='{path_to_stat}'")
|
||||
# Call the *original* stat on the resolved absolute path in the temp FS
|
||||
try:
|
||||
return original_os_stat(path_to_stat, *args, **kwargs)
|
||||
except FileNotFoundError as e:
|
||||
print(f"MOCK os.stat: Original stat FAILED for path '{path_to_stat}': {e}")
|
||||
raise e # Re-raise the exception
|
||||
except Exception as e:
|
||||
print(f"MOCK os.stat: Original stat FAILED unexpectedly for path '{path_to_stat}': {e}")
|
||||
raise e
|
||||
mocker.patch('os.stat', side_effect=stat_side_effect)
|
||||
|
||||
# Mock os.remove to use the mocked CWD
|
||||
original_os_remove = os.remove
|
||||
def remove_side_effect(path):
|
||||
current_mocked_dir = mock_current_dir_state()
|
||||
# Resolve path relative to mocked CWD if it's not absolute
|
||||
path_to_remove = path if os.path.isabs(path) else os.path.abspath(os.path.join(current_mocked_dir, path))
|
||||
print(f"MOCK os.remove: Requested path='{path}'. Mocked CWD='{current_mocked_dir}'. Resolved='{path_to_remove}'")
|
||||
# Call the *original* remove on the resolved absolute path in the temp FS
|
||||
try:
|
||||
return original_os_remove(path_to_remove)
|
||||
except FileNotFoundError as e:
|
||||
print(f"MOCK os.remove: Original remove FAILED for path '{path_to_remove}': {e}")
|
||||
raise e # Re-raise the exception
|
||||
except Exception as e:
|
||||
print(f"MOCK os.remove: Original remove FAILED unexpectedly for path '{path_to_remove}': {e}")
|
||||
raise e
|
||||
mocker.patch('os.remove', side_effect=remove_side_effect)
|
||||
|
||||
# Mock ReviewServer.start to return the correction_result stored on the instance
|
||||
def mock_start_return_self_correction_result(mock_instance):
|
||||
print("MOCK ReviewServer.start: Bypassing UI, returning instance's correction_result.")
|
||||
# Assuming the ReviewServer instance stores the result in an attribute like 'correction_result'
|
||||
# We access it via the 'mock_instance' passed to the side_effect
|
||||
# The actual attribute name might differ, adjust if needed based on ReviewServer implementation
|
||||
return mock_instance.correction_result # Access the attribute on the mocked instance
|
||||
|
||||
# Patch the 'start' method where ReviewServer is defined
|
||||
mocker.patch(
|
||||
'lyrics_transcriber.review.server.ReviewServer.start',
|
||||
side_effect=mock_start_return_self_correction_result,
|
||||
autospec=True
|
||||
)
|
||||
|
||||
# Mock builtins.input to handle unexpected prompts
|
||||
def mock_input_side_effect(prompt=""):
|
||||
print(f"MOCK input: Received prompt: '{prompt}'")
|
||||
if "Enter the manually uploaded YouTube video ID:" in prompt:
|
||||
print("MOCK input: Returning dummy YouTube ID.")
|
||||
return "manual_mock_video_id"
|
||||
# Handle other potential prompts if necessary, or raise error
|
||||
print(f"MOCK input: WARNING - Unexpected prompt received!")
|
||||
return "unexpected_input_response" # Or raise an exception
|
||||
mocker.patch('builtins.input', side_effect=mock_input_side_effect)
|
||||
|
||||
# --- 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"
|
||||
|
||||
# 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,
|
||||
]
|
||||
|
||||
# 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 ---")
|
||||
|
||||
# --- 4. Assert Local File Outputs ---
|
||||
final_branded_dir_name = f"{expected_brand_code} - {artist} - {title}"
|
||||
final_branded_dir_path = organised_dir / final_branded_dir_name
|
||||
base_name = f"{artist} - {title}"
|
||||
final_base_name = f"{expected_brand_code} - {base_name}"
|
||||
|
||||
assert final_branded_dir_path.is_dir(), f"Expected branded directory not found: {final_branded_dir_path}"
|
||||
|
||||
# Check files in the final branded directory
|
||||
expected_files_in_branded_dir = [
|
||||
f"{base_name} (Final Karaoke Lossless 4k).mp4",
|
||||
f"{base_name} (Final Karaoke Lossless 4k).mkv",
|
||||
f"{base_name} (Final Karaoke Lossy 4k).mp4",
|
||||
f"{base_name} (Final Karaoke Lossy 720p).mp4",
|
||||
f"{base_name} (Final Karaoke CDG).zip",
|
||||
f"{base_name} (Final Karaoke TXT).zip",
|
||||
f"{base_name} (Karaoke).mp3", # Extracted from zip
|
||||
f"{base_name} (Karaoke).cdg", # Extracted from zip
|
||||
f"{base_name} (Karaoke).txt", # Created for zip
|
||||
]
|
||||
for filename in expected_files_in_branded_dir:
|
||||
filepath = final_branded_dir_path / filename
|
||||
assert filepath.is_file(), f"Expected file not found in branded dir: {filepath}"
|
||||
assert filepath.stat().st_size > 0, f"File is empty: {filepath}"
|
||||
|
||||
# Check files copied to public share
|
||||
expected_public_mp4 = public_share_mp4_dir / f"{final_base_name}.mp4"
|
||||
expected_public_720p = public_share_720p_dir / f"{final_base_name}.mp4"
|
||||
expected_public_cdg = public_share_cdg_dir / f"{final_base_name}.zip"
|
||||
|
||||
assert expected_public_mp4.is_file(), f"Expected file not found in public share MP4: {expected_public_mp4}"
|
||||
assert expected_public_mp4.stat().st_size > 0
|
||||
assert expected_public_720p.is_file(), f"Expected file not found in public share 720p: {expected_public_720p}"
|
||||
assert expected_public_720p.stat().st_size > 0
|
||||
assert expected_public_cdg.is_file(), f"Expected file not found in public share CDG: {expected_public_cdg}"
|
||||
assert expected_public_cdg.stat().st_size > 0
|
||||
|
||||
# --- 5. Assert Mock Calls ---
|
||||
# YouTube Upload - we're checking that upload_final_mp4_to_youtube_with_title_thumbnail was called
|
||||
assert mock_upload.called
|
||||
assert mock_requests_post.call_args.kwargs['json']['content'].find('manual_mock_video_id') != -1
|
||||
|
||||
# Discord Notification
|
||||
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"
|
||||
|
||||
# Debug all os.system calls
|
||||
print("\n--- Debug: ALL mock_os_system calls ---")
|
||||
for i, call_args in enumerate(mock_os_system.call_args_list):
|
||||
print(f"Call {i}: {call_args[0][0]}")
|
||||
|
||||
# Look specifically at the rclone mock side effect in the code
|
||||
print("\n--- Important: How the mock captures rclone calls ---")
|
||||
print("The mock captures exact strings for os.system calls.")
|
||||
|
||||
# Print all os.system calls for debugging
|
||||
print("\n--- ALL mock_os_system.call_args_list calls ---")
|
||||
all_calls = []
|
||||
for i, call_args in enumerate(mock_os_system.call_args_list):
|
||||
command = call_args[0][0]
|
||||
all_calls.append(command)
|
||||
print(f"Call {i}: '{command}'")
|
||||
|
||||
# Extract the command from the finalise.py implementation for debugging
|
||||
expected_rclone_link_prefix = "rclone link"
|
||||
organised_dir_folder = "andrewdropboxfull:organised/NOMAD-0001 - ABBA - Waterloo"
|
||||
|
||||
# Also look for the command in subprocess_run calls (used by the finalise.py implementation)
|
||||
print("\n--- ALL mock_subprocess_run.call_args_list calls ---")
|
||||
subprocess_all_calls = []
|
||||
for i, call_args in enumerate(mock_subprocess_run.call_args_list):
|
||||
if call_args[0]: # Check if there are positional args
|
||||
command = call_args[0][0]
|
||||
subprocess_all_calls.append(command)
|
||||
print(f"Call {i}: '{command}'")
|
||||
|
||||
# Check for rclone link command in both os.system and subprocess.run calls
|
||||
all_system_commands = all_calls + subprocess_all_calls
|
||||
|
||||
# Look for rclone link in all calls
|
||||
found_rclone_link = False
|
||||
matching_command = None
|
||||
|
||||
for command in all_system_commands:
|
||||
if isinstance(command, str) and expected_rclone_link_prefix in command and organised_dir_folder in command:
|
||||
found_rclone_link = True
|
||||
matching_command = command
|
||||
print(f"\nSUCCESS: Found matching command: '{command}'")
|
||||
break
|
||||
elif isinstance(command, list) and len(command) >= 3 and command[0] == "rclone" and command[1] == "link" and organised_dir_folder in " ".join(command):
|
||||
found_rclone_link = True
|
||||
matching_command = command
|
||||
print(f"\nSUCCESS: Found matching command (list): {command}")
|
||||
break
|
||||
|
||||
if not found_rclone_link:
|
||||
# Try to find partial matches for better error messages
|
||||
print("\nSearching for partial matches...")
|
||||
|
||||
# For string commands
|
||||
rclone_matches = [cmd for cmd in all_system_commands if isinstance(cmd, str) and expected_rclone_link_prefix in cmd]
|
||||
if rclone_matches:
|
||||
print("\nFound commands with 'rclone link' but missing correct path:")
|
||||
for cmd in rclone_matches:
|
||||
print(f"- '{cmd}'")
|
||||
else:
|
||||
print("\nNo string commands found containing 'rclone link'")
|
||||
|
||||
# For list commands
|
||||
rclone_list_matches = [cmd for cmd in all_system_commands if isinstance(cmd, list) and len(cmd) >= 2 and cmd[0] == "rclone" and cmd[1] == "link"]
|
||||
if rclone_list_matches:
|
||||
print("\nFound list commands with 'rclone link' but missing correct path:")
|
||||
for cmd in rclone_list_matches:
|
||||
print(f"- {cmd}")
|
||||
|
||||
# Check for the path fragment
|
||||
path_matches = [cmd for cmd in all_system_commands if isinstance(cmd, str) and organised_dir_folder in cmd]
|
||||
if path_matches:
|
||||
print("\nFound commands with the correct path but not 'rclone link':")
|
||||
for cmd in path_matches:
|
||||
print(f"- '{cmd}'")
|
||||
|
||||
# Final assertion with clear error message
|
||||
# Check if the command was logged in the output for debugging
|
||||
log_lines = [line for line in mock_os_system.mock_calls if "rclone link" in str(line)]
|
||||
if log_lines:
|
||||
print("\nFound logged rclone link commands in mock calls:")
|
||||
for line in log_lines:
|
||||
print(f"- {line}")
|
||||
|
||||
error_message = f"No command found containing both '{expected_rclone_link_prefix}' and '{organised_dir_folder}'"
|
||||
print(f"\nASSERTION ERROR: {error_message}")
|
||||
assert False, error_message
|
||||
|
||||
# Gmail Draft
|
||||
mock_youtube_service.users().drafts().create.assert_called_once()
|
||||
draft_args, draft_kwargs = mock_youtube_service.users().drafts().create.call_args
|
||||
assert draft_kwargs['userId'] == 'me'
|
||||
|
||||
# Pyperclip
|
||||
# Check if it was called at least once (exact calls can be tricky with multiple potential copies)
|
||||
assert mock_pyperclip.call_count >= 1
|
||||
@@ -0,0 +1,174 @@
|
||||
"""
|
||||
Tests for the utility functions.
|
||||
"""
|
||||
|
||||
import os
|
||||
import tempfile
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
|
||||
from karaoke_gen.utils import (
|
||||
# File utilities
|
||||
sanitize_filename,
|
||||
ensure_directory_exists,
|
||||
file_exists,
|
||||
|
||||
# Path utilities
|
||||
normalize_path,
|
||||
join_paths,
|
||||
get_absolute_path,
|
||||
get_relative_path,
|
||||
get_filename,
|
||||
get_filename_without_extension,
|
||||
get_file_extension,
|
||||
|
||||
# String utilities
|
||||
slugify,
|
||||
truncate_string,
|
||||
extract_artist_and_title,
|
||||
format_duration,
|
||||
format_filesize,
|
||||
)
|
||||
|
||||
|
||||
class TestFileUtils(unittest.TestCase):
|
||||
"""Test file utility functions."""
|
||||
|
||||
def test_sanitize_filename(self):
|
||||
"""Test sanitize_filename function."""
|
||||
# Test with invalid characters
|
||||
self.assertEqual(sanitize_filename("file/with\\invalid:chars"), "file_with_invalid_chars")
|
||||
|
||||
# Test with leading/trailing spaces and dots
|
||||
self.assertEqual(sanitize_filename(" file.with.spaces. "), "file.with.spaces")
|
||||
|
||||
# Test with empty string
|
||||
self.assertEqual(sanitize_filename(""), "unnamed")
|
||||
|
||||
def test_ensure_directory_exists(self):
|
||||
"""Test ensure_directory_exists function."""
|
||||
with tempfile.TemporaryDirectory() as temp_dir:
|
||||
test_dir = os.path.join(temp_dir, "test_dir")
|
||||
|
||||
# Directory should not exist initially
|
||||
self.assertFalse(os.path.exists(test_dir))
|
||||
|
||||
# Create directory
|
||||
ensure_directory_exists(test_dir)
|
||||
|
||||
# Directory should exist now
|
||||
self.assertTrue(os.path.exists(test_dir))
|
||||
|
||||
# Should not raise exception when called on existing directory
|
||||
ensure_directory_exists(test_dir)
|
||||
|
||||
def test_file_exists(self):
|
||||
"""Test file_exists function."""
|
||||
with tempfile.TemporaryDirectory() as temp_dir:
|
||||
# Create a test file
|
||||
test_file = os.path.join(temp_dir, "test_file.txt")
|
||||
with open(test_file, "w") as f:
|
||||
f.write("test")
|
||||
|
||||
# Test with existing file
|
||||
self.assertTrue(file_exists(test_file))
|
||||
|
||||
# Test with non-existing file
|
||||
self.assertFalse(file_exists(os.path.join(temp_dir, "non_existing_file.txt")))
|
||||
|
||||
|
||||
class TestPathUtils(unittest.TestCase):
|
||||
"""Test path utility functions."""
|
||||
|
||||
def test_normalize_path(self):
|
||||
"""Test normalize_path function."""
|
||||
# Test with mixed separators
|
||||
self.assertEqual(normalize_path("path/to\\file"), os.path.normpath("path/to/file"))
|
||||
|
||||
def test_join_paths(self):
|
||||
"""Test join_paths function."""
|
||||
# Test joining paths
|
||||
self.assertEqual(join_paths("path", "to", "file"), os.path.join("path", "to", "file"))
|
||||
|
||||
def test_get_absolute_path(self):
|
||||
"""Test get_absolute_path function."""
|
||||
# Test with relative path
|
||||
self.assertEqual(get_absolute_path("."), os.path.abspath("."))
|
||||
|
||||
def test_get_relative_path(self):
|
||||
"""Test get_relative_path function."""
|
||||
# Test with absolute path
|
||||
abs_path = os.path.abspath(".")
|
||||
self.assertEqual(get_relative_path(abs_path, os.path.dirname(abs_path)), os.path.basename(abs_path))
|
||||
|
||||
def test_get_filename(self):
|
||||
"""Test get_filename function."""
|
||||
# Test with path
|
||||
self.assertEqual(get_filename("/path/to/file.txt"), "file.txt")
|
||||
|
||||
def test_get_filename_without_extension(self):
|
||||
"""Test get_filename_without_extension function."""
|
||||
# Test with path and extension
|
||||
self.assertEqual(get_filename_without_extension("/path/to/file.txt"), "file")
|
||||
|
||||
def test_get_file_extension(self):
|
||||
"""Test get_file_extension function."""
|
||||
# Test with path and extension
|
||||
self.assertEqual(get_file_extension("/path/to/file.txt"), ".txt")
|
||||
|
||||
|
||||
class TestStringUtils(unittest.TestCase):
|
||||
"""Test string utility functions."""
|
||||
|
||||
def test_slugify(self):
|
||||
"""Test slugify function."""
|
||||
# Test with spaces and special characters
|
||||
self.assertEqual(slugify("Hello World!"), "hello-world")
|
||||
|
||||
# Test with unicode characters
|
||||
self.assertEqual(slugify("Héllö Wörld"), "hello-world")
|
||||
|
||||
def test_truncate_string(self):
|
||||
"""Test truncate_string function."""
|
||||
# Test with string shorter than max length
|
||||
self.assertEqual(truncate_string("Hello", 10), "Hello")
|
||||
|
||||
# Test with string longer than max length
|
||||
self.assertEqual(truncate_string("Hello World", 8), "Hello...")
|
||||
|
||||
def test_extract_artist_and_title(self):
|
||||
"""Test extract_artist_and_title function."""
|
||||
# Test with standard format
|
||||
self.assertEqual(
|
||||
extract_artist_and_title("Artist - Title.mp3"),
|
||||
{"artist": "Artist", "title": "Title"}
|
||||
)
|
||||
|
||||
# Test with no separator
|
||||
self.assertEqual(
|
||||
extract_artist_and_title("Title.mp3"),
|
||||
{"artist": "", "title": "Title"}
|
||||
)
|
||||
|
||||
def test_format_duration(self):
|
||||
"""Test format_duration function."""
|
||||
# Test with seconds
|
||||
self.assertEqual(format_duration(65), "01:05")
|
||||
|
||||
# Test with minutes
|
||||
self.assertEqual(format_duration(125), "02:05")
|
||||
|
||||
def test_format_filesize(self):
|
||||
"""Test format_filesize function."""
|
||||
# Test with bytes
|
||||
self.assertEqual(format_filesize(500), "500 B")
|
||||
|
||||
# Test with kilobytes
|
||||
self.assertEqual(format_filesize(1500), "1.5 KB")
|
||||
|
||||
# Test with megabytes
|
||||
self.assertEqual(format_filesize(1500000), "1.4 MB")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -1,6 +0,0 @@
|
||||
__pycache__/
|
||||
*.py[cod]
|
||||
*$py.class
|
||||
.pytest_cache/
|
||||
.coverage
|
||||
htmlcov/
|
||||
@@ -1,45 +0,0 @@
|
||||
# Unit Tests for KaraokePrep
|
||||
|
||||
This directory contains unit tests for the KaraokePrep class.
|
||||
|
||||
## Test Files
|
||||
|
||||
The tests are organized into the following files:
|
||||
|
||||
- `test_initialization.py`: Tests for initialization and basic functionality
|
||||
- `test_file_operations.py`: Tests for file operations (copy, download, convert)
|
||||
- `test_metadata.py`: Tests for metadata extraction and parsing
|
||||
- `test_lyrics.py`: Tests for lyrics processing
|
||||
- `test_audio.py`: Tests for audio processing and separation
|
||||
- `test_video.py`: Tests for video creation and processing
|
||||
- `test_async.py`: Tests for async methods
|
||||
|
||||
## Running the Tests
|
||||
|
||||
To run the tests, you need to have the test dependencies installed:
|
||||
|
||||
```bash
|
||||
pip install -r requirements-test.txt
|
||||
```
|
||||
|
||||
Then you can run the tests with:
|
||||
|
||||
```bash
|
||||
python run_tests.py
|
||||
```
|
||||
|
||||
This will run all the tests and generate a coverage report.
|
||||
|
||||
## Checking Test Files
|
||||
|
||||
If you want to check if the test files are valid Python code without running the tests, you can use:
|
||||
|
||||
```bash
|
||||
python check_tests.py
|
||||
```
|
||||
|
||||
This will check if all the test files can be imported without errors.
|
||||
|
||||
## Test Coverage
|
||||
|
||||
The tests aim to cover all the functionality of the KaraokePrep class. The coverage report will show you which parts of the code are covered by the tests.
|
||||
Whitespace-only changes.
@@ -1,43 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
import os
|
||||
import sys
|
||||
import importlib.util
|
||||
|
||||
def check_file(file_path):
|
||||
"""Check if a Python file can be imported without errors."""
|
||||
try:
|
||||
spec = importlib.util.spec_from_file_location("module.name", file_path)
|
||||
module = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(module)
|
||||
print(f"✅ {file_path} - OK")
|
||||
return True
|
||||
except Exception as e:
|
||||
print(f"❌ {file_path} - ERROR: {e}")
|
||||
return False
|
||||
|
||||
def main():
|
||||
"""Check all test files in the current directory."""
|
||||
current_dir = os.path.dirname(os.path.abspath(__file__))
|
||||
test_files = [f for f in os.listdir(current_dir) if f.startswith("test_") and f.endswith(".py")]
|
||||
|
||||
if not test_files:
|
||||
print("No test files found.")
|
||||
return 0
|
||||
|
||||
print(f"Checking {len(test_files)} test files...")
|
||||
|
||||
success = True
|
||||
for file_name in sorted(test_files):
|
||||
file_path = os.path.join(current_dir, file_name)
|
||||
if not check_file(file_path):
|
||||
success = False
|
||||
|
||||
if success:
|
||||
print("\nAll test files are valid Python code.")
|
||||
return 0
|
||||
else:
|
||||
print("\nSome test files have errors. Please fix them before running the tests.")
|
||||
return 1
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -1,44 +0,0 @@
|
||||
import os
|
||||
import pytest
|
||||
import tempfile
|
||||
import logging
|
||||
from unittest.mock import MagicMock
|
||||
from karaoke_prep.karaoke_prep import KaraokePrep
|
||||
import inspect
|
||||
|
||||
@pytest.fixture
|
||||
def mock_logger():
|
||||
"""Return a mock logger for testing."""
|
||||
return MagicMock(spec=logging.Logger)
|
||||
|
||||
@pytest.fixture
|
||||
def mock_ffmpeg():
|
||||
"""Return a mock for os.system to avoid executing ffmpeg commands."""
|
||||
return MagicMock()
|
||||
|
||||
@pytest.fixture
|
||||
def temp_dir():
|
||||
"""Create a temporary directory for test files."""
|
||||
with tempfile.TemporaryDirectory() as temp_dir:
|
||||
yield temp_dir
|
||||
|
||||
@pytest.fixture
|
||||
def basic_karaoke_prep(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)
|
||||
|
||||
# Replace the ffmpeg_base_command with a mock
|
||||
karaoke_prep.ffmpeg_base_command = "mock_ffmpeg"
|
||||
|
||||
# Mock os.system to avoid executing commands
|
||||
karaoke_prep._os_system = mock_os_system
|
||||
|
||||
yield karaoke_prep
|
||||
|
||||
def pytest_collection_modifyitems(items):
|
||||
"""Mark async tests with asyncio marker."""
|
||||
for item in items:
|
||||
if inspect.iscoroutinefunction(item.obj):
|
||||
item.add_marker(pytest.mark.asyncio)
|
||||
@@ -1,4 +0,0 @@
|
||||
pytest==8.3.5
|
||||
pytest-cov==6.0.0
|
||||
pytest-mock==3.14.0
|
||||
pytest-asyncio==0.23.8
|
||||
@@ -1,17 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
import os
|
||||
import sys
|
||||
import pytest
|
||||
|
||||
if __name__ == "__main__":
|
||||
# Add the project root to the Python path
|
||||
project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "../.."))
|
||||
sys.path.insert(0, project_root)
|
||||
|
||||
# Run pytest with coverage
|
||||
sys.exit(pytest.main([
|
||||
"--cov=karaoke_prep",
|
||||
"--cov-report=term",
|
||||
"-v",
|
||||
os.path.dirname(__file__)
|
||||
]))
|
||||
@@ -1,596 +0,0 @@
|
||||
import os
|
||||
import pytest
|
||||
import asyncio
|
||||
import signal
|
||||
import sys
|
||||
from unittest.mock import MagicMock, patch, AsyncMock, ANY
|
||||
from karaoke_prep.karaoke_prep import KaraokePrep
|
||||
|
||||
class TestAsync:
|
||||
@pytest.mark.asyncio
|
||||
async def test_prep_single_track(self, basic_karaoke_prep, 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:
|
||||
|
||||
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
|
||||
|
||||
# Create mock input file
|
||||
with open(basic_karaoke_prep.input_media, "w") as f:
|
||||
f.write("mock video content")
|
||||
|
||||
# Configure mock asyncio.gather to return mock results
|
||||
mock_separate.return_value = {}
|
||||
|
||||
# Configure mock asyncio.create_task to return a mock future
|
||||
mock_future = AsyncMock() # Use AsyncMock for tasks
|
||||
mock_copy.return_value = os.path.join(temp_dir, "copied.mp4")
|
||||
mock_convert.return_value = os.path.join(temp_dir, "converted.wav")
|
||||
|
||||
# Mock the return value of prep_single_track
|
||||
expected_result = {
|
||||
"track_output_dir": temp_dir, # Use temp_dir here
|
||||
"artist": "Test Artist",
|
||||
"title": "Test Title",
|
||||
"extractor": "Original",
|
||||
"extracted_info": None,
|
||||
"lyrics": None,
|
||||
"processed_lyrics": None,
|
||||
"input_media": os.path.join(temp_dir, "copied.mp4"),
|
||||
"input_still_image": None,
|
||||
"input_audio_wav": os.path.join(temp_dir, "converted.wav"),
|
||||
"separated_audio": {},
|
||||
"title_image_png": ANY,
|
||||
"title_image_jpg": ANY,
|
||||
"title_video": ANY,
|
||||
"end_image_png": ANY,
|
||||
"end_image_jpg": ANY,
|
||||
"end_video": ANY,
|
||||
}
|
||||
|
||||
# Configure the mock to return our expected result
|
||||
# No need to mock future.result, the function returns the dict directly
|
||||
|
||||
# Call the method
|
||||
result = await basic_karaoke_prep.prep_single_track()
|
||||
|
||||
# Verify the result structure
|
||||
assert result is not None
|
||||
assert result["artist"] == expected_result["artist"]
|
||||
assert result["title"] == expected_result["title"]
|
||||
assert result["input_media"] == expected_result["input_media"]
|
||||
assert result["input_audio_wav"] == expected_result["input_audio_wav"]
|
||||
if not isinstance(result["separated_audio"], asyncio.futures.Future) and not asyncio.iscoroutine(result["separated_audio"]):
|
||||
assert result["separated_audio"] == expected_result["separated_audio"]
|
||||
assert result["extractor"] == expected_result["extractor"]
|
||||
|
||||
# Verify asyncio.create_task was called
|
||||
assert mock_copy.call_count >= 1
|
||||
assert mock_convert.call_count >= 1
|
||||
|
||||
# Verify asyncio.gather was called
|
||||
assert mock_separate.call_count >= 1
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_prep_single_track_with_url(self, basic_karaoke_prep):
|
||||
"""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
|
||||
|
||||
# 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:
|
||||
|
||||
# Configure mock asyncio.gather to return mock results
|
||||
mock_separate.return_value = {}
|
||||
|
||||
# Configure mock asyncio.create_task to return a mock future
|
||||
mock_future = AsyncMock() # Use AsyncMock for tasks
|
||||
mock_download.return_value = "downloaded_file.mp4"
|
||||
mock_extract_image.return_value = "still_image.png"
|
||||
mock_convert.return_value = "output.wav"
|
||||
mock_create_title.return_value = None
|
||||
mock_create_end.return_value = None
|
||||
mock_future.return_value = {
|
||||
"track_output_dir": "output_dir",
|
||||
"artist": "Test Artist",
|
||||
"title": "Test Title",
|
||||
"input_media": "downloaded_file.mp4",
|
||||
"input_still_image": "still_image.png",
|
||||
"input_audio_wav": "output.wav",
|
||||
"separated_audio": {},
|
||||
"extractor": "youtube",
|
||||
"extracted_info": ANY,
|
||||
"lyrics": None,
|
||||
"processed_lyrics": None,
|
||||
"title_image_png": ANY,
|
||||
"title_image_jpg": ANY,
|
||||
"title_video": ANY,
|
||||
"end_image_png": ANY,
|
||||
"end_image_jpg": ANY,
|
||||
"end_video": ANY,
|
||||
}
|
||||
|
||||
# Configure the mock to return our expected result
|
||||
# No need to mock future.result, the function returns the dict directly
|
||||
|
||||
# Call the method
|
||||
result = await basic_karaoke_prep.prep_single_track()
|
||||
|
||||
# Verify the result structure
|
||||
assert result is not None
|
||||
assert result["artist"] == mock_future.return_value["artist"]
|
||||
assert result["title"] == mock_future.return_value["title"]
|
||||
# assert result["input_media"] == "downloaded_file.mp4"
|
||||
print(f"DEBUG: Actual input_media = {result.get('input_media')}") # Debug print
|
||||
assert result["input_still_image"] == "still_image.png"
|
||||
assert result["input_audio_wav"] == "output.wav"
|
||||
assert result["extractor"].lower() == "youtube"
|
||||
if not isinstance(result["separated_audio"], asyncio.futures.Future) and not asyncio.iscoroutine(result["separated_audio"]):
|
||||
assert result["separated_audio"] == {}
|
||||
# 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):
|
||||
"""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
|
||||
|
||||
# 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}*)")
|
||||
# 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")]
|
||||
elif pattern == f"{expected_base}.png":
|
||||
return [os.path.join(temp_dir, f"{artist_title} ({basic_karaoke_prep.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 []
|
||||
|
||||
with patch.object(basic_karaoke_prep.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:
|
||||
|
||||
# Configure mock asyncio.gather to return mock results
|
||||
mock_separate.return_value = {}
|
||||
|
||||
# Configure mock asyncio.create_task to return a mock future
|
||||
mock_future = AsyncMock() # Use AsyncMock for tasks
|
||||
mock_future.return_value = {
|
||||
"track_output_dir": temp_dir,
|
||||
"artist": "Test Artist",
|
||||
"title": "Test Title",
|
||||
"input_media": "existing_file.webm",
|
||||
"input_still_image": "existing_file.png",
|
||||
"input_audio_wav": "existing_file.wav",
|
||||
"separated_audio": {},
|
||||
"extractor": "Original",
|
||||
"extracted_info": None,
|
||||
"lyrics": None,
|
||||
"processed_lyrics": None,
|
||||
"title_image_png": ANY,
|
||||
"title_image_jpg": ANY,
|
||||
"title_video": ANY,
|
||||
"end_image_png": ANY,
|
||||
"end_image_jpg": ANY,
|
||||
"end_video": ANY,
|
||||
}
|
||||
|
||||
# Configure the mock to return our expected result
|
||||
# No need to mock future.result, the function returns the dict directly
|
||||
|
||||
# Call the method
|
||||
result = await basic_karaoke_prep.prep_single_track()
|
||||
|
||||
# Verify the result structure
|
||||
assert result is not None
|
||||
assert result["artist"] == mock_future.return_value["artist"]
|
||||
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")
|
||||
|
||||
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
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_prep_single_track_skip_lyrics(self, basic_karaoke_prep, 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
|
||||
|
||||
# Create mock input file
|
||||
with open(basic_karaoke_prep.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:
|
||||
|
||||
# Mock the return value of prep_single_track
|
||||
expected_result = {
|
||||
"track_output_dir": temp_dir,
|
||||
"artist": "Test Artist",
|
||||
"title": "Test Title",
|
||||
"input_media": os.path.join(temp_dir, "copied.mp4"),
|
||||
"input_audio_wav": os.path.join(temp_dir, "converted.wav"),
|
||||
"lyrics": None, # This is expected when skip_lyrics=True
|
||||
"separated_audio": {},
|
||||
"extractor": "Original",
|
||||
"extracted_info": None,
|
||||
"processed_lyrics": None,
|
||||
"input_still_image": None,
|
||||
"title_image_png": ANY,
|
||||
"title_image_jpg": ANY,
|
||||
"title_video": ANY,
|
||||
"end_image_png": ANY,
|
||||
"end_image_jpg": ANY,
|
||||
"end_video": ANY,
|
||||
}
|
||||
|
||||
# Call the method
|
||||
result = await basic_karaoke_prep.prep_single_track()
|
||||
|
||||
# Verify the result structure
|
||||
assert result is not None
|
||||
assert result["artist"] == expected_result["artist"]
|
||||
assert result["title"] == expected_result["title"]
|
||||
assert result["input_media"] == expected_result["input_media"]
|
||||
assert result["input_audio_wav"] == expected_result["input_audio_wav"]
|
||||
assert result["lyrics"] is None # Should be skipped
|
||||
if not isinstance(result["separated_audio"], asyncio.futures.Future) and not asyncio.iscoroutine(result["separated_audio"]):
|
||||
assert result["separated_audio"] == expected_result["separated_audio"]
|
||||
assert result["extractor"] == expected_result["extractor"]
|
||||
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):
|
||||
"""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
|
||||
|
||||
# Create mock input file
|
||||
with open(basic_karaoke_prep.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:
|
||||
# Conditionally patch separation only if we expect it to run (it's skipped here)
|
||||
# We will assert on the actual method instance later
|
||||
|
||||
# No need to configure mock_separate as it shouldn't be called
|
||||
|
||||
# Configure other mocks
|
||||
mock_copy.return_value = os.path.join(temp_dir, "copied.mp4")
|
||||
mock_convert.return_value = os.path.join(temp_dir, "converted.wav")
|
||||
mock_create_title.return_value = None
|
||||
mock_create_end.return_value = None
|
||||
|
||||
expected_result = {
|
||||
"track_output_dir": temp_dir,
|
||||
"artist": "Test Artist",
|
||||
"title": "Test Title",
|
||||
"input_media": os.path.join(temp_dir, "copied.mp4"),
|
||||
"input_audio_wav": os.path.join(temp_dir, "converted.wav"),
|
||||
"separated_audio": {
|
||||
"clean_instrumental": {},
|
||||
"backing_vocals": {},
|
||||
"other_stems": {},
|
||||
"combined_instrumentals": {}
|
||||
},
|
||||
"extractor": "Original",
|
||||
"extracted_info": None,
|
||||
"lyrics": None, # transcribe_lyrics is mocked to return {}
|
||||
"processed_lyrics": None,
|
||||
"input_still_image": None,
|
||||
"title_image_png": ANY,
|
||||
"title_image_jpg": ANY,
|
||||
"title_video": ANY,
|
||||
"end_image_png": ANY,
|
||||
"end_image_jpg": ANY,
|
||||
"end_video": ANY,
|
||||
}
|
||||
|
||||
# Call the method
|
||||
result = await basic_karaoke_prep.prep_single_track()
|
||||
|
||||
# Verify the result structure
|
||||
assert result is not None
|
||||
assert result["artist"] == expected_result["artist"]
|
||||
assert result["title"] == expected_result["title"]
|
||||
assert result["input_media"] == expected_result["input_media"]
|
||||
assert result["input_audio_wav"] == expected_result["input_audio_wav"]
|
||||
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:
|
||||
# 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()
|
||||
|
||||
# Assert that the transcription mock WAS called (implicitly via gather)
|
||||
assert mock_transcribe.call_count > 0
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_shutdown(self, basic_karaoke_prep):
|
||||
"""Test the shutdown signal handler."""
|
||||
# Mock signal
|
||||
mock_signal = MagicMock()
|
||||
mock_signal.name = "SIGINT"
|
||||
|
||||
# Mock asyncio.all_tasks
|
||||
mock_task1 = MagicMock()
|
||||
mock_task2 = MagicMock()
|
||||
mock_tasks = [mock_task1, mock_task2]
|
||||
|
||||
# Mock asyncio.current_task
|
||||
mock_current_task = MagicMock()
|
||||
|
||||
with patch('asyncio.all_tasks', return_value=mock_tasks), \
|
||||
patch('asyncio.current_task', return_value=mock_current_task), \
|
||||
patch('asyncio.gather'), \
|
||||
patch('sys.exit') as mock_exit:
|
||||
|
||||
# Mock the shutdown method to do nothing
|
||||
with patch.object(basic_karaoke_prep, 'shutdown') as mock_shutdown:
|
||||
# Call the method
|
||||
await basic_karaoke_prep.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):
|
||||
"""Test processing a playlist."""
|
||||
# Setup
|
||||
basic_karaoke_prep.artist = "Test Artist"
|
||||
basic_karaoke_prep.title = "Test Title"
|
||||
basic_karaoke_prep.extracted_info = {
|
||||
"entries": [
|
||||
{"title": "Track 1"},
|
||||
{"title": "Track 2"}
|
||||
]
|
||||
}
|
||||
basic_karaoke_prep.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:
|
||||
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 = {
|
||||
"entries": [
|
||||
{"title": "Track 1"},
|
||||
{"title": "Track 2"}
|
||||
]
|
||||
}
|
||||
|
||||
# Mock the result of process_playlist
|
||||
expected_result = [{"track": "result1"}, {"track": "result2"}]
|
||||
|
||||
# Call the method
|
||||
result = await basic_karaoke_prep.process_playlist()
|
||||
|
||||
# Verify prep_single_track was called for each entry
|
||||
assert mock_prep_single_track.call_count == 2
|
||||
|
||||
# Verify the result
|
||||
assert len(result) == 2
|
||||
assert result[0] == {"track": "result"}
|
||||
assert result[1] == {"track": "result"}
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_process_playlist_error(self, basic_karaoke_prep):
|
||||
"""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
|
||||
|
||||
# Test
|
||||
with pytest.raises(Exception, match="Failed to find 'entries' in playlist, cannot process"):
|
||||
await basic_karaoke_prep.process_playlist()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_process_folder(self, basic_karaoke_prep, 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"
|
||||
|
||||
# Create mock files
|
||||
os.makedirs(temp_dir, exist_ok=True)
|
||||
with open(os.path.join(temp_dir, "01_Track1.mp3"), "w") as f:
|
||||
f.write("mock audio content")
|
||||
with open(os.path.join(temp_dir, "02_Track2.mp3"), "w") as f:
|
||||
f.write("mock audio content")
|
||||
|
||||
# Mock dependencies
|
||||
with patch.object(basic_karaoke_prep, 'prep_single_track', new_callable=AsyncMock) as mock_prep_single_track, \
|
||||
patch('os.makedirs'), \
|
||||
patch('shutil.move'):
|
||||
|
||||
mock_prep_single_track.return_value = {
|
||||
"track_output_dir": os.path.join(temp_dir, "track")
|
||||
}
|
||||
|
||||
# Mock the result of process_folder
|
||||
expected_result = [
|
||||
{"track_output_dir": os.path.join(temp_dir, "track")}
|
||||
]
|
||||
|
||||
# Call the method
|
||||
result = await basic_karaoke_prep.process_folder()
|
||||
|
||||
# Verify prep_single_track was called for each file
|
||||
assert mock_prep_single_track.call_count == 2
|
||||
|
||||
# Verify the result
|
||||
assert len(result) == 2
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_process_folder_error(self, basic_karaoke_prep):
|
||||
"""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"
|
||||
|
||||
# Test
|
||||
with pytest.raises(Exception, match="Error: Filename pattern and artist are required for processing a folder"):
|
||||
await basic_karaoke_prep.process_folder()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_process_local_file(self, basic_karaoke_prep, 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"
|
||||
|
||||
# Mock dependencies
|
||||
with patch.object(basic_karaoke_prep, '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()
|
||||
|
||||
# Verify prep_single_track was called
|
||||
mock_prep_single_track.assert_called_once()
|
||||
|
||||
# Verify the result
|
||||
assert len(result) == 1
|
||||
assert result[0] == {"track": "result"}
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_process_online_media(self, basic_karaoke_prep):
|
||||
"""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"
|
||||
|
||||
# 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:
|
||||
|
||||
# Configure the mock ydl context manager
|
||||
mock_ydl_instance = MagicMock()
|
||||
mock_ydl_instance.extract_info.return_value = {
|
||||
"title": "Test Video",
|
||||
"extractor_key": "Youtube",
|
||||
"id": "12345",
|
||||
"url": "https://example.com/video"
|
||||
}
|
||||
mock_ydl.return_value.__enter__.return_value = mock_ydl_instance
|
||||
|
||||
basic_karaoke_prep.extracted_info = {} # Not a playlist
|
||||
mock_prep_single_track.return_value = {"track": "result"}
|
||||
|
||||
result = await basic_karaoke_prep.process()
|
||||
|
||||
# Verify prep_single_track was called
|
||||
mock_prep_single_track.assert_called_once()
|
||||
|
||||
# Verify the result
|
||||
assert len(result) == 1
|
||||
assert result[0] == {"track": "result"}
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_process_online_playlist(self, basic_karaoke_prep):
|
||||
"""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"
|
||||
|
||||
# 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:
|
||||
|
||||
# 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
|
||||
mock_process_playlist.return_value = [{"track": "result1"}, {"track": "result2"}]
|
||||
|
||||
result = await basic_karaoke_prep.process()
|
||||
|
||||
# Verify process_playlist was called
|
||||
mock_process_playlist.assert_called_once()
|
||||
|
||||
# Verify the result
|
||||
assert len(result) == 2
|
||||
assert result[0] == {"track": "result1"}
|
||||
assert result[1] == {"track": "result2"}
|
||||
@@ -1,288 +0,0 @@
|
||||
import os
|
||||
import pytest
|
||||
import glob
|
||||
import json
|
||||
import tempfile
|
||||
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 audio_separator.separator import Separator # Keep for patching target
|
||||
|
||||
class TestAudio:
|
||||
def test_separate_audio(self, basic_karaoke_prep, temp_dir):
|
||||
"""Test separating audio into instrumental and vocals."""
|
||||
# Setup
|
||||
audio_file = os.path.join(temp_dir, "input.wav")
|
||||
with open(audio_file, "w") as f:
|
||||
f.write("mock audio content")
|
||||
|
||||
model_name = "test_model.ckpt"
|
||||
artist_title = "Test Artist - Test Title"
|
||||
track_output_dir = temp_dir
|
||||
instrumental_path = os.path.join(temp_dir, f"{artist_title} (Instrumental {model_name}).flac")
|
||||
vocals_path = os.path.join(temp_dir, f"{artist_title} (Vocals {model_name}).flac")
|
||||
|
||||
# Mock Separator
|
||||
mock_separator = MagicMock()
|
||||
mock_separator.load_model.return_value = None
|
||||
mock_separator.separate.return_value = [
|
||||
f"{artist_title} (Vocals)_test_model.flac",
|
||||
f"{artist_title} (Instrumental)_test_model.flac",
|
||||
f"{artist_title}_(Piano)_test_model.flac"
|
||||
]
|
||||
|
||||
# Mock dependencies
|
||||
with patch('audio_separator.separator.Separator', return_value=mock_separator), \
|
||||
patch('os.rename') as mock_rename:
|
||||
|
||||
# Call the method
|
||||
basic_karaoke_prep.audio_processor.separate_audio(
|
||||
audio_file=audio_file,
|
||||
model_name=model_name,
|
||||
artist_title=artist_title,
|
||||
track_output_dir=track_output_dir,
|
||||
instrumental_path=instrumental_path,
|
||||
vocals_path=vocals_path
|
||||
)
|
||||
|
||||
# Verify Separator.load_model was called with correct arguments
|
||||
mock_separator.load_model.assert_called_once_with(model_filename=model_name)
|
||||
|
||||
# Verify Separator.separate was called with correct arguments
|
||||
mock_separator.separate.assert_called_once_with(audio_file)
|
||||
|
||||
# Verify os.rename was called for each output file
|
||||
assert mock_rename.call_count == 3
|
||||
mock_rename.assert_any_call(
|
||||
f"{artist_title} (Vocals)_test_model.flac",
|
||||
vocals_path
|
||||
)
|
||||
mock_rename.assert_any_call(
|
||||
f"{artist_title} (Instrumental)_test_model.flac",
|
||||
instrumental_path
|
||||
)
|
||||
|
||||
def test_separate_audio_invalid_audio_file(self, basic_karaoke_prep):
|
||||
"""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(
|
||||
audio_file=None,
|
||||
model_name="test_model.ckpt",
|
||||
artist_title="Test Artist - Test Title",
|
||||
track_output_dir="output_dir",
|
||||
instrumental_path="instrumental.flac",
|
||||
vocals_path="vocals.flac"
|
||||
)
|
||||
|
||||
def test_process_audio_separation(self, basic_karaoke_prep, temp_dir):
|
||||
"""Test the process_audio_separation method."""
|
||||
# Setup
|
||||
audio_file = os.path.join(temp_dir, "input.wav")
|
||||
with open(audio_file, "w") as f:
|
||||
f.write("mock audio content")
|
||||
|
||||
artist_title = "Test Artist - Test Title"
|
||||
track_output_dir = temp_dir
|
||||
|
||||
# Create stems directory
|
||||
stems_dir = os.path.join(track_output_dir, "stems")
|
||||
os.makedirs(stems_dir, exist_ok=True)
|
||||
|
||||
# Mock Separator
|
||||
mock_separator = MagicMock()
|
||||
mock_separator.load_model.return_value = None
|
||||
|
||||
# Mock output files for different models
|
||||
clean_model = "model_bs_roformer_ep_317_sdr_12.9755.ckpt"
|
||||
backing_model = "mel_band_roformer_karaoke_aufr33_viperx_sdr_10.1956.ckpt"
|
||||
other_model = "htdemucs_6s.yaml"
|
||||
|
||||
# Determine intermediate filenames based on input to _separate_backing_vocals
|
||||
# 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}"
|
||||
|
||||
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}")
|
||||
],
|
||||
# 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}")
|
||||
],
|
||||
# 3. Backing vocals model outputs (called by _separate_backing_vocals)
|
||||
# These are output relative to the *vocals input* file's directory (stems_dir)
|
||||
[
|
||||
intermediate_bv_vocals, # e.g., .../stems/Artist - Title (Vocals model_clean)_(Vocals).flac
|
||||
intermediate_bv_instrumental # e.g., .../stems/Artist - Title (Vocals model_clean)_(Instrumental).flac
|
||||
]
|
||||
]
|
||||
|
||||
# Mock dependencies
|
||||
with patch('audio_separator.separator.Separator', return_value=mock_separator), \
|
||||
patch('os.rename') as mock_rename, \
|
||||
patch('os.path.exists', return_value=True), \
|
||||
patch('os.getpid', return_value=12345), \
|
||||
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:
|
||||
|
||||
# Configure _file_exists side effect: False initially, then True for normalization checks
|
||||
# Needs to return False for:
|
||||
# 1. clean instrumental path check (_separate_clean_instrumental)
|
||||
# 2. clean vocals path check (_separate_clean_instrumental)
|
||||
# 3. other stem piano path check (_separate_other_stems loop 1)
|
||||
# 4. other stem guitar path check (_separate_other_stems loop 1) - Assuming 1 'other' model
|
||||
# 5. lead vocals path check (_separate_backing_vocals)
|
||||
# 6. backing vocals path check (_separate_backing_vocals)
|
||||
# 7. combined instrumental path check (_generate_combined_instrumentals)
|
||||
# Then True for normalization checks:
|
||||
# 8. backing lead vocals path check (inner loop in _separate_backing_vocals)
|
||||
# 9. backing backing vocals path check (inner loop in _separate_backing_vocals)
|
||||
# 10. combined instrumental path check (_generate_combined_instrumentals)
|
||||
# Then True for normalization checks:
|
||||
# 11. clean instrumental path check (in _normalize_audio_files)
|
||||
# 12. combined instrumental path check (in _normalize_audio_files)
|
||||
mock_file_exists.side_effect = [False] * 9 + [True] * 2 # Adjusted from 7 to 9 False values
|
||||
|
||||
# Configure the mock datetime object
|
||||
mock_datetime.now.return_value = dt.datetime.fromisoformat("2023-01-01T12:00:00")
|
||||
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(
|
||||
audio_file=audio_file,
|
||||
artist_title=artist_title,
|
||||
track_output_dir=track_output_dir
|
||||
)
|
||||
|
||||
# Verify the result structure
|
||||
assert "clean_instrumental" in result
|
||||
assert "other_stems" in result
|
||||
assert "backing_vocals" in result
|
||||
assert "combined_instrumentals" in result
|
||||
|
||||
# Verify Separator.load_model was called for each model
|
||||
assert mock_separator.load_model.call_count == 3
|
||||
|
||||
# Verify Separator.separate was called for each separation
|
||||
assert mock_separator.separate.call_count == 3
|
||||
|
||||
# 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."""
|
||||
# Setup
|
||||
audio_file = os.path.join(temp_dir, "input.wav")
|
||||
with open(audio_file, "w") as f:
|
||||
f.write("mock audio content")
|
||||
|
||||
artist_title = "Test Artist - Test Title"
|
||||
track_output_dir = temp_dir
|
||||
|
||||
# Mock environment variable
|
||||
with patch.dict('os.environ', {'KARAOKE_PREP_SKIP_AUDIO_SEPARATION': '1'}), \
|
||||
patch('fcntl.flock'), \
|
||||
patch('builtins.open', mock_open()) as mock_file_open:
|
||||
|
||||
# Call the method
|
||||
result = basic_karaoke_prep.audio_processor.process_audio_separation(
|
||||
audio_file=audio_file,
|
||||
artist_title=artist_title,
|
||||
track_output_dir=track_output_dir
|
||||
)
|
||||
|
||||
# Verify the result structure
|
||||
assert "clean_instrumental" in result
|
||||
assert "other_stems" in result
|
||||
assert "backing_vocals" in result
|
||||
assert "combined_instrumentals" in result
|
||||
|
||||
# Verify all result sections are empty
|
||||
assert result["clean_instrumental"] == {}
|
||||
assert result["other_stems"] == {}
|
||||
assert result["backing_vocals"] == {}
|
||||
assert result["combined_instrumentals"] == {}
|
||||
|
||||
def test_normalize_audio(self, basic_karaoke_prep, temp_dir):
|
||||
"""Test normalizing audio."""
|
||||
# Setup
|
||||
input_path = os.path.join(temp_dir, "input.flac")
|
||||
output_path = os.path.join(temp_dir, "output.flac")
|
||||
|
||||
# Create a mock AudioSegment
|
||||
mock_audio = MagicMock(spec=AudioSegment)
|
||||
mock_audio.max_dBFS = -6.0
|
||||
mock_audio.apply_gain.return_value = mock_audio
|
||||
mock_audio.rms = 100 # Non-zero RMS
|
||||
|
||||
# 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)
|
||||
|
||||
# Verify AudioSegment.from_file was called with correct arguments
|
||||
AudioSegment.from_file.assert_called_once_with(input_path, format="flac")
|
||||
|
||||
# Verify apply_gain was called with correct arguments (target_level - current_level)
|
||||
mock_audio.apply_gain.assert_called_once_with(0.0 - (-6.0))
|
||||
|
||||
# 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):
|
||||
"""Test normalizing audio when the result would be silent."""
|
||||
# Setup
|
||||
input_path = os.path.join(temp_dir, "input.flac")
|
||||
output_path = os.path.join(temp_dir, "output.flac")
|
||||
|
||||
# Create a mock AudioSegment
|
||||
mock_audio = MagicMock(spec=AudioSegment)
|
||||
mock_audio.max_dBFS = -6.0
|
||||
|
||||
# First mock has RMS of 0 (silent)
|
||||
mock_normalized = MagicMock(spec=AudioSegment)
|
||||
mock_normalized.rms = 0
|
||||
|
||||
mock_audio.apply_gain.return_value = mock_normalized
|
||||
|
||||
# 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)
|
||||
|
||||
# Verify AudioSegment.from_file was called with correct arguments
|
||||
AudioSegment.from_file.assert_called_once_with(input_path, format="flac")
|
||||
|
||||
# Verify apply_gain was called with correct arguments
|
||||
mock_audio.apply_gain.assert_called_once_with(0.0 - (-6.0))
|
||||
|
||||
# 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):
|
||||
"""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
|
||||
|
||||
# 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
|
||||
@@ -1,755 +0,0 @@
|
||||
import pytest
|
||||
import asyncio
|
||||
import argparse
|
||||
import csv
|
||||
import os
|
||||
import logging
|
||||
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
|
||||
|
||||
# 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",
|
||||
"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"
|
||||
}
|
||||
|
||||
# Instead of the global pytestmark, we'll explicitly mark async tests where needed
|
||||
# and neither mark sync tests nor explicitly mark them as non-async
|
||||
|
||||
# Sample CSV data as a string
|
||||
SAMPLE_CSV_DATA = """Artist,Title,Mixed Audio Filename,Instrumental Audio Filename,Status
|
||||
Artist One,Title One,mix1.mp3,inst1.mp3,Uploaded
|
||||
Artist Two,Title Two,mix2.wav,inst2.wav,Prep_Complete
|
||||
Artist Three,Title Three,mix3.flac,inst3.flac,Completed
|
||||
Artist Four,Title Four,mix4.ogg,inst4.ogg,Prep_Failed
|
||||
Artist Five,Title Five,mix5.m4a,inst5.m4a,Uploaded
|
||||
"""
|
||||
|
||||
# Sample style params JSON
|
||||
SAMPLE_STYLE_JSON = '{"cdg": {"some_style": "value"}}'
|
||||
|
||||
# For tests that are not async functions, remove the asyncio mark
|
||||
single_test_marks = {
|
||||
"test_update_csv_status": False,
|
||||
"test_argument_parsing": False,
|
||||
"test_async_main_csv_not_found": False,
|
||||
"test_main_logging_setup": False
|
||||
}
|
||||
|
||||
@pytest.fixture
|
||||
def mock_args(tmp_path):
|
||||
"""Fixture for mock command line arguments."""
|
||||
csv_path = tmp_path / "input.csv"
|
||||
csv_path.write_text(SAMPLE_CSV_DATA)
|
||||
style_path = tmp_path / "styles.json"
|
||||
style_path.write_text(SAMPLE_STYLE_JSON)
|
||||
|
||||
args = argparse.Namespace(
|
||||
input_csv=str(csv_path),
|
||||
style_params_json=str(style_path),
|
||||
output_dir=str(tmp_path / "output"),
|
||||
enable_cdg=False,
|
||||
enable_txt=False,
|
||||
log_level=logging.INFO, # Use numeric level directly as processed in bulk_cli
|
||||
dry_run=False,
|
||||
)
|
||||
return args
|
||||
|
||||
@pytest.fixture
|
||||
def mock_logger():
|
||||
"""Fixture for a mock logger."""
|
||||
return MagicMock(spec=logging.Logger)
|
||||
|
||||
@pytest.fixture
|
||||
def mock_log_formatter():
|
||||
"""Fixture for a 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
|
||||
@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
|
||||
mock_args, mock_logger, mock_log_formatter # Keep fixtures needed by args/mocks
|
||||
):
|
||||
"""Test the refactored async_main function orchestrates argument parsing, CSV reading, and processing."""
|
||||
|
||||
# --- Mock Configuration ---
|
||||
# 1. Mock _parse_and_validate_args to return our fixture args
|
||||
mock_parse_args.return_value = mock_args
|
||||
|
||||
# 2. Mock _read_csv_file to return sample rows
|
||||
sample_rows = list(csv.DictReader(SAMPLE_CSV_DATA.splitlines()))
|
||||
mock_read_csv.return_value = sample_rows
|
||||
|
||||
# 3. Mock setup_logging to return the mock formatter
|
||||
mock_setup_logging.return_value = mock_log_formatter
|
||||
|
||||
# 4. Mock process_csv_rows (AsyncMock) - we just check it's called correctly
|
||||
mock_process_rows.return_value = {"summary": "results"} # Return some dummy result
|
||||
|
||||
# --- Inject Mocks & Run ---
|
||||
# Ensure setup_logging returns the formatter when called
|
||||
mock_setup_logging.return_value = mock_log_formatter
|
||||
# We also need to ensure the global log_formatter is set as async_main checks it.
|
||||
bulk_cli.log_formatter = mock_log_formatter # Set the global formatter
|
||||
|
||||
# Run the async_main function
|
||||
result = await bulk_cli.async_main()
|
||||
|
||||
# --- Assertions ---
|
||||
# 1. Check _parse_and_validate_args was called
|
||||
mock_parse_args.assert_called_once()
|
||||
|
||||
# 2. Check logger level was set directly on the module logger
|
||||
mock_bulk_cli_logger.setLevel.assert_called_with(mock_args.log_level)
|
||||
# No need to assert setup_logging call for level setting
|
||||
|
||||
# 3. Check _read_csv_file was called with the validated CSV path from args
|
||||
mock_read_csv.assert_called_once_with(mock_args.input_csv)
|
||||
|
||||
# 4. Check process_csv_rows was awaited correctly, passing the patched module logger
|
||||
mock_process_rows.assert_awaited_once_with(
|
||||
mock_args.input_csv,
|
||||
sample_rows,
|
||||
mock_args,
|
||||
mock_bulk_cli_logger, # Pass the patched module logger
|
||||
mock_log_formatter # Check it's called with the formatter
|
||||
)
|
||||
|
||||
# 5. Check the final result is returned
|
||||
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")
|
||||
@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."""
|
||||
mock_kprep_instance = AsyncMock()
|
||||
mock_kprep.return_value = mock_kprep_instance
|
||||
mock_kprep_instance.process = AsyncMock(return_value=[{"artist": "A", "title": "T"}])
|
||||
row = {"Artist": "Test Artist", "Title": "Test Title", "Mixed Audio Filename": "mix.mp3", "Instrumental Audio Filename": "inst.mp3"}
|
||||
|
||||
result = await bulk_cli.process_track_prep(row, mock_args, mock_logger, mock_log_formatter)
|
||||
|
||||
assert result is True
|
||||
mock_kprep.assert_called_once_with(
|
||||
artist="Test Artist",
|
||||
title="Test Title",
|
||||
input_media="mix.mp3",
|
||||
existing_instrumental="inst.mp3",
|
||||
style_params_json=mock_args.style_params_json,
|
||||
logger=mock_logger,
|
||||
log_level=mock_args.log_level,
|
||||
dry_run=mock_args.dry_run,
|
||||
render_video=False,
|
||||
create_track_subfolders=True,
|
||||
)
|
||||
mock_kprep_instance.process.assert_awaited_once()
|
||||
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")
|
||||
@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."""
|
||||
mock_kprep_instance = AsyncMock()
|
||||
mock_kprep.return_value = mock_kprep_instance
|
||||
mock_kprep_instance.process.side_effect = Exception("Prep Error")
|
||||
row = {"Artist": "Test Artist", "Title": "Test Title", "Mixed Audio Filename": "mix.mp3", "Instrumental Audio Filename": "inst.mp3"}
|
||||
|
||||
result = await bulk_cli.process_track_prep(row, mock_args, mock_logger, mock_log_formatter)
|
||||
|
||||
assert result is False
|
||||
mock_logger.error.assert_called_once_with("Failed initial prep for Test Artist - Test Title: Prep Error")
|
||||
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("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(
|
||||
mock_open_file, mock_getcwd, mock_chdir, mock_exists, mock_kfinalise, mock_kprep,
|
||||
mock_args, mock_logger, mock_log_formatter
|
||||
):
|
||||
"""Test process_track_render success with KaraokePrep and KaraokeFinalise."""
|
||||
mock_kprep_instance = AsyncMock()
|
||||
mock_kprep.return_value = mock_kprep_instance
|
||||
mock_kprep_instance.process = AsyncMock(return_value=[{"artist": "Render Artist", "title": "Render Title"}])
|
||||
mock_kfinalise_instance = mock_kfinalise.return_value
|
||||
mock_kfinalise_instance.process = MagicMock(return_value={"final": "track"})
|
||||
|
||||
row = {"Artist": "Render Artist", "Title": "Render Title", "Mixed Audio Filename": "mix_render.mp3", "Instrumental Audio Filename": "inst_render.mp3"}
|
||||
mock_args.enable_cdg = False # Keep it simple first
|
||||
|
||||
result = await bulk_cli.process_track_render(row, mock_args, mock_logger, mock_log_formatter)
|
||||
|
||||
assert result is True
|
||||
# Check KaraokePrep call
|
||||
mock_kprep.assert_called_once_with(
|
||||
artist="Render Artist",
|
||||
title="Render Title",
|
||||
input_media="mix_render.mp3",
|
||||
existing_instrumental="inst_render.mp3",
|
||||
style_params_json=mock_args.style_params_json,
|
||||
logger=mock_logger,
|
||||
log_level=mock_args.log_level,
|
||||
dry_run=mock_args.dry_run,
|
||||
render_video=True,
|
||||
create_track_subfolders=True,
|
||||
skip_transcription_review=True,
|
||||
)
|
||||
mock_kprep_instance.process.assert_awaited_once()
|
||||
|
||||
# Check directory finding and chdir
|
||||
expected_track_dir = os.path.join(mock_args.output_dir, "Render Artist - Render Title")
|
||||
mock_exists.assert_called_with(expected_track_dir)
|
||||
mock_chdir.assert_any_call(expected_track_dir) # Changed into track dir
|
||||
|
||||
# Check KaraokeFinalise call
|
||||
mock_kfinalise.assert_called_once_with(
|
||||
log_formatter=mock_log_formatter,
|
||||
log_level=mock_args.log_level,
|
||||
dry_run=mock_args.dry_run,
|
||||
enable_cdg=False,
|
||||
enable_txt=False,
|
||||
cdg_styles=None,
|
||||
non_interactive=True,
|
||||
)
|
||||
mock_kfinalise_instance.process.assert_called_once()
|
||||
|
||||
# Check changed back to original dir
|
||||
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("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(
|
||||
mock_open_file, mock_getcwd, mock_chdir, mock_exists, mock_kfinalise, mock_kprep,
|
||||
mock_args, mock_logger, mock_log_formatter
|
||||
):
|
||||
"""Test process_track_render handles exceptions from KaraokeFinalise."""
|
||||
mock_kprep_instance = AsyncMock()
|
||||
mock_kprep.return_value = mock_kprep_instance
|
||||
mock_kprep_instance.process = AsyncMock(return_value=[{"artist": "Fail Artist", "title": "Fail Title"}])
|
||||
mock_kfinalise_instance = mock_kfinalise.return_value
|
||||
mock_kfinalise_instance.process.side_effect = Exception("Finalise Error")
|
||||
|
||||
row = {"Artist": "Fail Artist", "Title": "Fail Title", "Mixed Audio Filename": "mix_fail.mp3", "Instrumental Audio Filename": "inst_fail.mp3"}
|
||||
|
||||
result = await bulk_cli.process_track_render(row, mock_args, mock_logger, mock_log_formatter)
|
||||
|
||||
assert result is False
|
||||
mock_logger.error.assert_any_call("Error during finalisation: Finalise Error")
|
||||
mock_logger.error.assert_called_with("Failed render/finalise for Fail Artist - Fail Title: Finalise Error")
|
||||
mock_chdir.assert_called_with("/fake/original/dir") # Should still change back
|
||||
|
||||
|
||||
def test_update_csv_status(tmp_path):
|
||||
"""Test the update_csv_status function correctly modifies the CSV."""
|
||||
# Create a temporary CSV file
|
||||
csv_path = tmp_path / "test.csv"
|
||||
csv_path.write_text(SAMPLE_CSV_DATA)
|
||||
|
||||
# Call the function
|
||||
result = bulk_cli.update_csv_status(str(csv_path), 0, "New_Status")
|
||||
|
||||
# Verify the function returned True for success
|
||||
assert result is True
|
||||
|
||||
# Read the file back and verify changes
|
||||
with open(csv_path, "r") as f:
|
||||
reader = csv.DictReader(f)
|
||||
rows = list(reader)
|
||||
|
||||
# Check that the status was updated for the first row
|
||||
assert rows[0]["Status"] == "New_Status"
|
||||
# Check that other rows remain unchanged
|
||||
assert rows[1]["Status"] == "Prep_Complete"
|
||||
assert rows[2]["Status"] == "Completed"
|
||||
|
||||
|
||||
@patch(mock_module_paths["logger"])
|
||||
def test_update_csv_status_dry_run(mock_logger, tmp_path):
|
||||
"""Test that update_csv_status doesn't modify the file in dry run mode."""
|
||||
# Create a temporary CSV file
|
||||
csv_path = tmp_path / "test_dry_run.csv"
|
||||
csv_path.write_text(SAMPLE_CSV_DATA)
|
||||
|
||||
# Call with dry_run=True
|
||||
result = bulk_cli.update_csv_status(str(csv_path), 0, "New_Status", dry_run=True)
|
||||
|
||||
# Verify the function returned False for dry run
|
||||
assert result is False
|
||||
|
||||
# Verify log message
|
||||
mock_logger.info.assert_called_once()
|
||||
log_message = mock_logger.info.call_args[0][0]
|
||||
assert "DRY RUN" in log_message
|
||||
assert "New_Status" in log_message
|
||||
|
||||
# Read the file back and verify it wasn't changed
|
||||
with open(csv_path, "r") as f:
|
||||
reader = csv.DictReader(f)
|
||||
rows = list(reader)
|
||||
|
||||
# Check that the status of the first row is still the original
|
||||
assert rows[0]["Status"] == "Uploaded"
|
||||
|
||||
|
||||
@patch(mock_module_paths["ArgumentParser"])
|
||||
def test_argument_parsing(mock_parser_class):
|
||||
"""Test that arguments are parsed correctly."""
|
||||
# Create a mock parser that returns predefined args
|
||||
mock_parser_instance = mock_parser_class.return_value
|
||||
mock_args = argparse.Namespace(
|
||||
input_csv="path/to/input.csv",
|
||||
style_params_json="path/to/styles.json",
|
||||
output_dir="output",
|
||||
enable_cdg=True,
|
||||
enable_txt=False,
|
||||
log_level="debug",
|
||||
dry_run=True,
|
||||
)
|
||||
mock_parser_instance.parse_args.return_value = mock_args
|
||||
|
||||
# Call the function under test
|
||||
with patch("sys.argv", ["bulk_cli.py", "path/to/input.csv", "--style_params_json=path/to/styles.json"]):
|
||||
result = bulk_cli.parse_arguments()
|
||||
|
||||
# Verify the parser was configured correctly
|
||||
assert mock_parser_class.call_count == 1
|
||||
# Verify parse_args was called
|
||||
assert mock_parser_instance.parse_args.call_count == 1
|
||||
|
||||
# Verify the expected arguments were added to the parser
|
||||
add_argument_calls = [call_args[0][0] for call_args in mock_parser_instance.add_argument.call_args_list]
|
||||
|
||||
# Check for required arguments
|
||||
assert "input_csv" in ''.join(str(x) for x in add_argument_calls)
|
||||
assert "--style_params_json" in add_argument_calls
|
||||
assert "--output_dir" in add_argument_calls
|
||||
assert "--enable_cdg" in add_argument_calls
|
||||
assert "--enable_txt" in add_argument_calls
|
||||
assert "--log_level" in add_argument_calls
|
||||
assert "--dry_run" in add_argument_calls
|
||||
|
||||
# Check the result
|
||||
assert result == mock_args
|
||||
|
||||
|
||||
@patch(mock_module_paths["os_path_isfile"], return_value=False) # Simulate file not found
|
||||
@patch(mock_module_paths["logger"]) # Mock logger to check error message
|
||||
def test_validate_input_csv_not_found(mock_logger, mock_isfile):
|
||||
"""Test that validate_input_csv returns False when CSV is not found."""
|
||||
# Call the function under test with a non-existent file
|
||||
result = bulk_cli.validate_input_csv("/non/existent/file.csv")
|
||||
|
||||
# Verify the result
|
||||
assert result is False
|
||||
|
||||
# Verify error was logged
|
||||
mock_logger.error.assert_called_once_with("Input CSV file not found: /non/existent/file.csv")
|
||||
|
||||
|
||||
@patch(mock_module_paths["os_path_isfile"], return_value=True) # Simulate file found
|
||||
def test_validate_input_csv_exists(mock_isfile):
|
||||
"""Test that validate_input_csv returns True when CSV exists."""
|
||||
# Call the function under test with an existing file
|
||||
result = bulk_cli.validate_input_csv("/path/to/existing/file.csv")
|
||||
|
||||
# Verify the result
|
||||
assert result is True
|
||||
|
||||
# Verify isfile was called with the right path
|
||||
mock_isfile.assert_called_once_with("/path/to/existing/file.csv")
|
||||
|
||||
|
||||
@patch(mock_module_paths["ArgumentParser"])
|
||||
@patch(mock_module_paths["os_path_abspath"])
|
||||
@patch(mock_module_paths["os_path_isfile"], return_value=False) # Simulate file not found
|
||||
@patch(mock_module_paths["asyncio_run"]) # Keep mock_run for now, might be useful later
|
||||
@patch(mock_module_paths["logger"])
|
||||
# Test the helper function directly
|
||||
def test_parse_and_validate_args_csv_not_found(mock_logger, mock_run, mock_isfile, mock_abspath, mock_parser_class):
|
||||
"""Test _parse_and_validate_args raises FileNotFoundError if input CSV is not found."""
|
||||
# Configure mocks for parse_arguments called within _parse_and_validate_args
|
||||
mock_parser_instance = mock_parser_class.return_value
|
||||
mock_abspath.side_effect = lambda p: f"/abs/{p}" # Mock abspath used in parse_arguments
|
||||
mock_isfile.return_value = False # Mock isfile called by validate_input_csv
|
||||
|
||||
mock_args = argparse.Namespace(
|
||||
input_csv="nonexistent.csv",
|
||||
style_params_json="styles.json",
|
||||
output_dir="output",
|
||||
enable_cdg=False,
|
||||
enable_txt=False,
|
||||
log_level=logging.INFO, # parse_arguments now converts level to int
|
||||
dry_run=False,
|
||||
)
|
||||
mock_parser_instance.parse_args.return_value = mock_args # Mock return of parse_args
|
||||
|
||||
# Use pytest.raises to check for the expected exception from _parse_and_validate_args
|
||||
with pytest.raises(FileNotFoundError) as excinfo:
|
||||
bulk_cli._parse_and_validate_args() # Call the target function
|
||||
|
||||
# Assertions
|
||||
# Check the exception message (raised by _parse_and_validate_args)
|
||||
assert "Input CSV file not found: /abs/nonexistent.csv" in str(excinfo.value)
|
||||
# Verify logger.error was called by validate_input_csv (called by _parse_and_validate_args)
|
||||
mock_logger.error.assert_called_once_with("Input CSV file not found: /abs/nonexistent.csv")
|
||||
# Verify os.path.isfile was called
|
||||
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("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(
|
||||
mock_open_file, mock_getcwd, mock_chdir, mock_exists, mock_kfinalise, mock_kprep,
|
||||
mock_args, mock_logger, mock_log_formatter
|
||||
):
|
||||
"""Test process_track_render raises FileNotFoundError if style JSON not found when CDG enabled."""
|
||||
row = {"Artist": "CDG Artist", "Title": "CDG Title", "Mixed Audio Filename": "mix_cdg.mp3", "Instrumental Audio Filename": "inst_cdg.mp3"}
|
||||
mock_args.enable_cdg = True # Enable CDG
|
||||
mock_args.style_params_json = "/fake/styles.json"
|
||||
|
||||
# Use pytest.raises to check for the expected exception
|
||||
with pytest.raises(FileNotFoundError) as excinfo:
|
||||
await bulk_cli.process_track_render(row, mock_args, mock_logger, mock_log_formatter)
|
||||
|
||||
# Assertions
|
||||
mock_open_file.assert_called_once_with(mock_args.style_params_json, "r")
|
||||
# Check the exception message
|
||||
assert f"CDG styles configuration file not found: {mock_args.style_params_json}" in str(excinfo.value)
|
||||
# KaraokeFinalise should not have been initialized if style loading fails early
|
||||
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("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(
|
||||
mock_open_file, mock_getcwd, mock_chdir, mock_exists, mock_kfinalise, mock_kprep,
|
||||
mock_args, mock_logger, mock_log_formatter
|
||||
):
|
||||
"""Test process_track_render raises ValueError if style JSON is invalid when CDG enabled."""
|
||||
row = {"Artist": "CDG Artist", "Title": "CDG Title", "Mixed Audio Filename": "mix_cdg.mp3", "Instrumental Audio Filename": "inst_cdg.mp3"}
|
||||
mock_args.enable_cdg = True # Enable CDG
|
||||
mock_args.style_params_json = "/fake/styles.json"
|
||||
|
||||
# Use pytest.raises to check for the expected exception
|
||||
with pytest.raises(ValueError) as excinfo:
|
||||
await bulk_cli.process_track_render(row, mock_args, mock_logger, mock_log_formatter)
|
||||
|
||||
# Assertions
|
||||
mock_open_file.assert_called_once_with(mock_args.style_params_json, "r")
|
||||
# Check the exception message
|
||||
assert "Invalid JSON in CDG styles configuration file:" in str(excinfo.value)
|
||||
# KaraokeFinalise should not have been initialized if style loading fails early
|
||||
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")
|
||||
@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,
|
||||
mock_args, mock_logger, mock_log_formatter
|
||||
):
|
||||
"""Test process_track_render logs error if track directory is not found."""
|
||||
row = {"Artist": "NoDir Artist", "Title": "NoDir Title", "Mixed Audio Filename": "mix_nodir.mp3", "Instrumental Audio Filename": "inst_nodir.mp3"}
|
||||
|
||||
result = await bulk_cli.process_track_render(row, mock_args, mock_logger, mock_log_formatter)
|
||||
|
||||
# Should still return True overall for the row processing attempt, but log an error
|
||||
assert result is True # Continue with other tracks
|
||||
mock_kfinalise.assert_called_once()
|
||||
mock_kfinalise.return_value.process.assert_not_called() # Should never call process since dirs not found
|
||||
|
||||
# Check that os.path.exists was called for all potential directories
|
||||
assert mock_exists.call_count >= 3
|
||||
|
||||
# Validate error logging
|
||||
error_message = mock_logger.error.call_args[0][0]
|
||||
assert "Track directory not found. Tried:" in error_message
|
||||
assert "NoDir Artist - NoDir Title" in error_message
|
||||
|
||||
# Should never change directory if no directory exists
|
||||
mock_chdir.assert_not_called()
|
||||
|
||||
|
||||
# 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
|
||||
@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
|
||||
mock_args, mock_logger, mock_log_formatter # Keep necessary fixtures
|
||||
):
|
||||
"""Test async_main correctly handles the dry_run flag."""
|
||||
|
||||
# --- Mock Configuration ---
|
||||
# 1. Configure mock_args fixture to have dry_run = True
|
||||
mock_args.dry_run = True
|
||||
|
||||
# 2. Mock _parse_and_validate_args to return the modified mock_args
|
||||
mock_parse_args.return_value = mock_args
|
||||
|
||||
# 3. Mock _read_csv_file
|
||||
sample_rows = list(csv.DictReader(SAMPLE_CSV_DATA.splitlines()))
|
||||
mock_read_csv.return_value = sample_rows
|
||||
|
||||
# 4. Mock setup_logging
|
||||
mock_setup_logging.return_value = mock_log_formatter
|
||||
|
||||
# 5. Mock process_csv_rows
|
||||
mock_process_rows.return_value = {"summary": "dry run results"}
|
||||
|
||||
# --- Inject Mocks & Run ---
|
||||
# Ensure setup_logging returns the formatter when called
|
||||
mock_setup_logging.return_value = mock_log_formatter
|
||||
bulk_cli.log_formatter = mock_log_formatter # Set global formatter
|
||||
|
||||
# Run async_main
|
||||
result = await bulk_cli.async_main()
|
||||
|
||||
# --- Assertions ---
|
||||
# 1. Check _parse_and_validate_args called
|
||||
mock_parse_args.assert_called_once()
|
||||
|
||||
# 2. Check logger level was set and info message logged directly on module logger
|
||||
mock_bulk_cli_logger.setLevel.assert_called_with(mock_args.log_level)
|
||||
mock_bulk_cli_logger.info.assert_any_call("Dry run mode enabled. No changes will be made.")
|
||||
# No need to assert setup_logging call for level setting
|
||||
|
||||
# 3. Check _read_csv_file called
|
||||
mock_read_csv.assert_called_once_with(mock_args.input_csv)
|
||||
|
||||
# 4. Check process_csv_rows was awaited with dry_run=True in args, passing the patched module logger
|
||||
mock_process_rows.assert_awaited_once_with(
|
||||
mock_args.input_csv,
|
||||
sample_rows,
|
||||
mock_args, # Ensure the args object passed has dry_run=True
|
||||
mock_bulk_cli_logger, # Pass the patched module logger
|
||||
mock_log_formatter
|
||||
)
|
||||
# Verify the args passed to process_csv_rows had dry_run=True
|
||||
call_args, _ = mock_process_rows.call_args
|
||||
passed_args_obj = call_args[2]
|
||||
assert passed_args_obj.dry_run is True
|
||||
|
||||
# 5. Check result
|
||||
assert result == {"summary": "dry run results"}
|
||||
|
||||
# Note: The check for update_csv_status *not* being called is now implicitly
|
||||
# handled by testing process_csv_rows directly (like in test_process_csv_rows_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("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(
|
||||
mock_open_file, mock_getcwd, mock_chdir, mock_exists, mock_kfinalise, mock_kprep,
|
||||
mock_args, mock_logger, mock_log_formatter
|
||||
):
|
||||
"""Test process_track_render correctly loads CDG styles when enabled."""
|
||||
mock_kprep_instance = AsyncMock()
|
||||
mock_kprep.return_value = mock_kprep_instance
|
||||
mock_kprep_instance.process = AsyncMock(return_value=[{"artist": "CDG Artist", "title": "CDG Title"}])
|
||||
mock_kfinalise_instance = mock_kfinalise.return_value
|
||||
mock_kfinalise_instance.process = MagicMock(return_value={"final": "track"})
|
||||
|
||||
row = {"Artist": "CDG Artist", "Title": "CDG Title", "Mixed Audio Filename": "mix_cdg.mp3", "Instrumental Audio Filename": "inst_cdg.mp3"}
|
||||
mock_args.enable_cdg = True # Enable CDG
|
||||
expected_cdg_styles = {"some_style": "value"}
|
||||
|
||||
result = await bulk_cli.process_track_render(row, mock_args, mock_logger, mock_log_formatter)
|
||||
|
||||
assert result is True
|
||||
mock_kprep.assert_called_once() # Prep called
|
||||
mock_open_file.assert_called_once_with(mock_args.style_params_json, "r") # Style file opened
|
||||
|
||||
# Check KaraokeFinalise call with CDG styles
|
||||
mock_kfinalise.assert_called_once_with(
|
||||
log_formatter=mock_log_formatter,
|
||||
log_level=mock_args.log_level,
|
||||
dry_run=mock_args.dry_run,
|
||||
enable_cdg=True,
|
||||
enable_txt=False,
|
||||
cdg_styles=expected_cdg_styles, # Check styles are passed
|
||||
non_interactive=True,
|
||||
)
|
||||
mock_kfinalise_instance.process.assert_called_once()
|
||||
|
||||
|
||||
@patch(mock_module_paths["StreamHandler"])
|
||||
@patch(mock_module_paths["Formatter"])
|
||||
@patch(mock_module_paths["logger"])
|
||||
def test_setup_logging(mock_logger, mock_formatter, mock_handler):
|
||||
"""Test that setup_logging configures logging correctly."""
|
||||
# Create mock objects to check the output
|
||||
mock_handler_instance = MagicMock()
|
||||
mock_handler.return_value = mock_handler_instance
|
||||
|
||||
mock_formatter_instance = MagicMock()
|
||||
mock_formatter.return_value = mock_formatter_instance
|
||||
|
||||
# Call the function under test with DEBUG level
|
||||
result = bulk_cli.setup_logging(logging.DEBUG)
|
||||
|
||||
# Verify formatter was created with expected format
|
||||
mock_formatter.assert_called_once()
|
||||
format_args = mock_formatter.call_args[1]
|
||||
assert "fmt" in format_args
|
||||
assert "datefmt" in format_args
|
||||
assert "%(levelname)s" in format_args["fmt"]
|
||||
assert "%Y-%m-%d" in format_args["datefmt"]
|
||||
|
||||
# Verify handler was created and configured
|
||||
mock_handler.assert_called_once()
|
||||
mock_handler_instance.setFormatter.assert_called_once_with(mock_formatter_instance)
|
||||
|
||||
# Verify logger was configured
|
||||
mock_logger.addHandler.assert_called_once_with(mock_handler_instance)
|
||||
mock_logger.setLevel.assert_called_once_with(logging.DEBUG)
|
||||
|
||||
# Verify the return value
|
||||
assert result == mock_formatter_instance
|
||||
|
||||
|
||||
@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)
|
||||
@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."""
|
||||
# Configure the mocks with return values for each call
|
||||
mock_process_prep.side_effect = [True, False] # First success, then fail
|
||||
mock_process_render.side_effect = [True, False, True, True] # Add enough return values
|
||||
|
||||
# Create test CSV rows
|
||||
rows = [
|
||||
{"Artist": "Artist One", "Title": "Title One", "Mixed Audio Filename": "mix1.mp3", "Instrumental Audio Filename": "inst1.mp3", "Status": "Uploaded"},
|
||||
{"Artist": "Artist Two", "Title": "Title Two", "Mixed Audio Filename": "mix2.mp3", "Instrumental Audio Filename": "inst2.mp3", "Status": "Uploaded"},
|
||||
{"Artist": "Artist Three", "Title": "Title Three", "Mixed Audio Filename": "mix3.mp3", "Instrumental Audio Filename": "inst3.mp3", "Status": "Prep_Complete"},
|
||||
{"Artist": "Artist Four", "Title": "Title Four", "Mixed Audio Filename": "mix4.mp3", "Instrumental Audio Filename": "inst4.mp3", "Status": "Prep_Complete"},
|
||||
{"Artist": "Artist Five", "Title": "Title Five", "Mixed Audio Filename": "mix5.mp3", "Instrumental Audio Filename": "inst5.mp3", "Status": "Completed"}
|
||||
]
|
||||
|
||||
# Call the function under test
|
||||
csv_path = "/fake/test.csv"
|
||||
results = await bulk_cli.process_csv_rows(csv_path, rows, mock_args, mock_logger, mock_log_formatter)
|
||||
|
||||
# Verify process_track_prep was called for uploaded tracks
|
||||
assert mock_process_prep.call_count == 2
|
||||
mock_process_prep.assert_any_call(rows[0], mock_args, mock_logger, mock_log_formatter)
|
||||
mock_process_prep.assert_any_call(rows[1], mock_args, mock_logger, mock_log_formatter)
|
||||
|
||||
# Verify process_track_render was called for 'uploaded' and 'prep_complete' tracks
|
||||
# With our changes to process_csv_rows, it's now called for each track
|
||||
assert mock_process_render.call_count == 4 # Updated from 2 to 4
|
||||
mock_process_render.assert_any_call(rows[0], mock_args, mock_logger, mock_log_formatter)
|
||||
mock_process_render.assert_any_call(rows[1], mock_args, mock_logger, mock_log_formatter)
|
||||
mock_process_render.assert_any_call(rows[2], mock_args, mock_logger, mock_log_formatter)
|
||||
mock_process_render.assert_any_call(rows[3], mock_args, mock_logger, mock_log_formatter)
|
||||
|
||||
# Verify update_csv_status was called for each processed track
|
||||
assert mock_update_csv.call_count == 6 # Updated from 4 to 6
|
||||
|
||||
# Verify skipped track
|
||||
assert results["skipped"] == 3 # Updated from 1 to 3
|
||||
|
||||
# Verify success and failure counts
|
||||
assert results["prep_success"] == 1
|
||||
assert results["prep_failed"] == 1
|
||||
assert results["render_success"] == 3 # Updated expected success count
|
||||
assert results["render_failed"] == 1 # Updated expected failure count
|
||||
|
||||
|
||||
@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)
|
||||
@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."""
|
||||
# Configure the mocks
|
||||
mock_process_prep.return_value = True
|
||||
mock_process_render.return_value = True
|
||||
mock_args.dry_run = True
|
||||
|
||||
# Create a single test row
|
||||
rows = [
|
||||
{"Artist": "Artist One", "Title": "Title One", "Mixed Audio Filename": "mix1.mp3", "Instrumental Audio Filename": "inst1.mp3", "Status": "Uploaded"}
|
||||
]
|
||||
|
||||
# Call the function
|
||||
csv_path = "/fake/test.csv"
|
||||
results = await bulk_cli.process_csv_rows(csv_path, rows, mock_args, mock_logger, mock_log_formatter)
|
||||
|
||||
# Verify process_track_prep was called
|
||||
mock_process_prep.assert_called_once()
|
||||
|
||||
# Verify update_csv_status was NOT called
|
||||
mock_update_csv.assert_not_called()
|
||||
|
||||
# Verify results
|
||||
assert results["prep_success"] == 1
|
||||
assert results["prep_failed"] == 0
|
||||
@@ -1,248 +0,0 @@
|
||||
import os
|
||||
import pytest
|
||||
import glob
|
||||
import shutil
|
||||
from unittest.mock import MagicMock, patch, mock_open, call, DEFAULT
|
||||
from karaoke_prep.karaoke_prep import KaraokePrep
|
||||
import yt_dlp # Keep import for patching target
|
||||
from karaoke_prep.utils import sanitize_filename # Import utility
|
||||
|
||||
class TestFileOperations:
|
||||
def test_copy_input_media(self, basic_karaoke_prep, temp_dir):
|
||||
"""Test copying input media to a new location."""
|
||||
# Setup
|
||||
source_file = os.path.join(temp_dir, "source.mp4")
|
||||
with open(source_file, "w") as f:
|
||||
f.write("test content")
|
||||
|
||||
output_filename = os.path.join(temp_dir, "output")
|
||||
|
||||
# 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)
|
||||
|
||||
# Verify the correct file path was returned
|
||||
assert result == output_filename + ".mp4"
|
||||
|
||||
# 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):
|
||||
"""Test copying input media when source and destination are the same."""
|
||||
# Setup
|
||||
file_path = os.path.join(temp_dir, "file.mp4")
|
||||
with open(file_path, "w") as f:
|
||||
f.write("test content")
|
||||
|
||||
# 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])
|
||||
|
||||
# Verify the correct file path was returned
|
||||
assert result == file_path
|
||||
|
||||
def test_download_video(self, basic_karaoke_prep, temp_dir):
|
||||
"""Test downloading a video from a URL."""
|
||||
url = "https://example.com/video"
|
||||
output_filename = os.path.join(temp_dir, "output")
|
||||
downloaded_file = output_filename + ".mp4"
|
||||
|
||||
# Mock the yt_dlp.YoutubeDL context manager and its methods
|
||||
mock_ydl_instance = MagicMock()
|
||||
# Mock extract_info to prevent network calls during download process
|
||||
mock_ydl_instance.extract_info.return_value = {'id': 'video_id', 'formats': [], 'ext': 'mp4'}
|
||||
# Completely mock the download method to do nothing
|
||||
mock_ydl_instance.download = MagicMock(return_value=None)
|
||||
|
||||
# Mock glob.glob to return our "downloaded" file
|
||||
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, \
|
||||
patch('glob.glob', return_value=mock_glob_result):
|
||||
|
||||
# Configure the context manager to return our mock instance
|
||||
mock_ydl_context.return_value.__enter__.return_value = mock_ydl_instance
|
||||
|
||||
# Create the file that glob will "find"
|
||||
os.makedirs(os.path.dirname(downloaded_file), exist_ok=True)
|
||||
with open(downloaded_file, "w") as f:
|
||||
f.write("test video content")
|
||||
|
||||
# Call the method
|
||||
result = basic_karaoke_prep.file_handler.download_video(url, output_filename)
|
||||
|
||||
# Verify the correct file path was returned
|
||||
assert result == downloaded_file
|
||||
|
||||
# Verify ydl was instantiated with correct options
|
||||
expected_ydl_opts = {
|
||||
"quiet": True,
|
||||
"format": "bv*+ba/b",
|
||||
"outtmpl": f"{output_filename}.%(ext)s",
|
||||
"user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.169 Safari/537.36",
|
||||
}
|
||||
mock_ydl_context.assert_called_once_with(expected_ydl_opts)
|
||||
|
||||
# Verify download was called on the instance
|
||||
mock_ydl_instance.download.assert_called_once_with([url])
|
||||
|
||||
# Verify glob was called
|
||||
glob.glob.assert_called_once_with(f"{output_filename}.*")
|
||||
|
||||
def test_download_video_no_files_found(self, basic_karaoke_prep):
|
||||
"""Test downloading a video when no files are found after download."""
|
||||
url = "https://example.com/video"
|
||||
output_filename = "output"
|
||||
|
||||
# Mock the yt_dlp.YoutubeDL context manager and its methods
|
||||
mock_ydl_instance = MagicMock()
|
||||
# Mock extract_info to prevent network calls during download process
|
||||
mock_ydl_instance.extract_info.return_value = {'id': 'video_id', 'formats': [], 'ext': 'mp4'}
|
||||
# Completely mock the download method to do nothing
|
||||
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, \
|
||||
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)
|
||||
|
||||
# Verify None was returned
|
||||
assert result is None
|
||||
|
||||
# Verify ydl was instantiated
|
||||
mock_ydl_context.assert_called_once()
|
||||
|
||||
# Verify download was called on the instance
|
||||
mock_ydl_instance.download.assert_called_once_with([url])
|
||||
|
||||
# Verify glob was called
|
||||
glob.glob.assert_called_once_with(f"{output_filename}.*")
|
||||
|
||||
def test_extract_still_image_from_video(self, basic_karaoke_prep):
|
||||
"""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)
|
||||
|
||||
# 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"'
|
||||
mock_os_system.assert_called_once_with(expected_command)
|
||||
|
||||
def test_convert_to_wav_success(self, basic_karaoke_prep, temp_dir):
|
||||
"""Test converting input audio to WAV format successfully."""
|
||||
# Create a test input file
|
||||
input_filename = os.path.join(temp_dir, "input.mp3")
|
||||
with open(input_filename, "w") as f:
|
||||
f.write("test audio content")
|
||||
|
||||
# Mock os.path.isfile and os.path.getsize
|
||||
with patch('os.path.isfile', return_value=True), \
|
||||
patch('os.path.getsize', return_value=100), \
|
||||
patch('os.popen') as mock_popen:
|
||||
|
||||
# Mock the ffprobe output
|
||||
mock_popen.return_value.read.return_value = "codec_type=audio"
|
||||
|
||||
output_filename = os.path.join(temp_dir, "output")
|
||||
|
||||
# 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)
|
||||
|
||||
# Verify the correct file path was returned
|
||||
assert result == output_filename + ".wav"
|
||||
|
||||
# Verify os.system was called
|
||||
mock_os_system.assert_called_once()
|
||||
|
||||
def test_convert_to_wav_file_not_found(self, basic_karaoke_prep):
|
||||
"""Test converting input audio when the file is not found."""
|
||||
input_filename = "nonexistent.mp3"
|
||||
output_filename = "output"
|
||||
|
||||
# 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)
|
||||
|
||||
def test_convert_to_wav_empty_file(self, basic_karaoke_prep):
|
||||
"""Test converting input audio when the file is empty."""
|
||||
input_filename = "empty.mp3"
|
||||
output_filename = "output"
|
||||
|
||||
# Mock os.path.isfile to return True and os.path.getsize to return 0
|
||||
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)
|
||||
|
||||
def test_convert_to_wav_no_audio_stream(self, basic_karaoke_prep):
|
||||
"""Test converting input audio when no audio stream is found."""
|
||||
input_filename = "no_audio.mp4"
|
||||
output_filename = "output"
|
||||
|
||||
# Mock os.path.isfile, os.path.getsize, and os.popen
|
||||
with patch('os.path.isfile', return_value=True), \
|
||||
patch('os.path.getsize', return_value=100), \
|
||||
patch('os.popen') as mock_popen:
|
||||
|
||||
# Mock the ffprobe output to indicate no audio stream
|
||||
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)
|
||||
|
||||
def test_sanitize_filename(self, basic_karaoke_prep):
|
||||
"""Test sanitizing filenames."""
|
||||
# Test with various problematic characters
|
||||
assert sanitize_filename('file/with\\chars:*?"<>|') == 'file_with_chars_'
|
||||
assert sanitize_filename(" leading spaces") == "leading spaces"
|
||||
assert sanitize_filename("trailing spaces ") == "trailing spaces"
|
||||
assert sanitize_filename("trailing dots...") == "trailing dots"
|
||||
assert sanitize_filename("multiple spaces") == "multiple spaces"
|
||||
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):
|
||||
"""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")
|
||||
|
||||
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")
|
||||
|
||||
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):
|
||||
"""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")
|
||||
|
||||
assert artist_title == "Test Title"
|
||||
assert track_output_dir == temp_dir
|
||||
|
||||
def test_setup_output_paths_no_inputs(self, basic_karaoke_prep):
|
||||
"""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)
|
||||
@@ -1,657 +0,0 @@
|
||||
import pytest
|
||||
import asyncio
|
||||
import argparse
|
||||
import os
|
||||
import logging
|
||||
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
|
||||
|
||||
# Mark all tests in this module as asyncio
|
||||
pytestmark = pytest.mark.asyncio
|
||||
|
||||
# Sample style params JSON
|
||||
SAMPLE_STYLE_JSON = '{"cdg": {"some_style": "value"}}'
|
||||
|
||||
# Mock return value for KaraokeFinalise.process
|
||||
MOCK_FINAL_TRACK = {
|
||||
"artist": "Test Artist",
|
||||
"title": "Test Title",
|
||||
"video_with_vocals": "test_wv.mp4",
|
||||
"video_with_instrumental": "test_wi.mp4",
|
||||
"final_video": "test_final.mp4",
|
||||
"final_video_mkv": "test_final.mkv",
|
||||
"final_video_lossy": "test_final_lossy.mp4",
|
||||
"final_video_720p": "test_final_720p.mp4",
|
||||
"final_karaoke_cdg_zip": "test_cdg.zip",
|
||||
"final_karaoke_txt_zip": "test_txt.zip",
|
||||
"brand_code": "TEST-0001",
|
||||
"new_brand_code_dir_path": "/path/to/TEST-0001 - Test Artist - Test Title",
|
||||
"youtube_url": "https://youtube.com/watch?v=1234",
|
||||
"brand_code_dir_sharing_link": "https://share.link/folder",
|
||||
}
|
||||
|
||||
# Mock return value for KaraokePrep.process
|
||||
MOCK_PREP_TRACK = {
|
||||
"artist": "Test Artist",
|
||||
"title": "Test Title",
|
||||
"input_media": "input.mp3",
|
||||
"input_audio_wav": "input.wav",
|
||||
"input_still_image": "input.jpg",
|
||||
"lyrics": "lyrics.txt",
|
||||
"processed_lyrics": "lyrics.json",
|
||||
"track_output_dir": "/fake/output/Test Artist - Test Title",
|
||||
"separated_audio": {
|
||||
"clean_instrumental": {"instrumental": "inst.flac", "vocals": "vocals.flac"},
|
||||
"other_stems": {"model1": {"bass": "bass.flac", "drums": "drums.flac"}},
|
||||
"backing_vocals": {"model2": {"backing": "backing.flac"}},
|
||||
"combined_instrumentals": {"model1": "combined_inst.flac"},
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_base_args():
|
||||
"""Fixture for common mock command line arguments."""
|
||||
# Most args will be added/overridden in tests
|
||||
return argparse.Namespace(
|
||||
args=[], # Positional args
|
||||
prep_only=False,
|
||||
finalise_only=False,
|
||||
edit_lyrics=False,
|
||||
test_email_template=False,
|
||||
skip_transcription=False,
|
||||
skip_separation=False,
|
||||
skip_lyrics=False,
|
||||
lyrics_only=False,
|
||||
log_level="info",
|
||||
dry_run=False,
|
||||
render_bounding_boxes=False,
|
||||
filename_pattern=None,
|
||||
output_dir=".",
|
||||
no_track_subfolders=True, # Corresponds to create_track_subfolders=True
|
||||
lossless_output_format="FLAC",
|
||||
output_png=True,
|
||||
output_jpg=True,
|
||||
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"],
|
||||
model_file_dir="/tmp/audio-separator-models", # Default value might vary
|
||||
existing_instrumental=None,
|
||||
instrumental_format="flac",
|
||||
lyrics_artist=None,
|
||||
lyrics_title=None,
|
||||
lyrics_file=None,
|
||||
subtitle_offset_ms=0,
|
||||
skip_transcription_review=False,
|
||||
style_params_json=None,
|
||||
enable_cdg=False,
|
||||
enable_txt=False,
|
||||
brand_prefix=None,
|
||||
organised_dir=None,
|
||||
organised_dir_rclone_root=None,
|
||||
public_share_dir=None,
|
||||
youtube_client_secrets_file=None,
|
||||
youtube_description_file=None,
|
||||
rclone_destination=None,
|
||||
discord_webhook_url=None,
|
||||
email_template_file=None,
|
||||
keep_brand_code=False,
|
||||
yes=False, # non_interactive
|
||||
)
|
||||
|
||||
@pytest.fixture
|
||||
def mock_logger():
|
||||
"""Fixture for a mock logger."""
|
||||
logger = MagicMock(spec=logging.Logger)
|
||||
logger.level = logging.INFO # Default level
|
||||
return logger
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def mock_pyperclip():
|
||||
"""Automatically mock pyperclip."""
|
||||
with patch("karaoke_prep.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:
|
||||
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
|
||||
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"]
|
||||
mock_kprep_instance = MagicMock()
|
||||
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:
|
||||
mock_parser.return_value.parse_args.return_value = mock_base_args
|
||||
await gen_cli.async_main()
|
||||
|
||||
mock_kprep_class.assert_called_once()
|
||||
# Verify that input_media=URL is passed
|
||||
assert mock_kprep_class.call_args.kwargs["input_media"] == "https://example.com/song.mp3"
|
||||
mock_kprep_instance.process.assert_awaited_once()
|
||||
# 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
|
||||
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"]
|
||||
mock_kprep_instance = MagicMock()
|
||||
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:
|
||||
mock_parser.return_value.parse_args.return_value = mock_base_args
|
||||
await gen_cli.async_main()
|
||||
|
||||
mock_kprep_class.assert_called_once()
|
||||
call_kwargs = mock_kprep_class.call_args.kwargs
|
||||
assert call_kwargs["input_media"] == "http://example.com/video.mp4"
|
||||
assert call_kwargs["artist"] == "URL Artist"
|
||||
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
|
||||
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"]
|
||||
mock_kprep_instance = MagicMock()
|
||||
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:
|
||||
mock_parser.return_value.parse_args.return_value = mock_base_args
|
||||
await gen_cli.async_main()
|
||||
|
||||
mock_kprep_class.assert_called_once()
|
||||
call_kwargs = mock_kprep_class.call_args.kwargs
|
||||
assert call_kwargs["input_media"] == "/path/to/song.mp3"
|
||||
assert call_kwargs["artist"] == "File Artist"
|
||||
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
|
||||
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"]
|
||||
mock_kprep_instance = MagicMock()
|
||||
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:
|
||||
mock_parser.return_value.parse_args.return_value = mock_base_args
|
||||
await gen_cli.async_main()
|
||||
|
||||
mock_kprep_class.assert_called_once()
|
||||
# Verify that artist and title are passed, but not input_media
|
||||
assert mock_kprep_class.call_args.kwargs["artist"] == "Test Artist"
|
||||
assert mock_kprep_class.call_args.kwargs["title"] == "Test Title"
|
||||
assert mock_kprep_class.call_args.kwargs["input_media"] is None
|
||||
mock_kprep_instance.process.assert_awaited_once()
|
||||
# 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
|
||||
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"]
|
||||
mock_base_args.filename_pattern = r"(?P<index>\d+) - (?P<title>.+)\.mp3"
|
||||
mock_kprep_instance = MagicMock()
|
||||
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:
|
||||
mock_parser.return_value.parse_args.return_value = mock_base_args
|
||||
await gen_cli.async_main()
|
||||
|
||||
mock_kprep_class.assert_called_once()
|
||||
call_kwargs = mock_kprep_class.call_args.kwargs
|
||||
assert call_kwargs["input_media"] == "/path/to/folder"
|
||||
assert call_kwargs["artist"] == "Folder Artist"
|
||||
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")
|
||||
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):
|
||||
mock_parser.return_value.parse_args.return_value = mock_base_args
|
||||
await gen_cli.async_main()
|
||||
|
||||
# Just check that logger.error was called and exit was called
|
||||
assert mock_logger.error.called
|
||||
mock_exit.assert_called_once_with(1)
|
||||
|
||||
# --- 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
|
||||
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"]
|
||||
mock_base_args.prep_only = True
|
||||
mock_kprep_instance = MagicMock()
|
||||
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):
|
||||
mock_parser.return_value.parse_args.return_value = mock_base_args
|
||||
await gen_cli.async_main()
|
||||
|
||||
mock_kprep_class.assert_called_once()
|
||||
mock_kprep_instance.process.assert_awaited_once()
|
||||
mock_kfinalise.assert_not_called() # Finalise should be skipped
|
||||
# We'll just verify that the app exits correctly without checking specific log messages
|
||||
assert mock_logger.info.called
|
||||
|
||||
|
||||
@patch("karaoke_prep.utils.gen_cli.KaraokePrep") # Should not be called
|
||||
@patch("karaoke_prep.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."""
|
||||
mock_base_args.finalise_only = True
|
||||
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):
|
||||
mock_parser.return_value.parse_args.return_value = mock_base_args
|
||||
await gen_cli.async_main()
|
||||
|
||||
mock_kprep.assert_not_called() # Prep should be skipped
|
||||
mock_kfinalise.assert_called_once()
|
||||
mock_kfinalise_instance.process.assert_called_once()
|
||||
# Just verify that we do log something
|
||||
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("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."""
|
||||
mock_base_args.edit_lyrics = True
|
||||
mock_base_args.enable_cdg = False # Simplify for now
|
||||
|
||||
# Set up the KaraokePrep mock properly
|
||||
mock_kprep_instance = MagicMock() # Instance mock
|
||||
mock_kprep_class.return_value = mock_kprep_instance
|
||||
# Mock the file_handler attribute and its backup_existing_outputs method
|
||||
mock_file_handler = MagicMock()
|
||||
mock_file_handler.backup_existing_outputs = MagicMock(return_value="/fake/path/Edit Artist - Edit Title/input.wav")
|
||||
mock_kprep_instance.file_handler = mock_file_handler
|
||||
mock_kprep_instance.process = AsyncMock(return_value=[MOCK_PREP_TRACK]) # Async method
|
||||
|
||||
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:
|
||||
mock_parser.return_value.parse_args.return_value = mock_base_args
|
||||
await gen_cli.async_main()
|
||||
|
||||
# Check Prep call
|
||||
mock_kprep_class.assert_called_once()
|
||||
prep_call_kwargs = mock_kprep_class.call_args.kwargs
|
||||
assert prep_call_kwargs["artist"] == "Edit Artist"
|
||||
assert prep_call_kwargs["title"] == "Edit Title"
|
||||
assert prep_call_kwargs["input_media"] is None # Set to None initially
|
||||
assert prep_call_kwargs["skip_separation"] is True # Should skip separation in edit mode
|
||||
assert prep_call_kwargs["skip_lyrics"] is False
|
||||
assert prep_call_kwargs["skip_transcription"] is False
|
||||
assert prep_call_kwargs["create_track_subfolders"] is False # Already in folder
|
||||
|
||||
# Assert that the mocked method on the file_handler was called
|
||||
mock_kprep_instance.file_handler.backup_existing_outputs.assert_called_once()
|
||||
mock_kprep_instance.process.assert_awaited_once()
|
||||
|
||||
# Check Finalise call
|
||||
mock_kfinalise.assert_called_once()
|
||||
finalise_call_kwargs = mock_kfinalise.call_args.kwargs
|
||||
assert finalise_call_kwargs["keep_brand_code"] is True # Should keep brand code
|
||||
assert finalise_call_kwargs["non_interactive"] is False # Default unless -y
|
||||
|
||||
mock_kfinalise_instance.process.assert_called_once_with(replace_existing=True) # Should replace
|
||||
|
||||
|
||||
@patch("karaoke_prep.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):
|
||||
mock_parser.return_value.parse_args.return_value = mock_base_args
|
||||
await gen_cli.async_main()
|
||||
|
||||
mock_kfinalise.assert_called_once()
|
||||
finalise_call_kwargs = mock_kfinalise.call_args.kwargs
|
||||
assert finalise_call_kwargs["email_template_file"] == "template.txt"
|
||||
mock_kfinalise_instance.test_email_template.assert_called_once()
|
||||
assert mock_logger.info.called
|
||||
|
||||
|
||||
@patch("karaoke_prep.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
|
||||
@patch("karaoke_prep.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"]
|
||||
mock_base_args.lyrics_only = True
|
||||
mock_kprep_instance = MagicMock()
|
||||
mock_kprep_class.return_value = mock_kprep_instance
|
||||
mock_kprep_instance.process = AsyncMock(return_value=[MOCK_PREP_TRACK])
|
||||
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:
|
||||
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
|
||||
await gen_cli.async_main()
|
||||
|
||||
# Since we can't reliably test the os.environ, check that skip_separation was set
|
||||
mock_kprep_class.assert_called_once()
|
||||
prep_kwargs = mock_kprep_class.call_args.kwargs
|
||||
assert prep_kwargs["skip_separation"] is True
|
||||
mock_kprep_instance.process.assert_awaited_once()
|
||||
assert mock_logger.info.called
|
||||
|
||||
|
||||
# --- 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("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
|
||||
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"]
|
||||
mock_base_args.enable_cdg = True
|
||||
mock_base_args.style_params_json = "/fake/styles.json"
|
||||
expected_cdg_styles = {"some_style": "value"}
|
||||
|
||||
mock_kprep_instance = MagicMock()
|
||||
mock_kprep_class.return_value = mock_kprep_instance
|
||||
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:
|
||||
mock_parser.return_value.parse_args.return_value = mock_base_args
|
||||
await gen_cli.async_main()
|
||||
|
||||
mock_kprep_instance.process.assert_awaited_once()
|
||||
# Check open was called for the style file
|
||||
mock_open.assert_called_with("/fake/styles.json", "r")
|
||||
|
||||
# Check KaraokeFinalise was called with the loaded styles
|
||||
mock_kfinalise.assert_called_once()
|
||||
finalise_call_kwargs = mock_kfinalise.call_args.kwargs
|
||||
assert finalise_call_kwargs["enable_cdg"] is True
|
||||
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("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")
|
||||
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"]
|
||||
mock_base_args.enable_cdg = True
|
||||
mock_base_args.style_params_json = "/fake/styles.json"
|
||||
|
||||
mock_kprep_instance = MagicMock()
|
||||
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):
|
||||
mock_parser.return_value.parse_args.return_value = mock_base_args
|
||||
await gen_cli.async_main()
|
||||
|
||||
mock_kprep_instance.process.assert_awaited_once()
|
||||
mock_open.assert_called_with("/fake/styles.json", "r")
|
||||
assert mock_logger.error.called
|
||||
mock_exit.assert_called_once_with(1)
|
||||
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("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")
|
||||
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"]
|
||||
mock_base_args.enable_cdg = True
|
||||
mock_base_args.style_params_json = "/fake/styles.json"
|
||||
|
||||
mock_kprep_instance = MagicMock()
|
||||
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):
|
||||
mock_parser.return_value.parse_args.return_value = mock_base_args
|
||||
await gen_cli.async_main()
|
||||
|
||||
mock_kprep_instance.process.assert_awaited_once()
|
||||
mock_open.assert_called_with("/fake/styles.json", "r")
|
||||
# Assert sys.exit was called
|
||||
mock_exit.assert_called_once_with(1)
|
||||
# Verify KaraokeFinalise was not instantiated (we should exit before that)
|
||||
mock_kfinalise.assert_not_called()
|
||||
|
||||
|
||||
@patch("karaoke_prep.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
|
||||
@patch("karaoke_prep.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"]
|
||||
mock_kprep_instance = MagicMock()
|
||||
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:
|
||||
mock_parser.return_value.parse_args.return_value = mock_base_args
|
||||
# Expect the exception to propagate
|
||||
with pytest.raises(Exception, match="KPrep Failed!"):
|
||||
await gen_cli.async_main()
|
||||
|
||||
mock_kprep_class.assert_called_once()
|
||||
mock_kprep_instance.process.assert_awaited_once()
|
||||
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)
|
||||
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"]
|
||||
mock_kprep_instance = MagicMock()
|
||||
mock_kprep_class.return_value = mock_kprep_instance
|
||||
mock_kprep_instance.process = AsyncMock(return_value=[MOCK_PREP_TRACK]) # Prep succeeds
|
||||
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:
|
||||
mock_parser.return_value.parse_args.return_value = mock_base_args
|
||||
# Expect the exception to propagate
|
||||
with pytest.raises(Exception, match="KFinalise Failed!"):
|
||||
await gen_cli.async_main()
|
||||
|
||||
mock_kprep_class.assert_called_once()
|
||||
mock_kprep_instance.process.assert_awaited_once()
|
||||
mock_chdir.assert_called_once_with(MOCK_PREP_TRACK["track_output_dir"]) # Should chdir before finalise
|
||||
mock_kfinalise.assert_called_once() # Finalise is called
|
||||
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
|
||||
|
||||
|
||||
@patch("karaoke_prep.utils.gen_cli.KaraokePrep") # Use default MagicMock for class
|
||||
@patch("karaoke_prep.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"]
|
||||
mock_base_args.render_bounding_boxes = True
|
||||
mock_base_args.skip_separation = True
|
||||
mock_base_args.skip_lyrics = True
|
||||
mock_base_args.skip_transcription = True
|
||||
mock_base_args.skip_transcription_review = True
|
||||
mock_base_args.subtitle_offset_ms = -100
|
||||
mock_base_args.existing_instrumental = "/path/to/inst.wav"
|
||||
mock_base_args.lyrics_artist = "Override Artist"
|
||||
mock_base_args.lyrics_title = "Override Title"
|
||||
mock_base_args.lyrics_file = "/path/to/lyrics.txt"
|
||||
mock_base_args.style_params_json = "/path/to/styles.json"
|
||||
mock_base_args.instrumental_format = "mp3"
|
||||
mock_base_args.yes = True # non_interactive
|
||||
|
||||
mock_kprep_instance = MagicMock()
|
||||
mock_kprep_class.return_value = mock_kprep_instance
|
||||
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):
|
||||
mock_parser.return_value.parse_args.return_value = mock_base_args
|
||||
await gen_cli.async_main()
|
||||
|
||||
# Check KaraokePrep args
|
||||
mock_kprep_class.assert_called_once()
|
||||
prep_kwargs = mock_kprep_class.call_args.kwargs
|
||||
assert prep_kwargs["render_bounding_boxes"] is True
|
||||
assert prep_kwargs["skip_separation"] is True
|
||||
assert prep_kwargs["skip_lyrics"] is True
|
||||
assert prep_kwargs["skip_transcription"] is True
|
||||
assert prep_kwargs["skip_transcription_review"] is True
|
||||
assert prep_kwargs["subtitle_offset_ms"] == -100
|
||||
assert prep_kwargs["existing_instrumental"] == "/path/to/inst.wav"
|
||||
assert prep_kwargs["lyrics_artist"] == "Override Artist"
|
||||
assert prep_kwargs["lyrics_title"] == "Override Title"
|
||||
assert prep_kwargs["lyrics_file"] == "/path/to/lyrics.txt"
|
||||
assert prep_kwargs["style_params_json"] == "/path/to/styles.json"
|
||||
mock_kprep_instance.process.assert_awaited_once()
|
||||
|
||||
# Check KaraokeFinalise args
|
||||
mock_kfinalise.assert_called_once()
|
||||
finalise_kwargs = mock_kfinalise.call_args.kwargs
|
||||
assert finalise_kwargs["instrumental_format"] == "mp3"
|
||||
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")
|
||||
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"]
|
||||
|
||||
# Set up the KaraokePrep mock properly
|
||||
mock_kprep_instance = MagicMock()
|
||||
mock_kprep_class.return_value = mock_kprep_instance
|
||||
mock_kprep_instance.process = AsyncMock(return_value=[MOCK_PREP_TRACK])
|
||||
|
||||
# Ensure mock final track has URLs
|
||||
mock_final_track_with_urls = MOCK_FINAL_TRACK.copy()
|
||||
mock_final_track_with_urls["youtube_url"] = "http://youtu.be/fake"
|
||||
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:
|
||||
mock_parser.return_value.parse_args.return_value = mock_base_args
|
||||
await gen_cli.async_main()
|
||||
|
||||
mock_kprep_instance.process.assert_awaited_once()
|
||||
# Check log capture for success messages
|
||||
assert "(Folder link copied to clipboard)" in caplog.text
|
||||
assert "(YouTube URL copied to clipboard)" in caplog.text
|
||||
|
||||
mock_copy.assert_has_calls([
|
||||
call("http://share.link/fake"),
|
||||
call("http://youtu.be/fake")
|
||||
], 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"))
|
||||
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"]
|
||||
|
||||
# Set up the KaraokePrep mock properly
|
||||
mock_kprep_instance = MagicMock()
|
||||
mock_kprep_class.return_value = mock_kprep_instance
|
||||
mock_kprep_instance.process = AsyncMock(return_value=[MOCK_PREP_TRACK])
|
||||
|
||||
# Ensure mock final track has URLs
|
||||
mock_final_track_with_urls = MOCK_FINAL_TRACK.copy()
|
||||
mock_final_track_with_urls["youtube_url"] = "http://youtu.be/fake"
|
||||
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:
|
||||
mock_parser.return_value.parse_args.return_value = mock_base_args
|
||||
await gen_cli.async_main()
|
||||
|
||||
mock_kprep_instance.process.assert_awaited_once()
|
||||
# Check log capture for warning messages
|
||||
assert "Failed to copy folder link to clipboard: Clipboard Error" in caplog.text
|
||||
assert "Failed to copy YouTube URL to clipboard: Clipboard Error" in caplog.text
|
||||
|
||||
# Verify clipboard calls were attempted
|
||||
mock_copy.assert_has_calls([
|
||||
call("http://share.link/fake"),
|
||||
call("http://youtu.be/fake")
|
||||
], any_order=True)
|
||||
Loaded 100 of 114 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user