lattifai 1.2.1__py3-none-any.whl → 1.3.0__py3-none-any.whl

lattifai/errors.py

@@ -1,10 +1,42 @@
 """Error handling and exception classes for LattifAI SDK."""
 
+import functools
 import traceback
 from typing import Any, Dict, Optional
 
 import colorful
 
+
+def format_exception(e: "LattifAIError") -> str:
+    """Format LattifAIError with filtered traceback (only lattifai frames)."""
+    tb_lines = traceback.format_exception(type(e), e, e.__traceback__)
+    filtered = []
+    skip_next_code_line = False
+
+    for i, line in enumerate(tb_lines):
+        if skip_next_code_line:
+            skip_next_code_line = False
+            continue
+
+        if line.startswith("Traceback") or not line.startswith("  File"):
+            filtered.append(line)
+        elif "lattifai" in line:
+            filtered.append(line)
+            if i + 1 < len(tb_lines) and tb_lines[i + 1].startswith("    "):
+                filtered.append(tb_lines[i + 1])
+                skip_next_code_line = True
+        elif i + 1 < len(tb_lines) and tb_lines[i + 1].startswith("    "):
+            skip_next_code_line = True
+
+    return "".join(filtered)
+
+
+def _merge_context(kwargs: Dict[str, Any], updates: Dict[str, Any]) -> None:
+    """Merge updates into kwargs['context'], creating it if needed."""
+    context = kwargs.setdefault("context", {})
+    context.update(updates)
+
+
 # Error help messages
 LATTICE_DECODING_FAILURE_HELP = (
     "Failed to decode lattice alignment. Possible reasons:\n\n"
@@ -76,10 +108,8 @@ class AudioProcessingError(LattifAIError):
     """Error during audio processing operations."""
 
     def __init__(self, message: str, media_path: Optional[str] = None, **kwargs):
-        context = kwargs.get("context", {})
         if media_path:
-            context["media_path"] = media_path
-        kwargs["context"] = context
+            _merge_context(kwargs, {"media_path": media_path})
         super().__init__(message, **kwargs)
 
 
@@ -90,11 +120,9 @@ class AudioLoadError(AudioProcessingError):
         message = f"Failed to load audio file: {colorful.red(media_path)}"
         if original_error:
             message += f" - {colorful.red(str(original_error))}"
-
-        context = kwargs.get("context", {})
-        context.update({"media_path": media_path, "original_error": str(original_error) if original_error else None})
-        kwargs["context"] = context
-
+        _merge_context(
+            kwargs, {"media_path": media_path, "original_error": str(original_error) if original_error else None}
+        )
         super().__init__(message, media_path=media_path, **kwargs)
 
 
@@ -103,9 +131,7 @@ class AudioFormatError(AudioProcessingError):
 
     def __init__(self, media_path: str, format_issue: str, **kwargs):
         message = f"Audio format error for {colorful.red(media_path)}: {colorful.red(format_issue)}"
-        context = kwargs.get("context", {})
-        context.update({"media_path": media_path, "format_issue": format_issue})
-        kwargs["context"] = context
+        _merge_context(kwargs, {"media_path": media_path, "format_issue": format_issue})
         super().__init__(message, media_path=media_path, **kwargs)
 
 
@@ -113,10 +139,8 @@ class CaptionProcessingError(LattifAIError):
     """Error during caption/text processing operations."""
 
     def __init__(self, message: str, caption_path: Optional[str] = None, **kwargs):
-        context = kwargs.get("context", {})
         if caption_path:
-            context["caption_path"] = caption_path
-        kwargs["context"] = context
+            _merge_context(kwargs, {"caption_path": caption_path})
         super().__init__(message, **kwargs)
 
 
@@ -125,9 +149,7 @@ class CaptionParseError(CaptionProcessingError):
 
     def __init__(self, caption_path: str, parse_issue: str, **kwargs):
         message = f"Failed to parse caption file {caption_path}: {parse_issue}"
-        context = kwargs.get("context", {})
-        context.update({"caption_path": caption_path, "parse_issue": parse_issue})
-        kwargs["context"] = context
+        _merge_context(kwargs, {"caption_path": caption_path, "parse_issue": parse_issue})
         super().__init__(message, caption_path=caption_path, **kwargs)
 
 
@@ -135,12 +157,13 @@ class AlignmentError(LattifAIError):
     """Error during audio-text alignment process."""
 
     def __init__(self, message: str, media_path: Optional[str] = None, caption_path: Optional[str] = None, **kwargs):
-        context = kwargs.get("context", {})
+        updates = {}
         if media_path:
-            context["media_path"] = media_path
+            updates["media_path"] = media_path
         if caption_path:
-            context["caption_path"] = caption_path
-        kwargs["context"] = context
+            updates["caption_path"] = caption_path
+        if updates:
+            _merge_context(kwargs, updates)
         super().__init__(message, **kwargs)
 
 
@@ -151,36 +174,44 @@ class LatticeEncodingError(AlignmentError):
         message = "Failed to generate lattice graph from text"
         if original_error:
             message += f": {colorful.red(str(original_error))}"
-
-        context = kwargs.get("context", {})
-        context.update(
+        text_preview = text_content[:100] + "..." if len(text_content) > 100 else text_content
+        _merge_context(
+            kwargs,
             {
                 "text_content_length": len(text_content),
-                "text_preview": text_content[:100] + "..." if len(text_content) > 100 else text_content,
+                "text_preview": text_preview,
                 "original_error": str(original_error) if original_error else None,
-            }
+            },
         )
-        kwargs["context"] = context
         super().__init__(message, **kwargs)
 
 
 class LatticeDecodingError(AlignmentError):
     """Error decoding lattice alignment results."""
 
-    def __init__(self, lattice_id: str, original_error: Optional[Exception] = None, **kwargs):
-        message = f"Failed to decode lattice alignment results for lattice ID: {colorful.red(lattice_id)}"
+    def __init__(
+        self,
+        lattice_id: str,
+        message: Optional[str] = None,
+        original_error: Optional[Exception] = None,
+        skip_help: bool = False,
+        **kwargs,
+    ):
+        message = message or f"Failed to decode lattice alignment results for lattice ID: {colorful.red(lattice_id)}"
 
-        # Don't duplicate the help message if it's already in original_error
-        if original_error and str(original_error) != LATTICE_DECODING_FAILURE_HELP:
-            message += f" - {colorful.red(str(original_error))}"
+        error_str = str(original_error) if original_error else None
+        is_help_message = error_str == LATTICE_DECODING_FAILURE_HELP
+
+        if original_error and not is_help_message:
+            message += f" - {colorful.red(error_str)}"
+
+        context_updates = {"lattice_id": lattice_id}
+        if original_error and not is_help_message:
+            context_updates["original_error"] = error_str
+        _merge_context(kwargs, context_updates)
 
-        context = kwargs.get("context", {})
-        # Don't store the entire help message in context to avoid duplication
-        if original_error and str(original_error) != LATTICE_DECODING_FAILURE_HELP:
-            context["original_error"] = str(original_error)
-        context["lattice_id"] = lattice_id
-        kwargs["context"] = context
         super().__init__(message, **kwargs)
+        self.skip_help = skip_help
 
     def get_message(self) -> str:
         """Return formatted error message with help text."""
@@ -188,8 +219,9 @@ class LatticeDecodingError(AlignmentError):
         if self.context and self.context.get("lattice_id"):
             # Only show essential context (lattice_id), not the duplicated help message
             base_message += f'\n{colorful.yellow("Lattice ID:")} {self.context["lattice_id"]}'
-        # Append help message once at the end
-        base_message += f"\n\n{colorful.yellow(LATTICE_DECODING_FAILURE_HELP)}"
+        # Append help message only if not skipped (e.g., when anomaly info is provided)
+        if not self.skip_help:
+            base_message += f"\n\n{colorful.yellow(LATTICE_DECODING_FAILURE_HELP)}"
         return base_message
 
 
@@ -200,10 +232,9 @@ class ModelLoadError(LattifAIError):
         message = f"Failed to load model: {colorful.red(model_name)}"
         if original_error:
             message += f" - {colorful.red(str(original_error))}"
-
-        context = kwargs.get("context", {})
-        context.update({"model_name": model_name, "original_error": str(original_error) if original_error else None})
-        kwargs["context"] = context
+        _merge_context(
+            kwargs, {"model_name": model_name, "original_error": str(original_error) if original_error else None}
+        )
         super().__init__(message, **kwargs)
 
 
@@ -214,10 +245,7 @@ class DependencyError(LattifAIError):
         message = f"Missing required dependency: {colorful.red(dependency_name)}"
         if install_command:
             message += f"\nPlease install it using: {colorful.yellow(install_command)}"
-
-        context = kwargs.get("context", {})
-        context.update({"dependency_name": dependency_name, "install_command": install_command})
-        kwargs["context"] = context
+        _merge_context(kwargs, {"dependency_name": dependency_name, "install_command": install_command})
         super().__init__(message, **kwargs)
 
 
@@ -225,9 +253,7 @@ class APIError(LattifAIError):
     """Error communicating with LattifAI API."""
 
     def __init__(self, message: str, status_code: Optional[int] = None, response_text: Optional[str] = None, **kwargs):
-        context = kwargs.get("context", {})
-        context.update({"status_code": status_code, "response_text": response_text})
-        kwargs["context"] = context
+        _merge_context(kwargs, {"status_code": status_code, "response_text": response_text})
         super().__init__(message, **kwargs)
 
 
@@ -249,14 +275,13 @@ class QuotaExceededError(APIError):
 def handle_exception(func):
     """Decorator to handle exceptions and convert them to LattifAI errors."""
 
+    @functools.wraps(func)
     def wrapper(*args, **kwargs):
         try:
             return func(*args, **kwargs)
         except LattifAIError:
-            # Re-raise LattifAI errors as-is
             raise
         except Exception as e:
-            # Convert other exceptions to LattifAI errors
             error_msg = f"Unexpected error in {func.__name__}: {str(e)}"
             context = {
                 "function": func.__name__,

lattifai/event/__init__.py

@@ -0,0 +1,65 @@
+"""Audio Event Detection module for LattifAI.
+
+This module provides audio event detection capabilities, it can identify various
+audio events including speech, music, singing, and demographic characteristics
+(male, female, child voices).
+
+Key Components:
+    LattifAIEventDetector: Main class that wraps lattifai_core's
+        EventDetector for seamless integration with LattifAI workflows.
+
+Features:
+    - Multi-class audio event detection (30+ reduced classes or 400+ full classes)
+    - Voice Activity Detection (VAD) for speech segmentation
+    - Gender/age classification for speech segments
+    - Configurable detection thresholds and top-k filtering
+    - Support for both bundled and custom pretrained models
+
+Detected Event Types:
+    - Speech: General speech activity
+    - Male/Female/Child: Speaker demographic classification
+    - Music: Musical content detection
+    - Singing: Vocal music detection
+    - Synthetic: Synthetic/electronic sounds
+
+Configuration:
+    Use EventConfig to control:
+    - enabled: Whether to run audio event detection
+    - device: GPU/CPU device selection
+    - dtype: Model precision (float32, float16, bfloat16)
+    - reduced: Use reduced label set (33 vs 400+ classes)
+    - top_k: Number of top event classes to detect
+    - vad_chunk_size/vad_max_gap: VAD segmentation parameters
+
+Example:
+    >>> from lattifai.event import LattifAIEventDetector
+    >>> from lattifai.config import EventConfig
+    >>> from lattifai.audio2 import AudioLoader
+    >>>
+    >>> config = EventConfig(enabled=True, device="cuda")
+    >>> detector = LattifAIEventDetector(config)
+    >>>
+    >>> audio = AudioLoader.load("speech.wav")
+    >>> result = detector.detect(audio)
+    >>>
+    >>> # Access VAD segments directly
+    >>> for start, end in result.vad_segments:
+    ...     print(f"Speech: {start:.2f} - {end:.2f}")
+    >>>
+    >>> # Or access the full TextGrid
+    >>> print(result.audio_events)
+
+Performance Notes:
+    - GPU acceleration provides significant speedup (10x+ over CPU)
+    - Use dtype="float16" for faster inference with minimal accuracy loss
+    - fast_mode=True reduces computation by only detecting top_k classes
+    - Long audio files are automatically chunked to manage memory
+
+See Also:
+    - lattifai.config.EventConfig: Configuration options
+    - lattifai_core.event: Core event detection implementation
+"""
+
+from .lattifai import LattifAIEventDetector
+
+__all__ = ["LattifAIEventDetector"]

lattifai/event/lattifai.py

@@ -0,0 +1,166 @@
+"""LattifAI Audio Event Detection implementation."""
+
+import logging
+from typing import TYPE_CHECKING, Optional
+
+from lattifai.audio2 import AudioData
+from lattifai.config.event import EventConfig
+from lattifai.logging import get_logger
+
+if TYPE_CHECKING:
+    from lattifai_core.event import LEDOutput
+
+    from lattifai.data import Caption
+
+
+formatter = "%(asctime)s %(levelname)s [%(filename)s:%(lineno)d] %(message)s"
+logging.basicConfig(format=formatter, level=logging.INFO)
+
+
+class LattifAIEventDetector:
+    """
+    LattifAI Audio Event Detector.
+
+    This class provides a high-level interface for audio event detection,
+    wrapping the core LattifAIEventDetector from lattifai_core.
+
+    Attributes:
+        config: EventConfig configuration object.
+
+    Example:
+        >>> from lattifai.event import LattifAIEventDetector
+        >>> from lattifai.config import EventConfig
+        >>>
+        >>> config = EventConfig(enabled=True, device="cuda")
+        >>> detector = LattifAIEventDetector(config)
+        >>>
+        >>> # Detect events from audio data
+        >>> result = detector.detect(audio_data)
+        >>>
+        >>> # Access VAD segments directly
+        >>> for start, end in result.vad_segments:
+        ...     print(f"Speech: {start:.2f} - {end:.2f}")
+        >>>
+        >>> # Or access the full TextGrid
+        >>> for tier in result.audio_events.tiers:
+        ...     print(f"Event type: {tier.name}")
+    """
+
+    def __init__(self, config: EventConfig):
+        """
+        Initialize LattifAI Audio Event Detector.
+
+        Args:
+            config: EventConfig configuration.
+        """
+        self.config = config
+        self.logger = get_logger("event")
+        self._detector = None
+
+    @property
+    def name(self) -> str:
+        """Human-readable name of the detector."""
+        return "LattifAI_EventDetector"
+
+    @property
+    def detector(self):
+        """Lazy-load and return the audio event detector."""
+        if self._detector is None:
+            from lattifai_core.event import LattifAIEventDetector as CoreEventDetector
+
+            self._detector = CoreEventDetector.from_pretrained(
+                model_path=self.config.model_path,
+                device=self.config.device,
+                client_wrapper=self.config.client_wrapper,
+            )
+        return self._detector
+
+    def detect(
+        self,
+        input_media: AudioData,
+        vad_chunk_size: Optional[float] = None,
+        vad_max_gap: Optional[float] = None,
+        fast_mode: Optional[bool] = None,
+    ) -> "LEDOutput":
+        """
+        Detect audio events in the input audio.
+
+        Args:
+            input_media: Audio data to analyze.
+            vad_chunk_size: Override config vad_chunk_size.
+            vad_max_gap: Override config vad_max_gap.
+            fast_mode: Override config fast_mode.
+
+        Returns:
+            LEDOutput containing audio_events, event_names, vad_segments.
+        """
+        return self.detector(
+            audio=input_media,
+            vad_chunk_size=vad_chunk_size or self.config.vad_chunk_size,
+            vad_max_gap=vad_max_gap or self.config.vad_max_gap,
+            fast_mode=fast_mode if fast_mode is not None else self.config.fast_mode,
+            custom_aliases=self.config.event_aliases or {},
+        )
+
+    def profiling(self, reset: bool = False) -> str:
+        """Get profiling information for the detector."""
+        if self._detector is None:
+            return ""
+        return self.detector.profiling(reset=reset, logger=self.logger)
+
+    def detect_and_update_caption(
+        self,
+        caption: "Caption",
+        input_media: AudioData,
+        vad_chunk_size: Optional[float] = None,
+        vad_max_gap: Optional[float] = None,
+        fast_mode: Optional[bool] = None,
+    ) -> "Caption":
+        """
+        Run event detection and update caption with audio events.
+
+        This is the main entry point for integrating event detection with alignment.
+        When event_matching is enabled, it also updates caption timestamps for [Event] markers.
+
+        Args:
+            audio: AudioData to analyze
+            caption: Caption to update with event detection results
+
+        Returns:
+            Updated Caption with event field populated
+        """
+        # Event matching: update caption timestamps based on detected events
+        if self.config.event_matching:
+            # Get supervisions to process
+            supervisions = caption.alignments or caption.supervisions
+
+            led_output, supervisions = self.detector.detect_and_update_supervisions(
+                supervisions=supervisions,
+                audio=input_media,
+                vad_chunk_size=vad_chunk_size or self.config.vad_chunk_size,
+                vad_max_gap=vad_max_gap or self.config.vad_max_gap,
+                fast_mode=fast_mode if fast_mode is not None else self.config.fast_mode,
+                custom_aliases=self.config.event_aliases or {},
+                extra_events=self.config.extra_events or None,
+                time_tolerance=self.config.time_tolerance,
+                update_timestamps=self.config.update_timestamps,
+                duplicate_strategy=self.config.duplicate_strategy,
+            )
+            # Store LEDOutput in caption
+            caption.event = led_output
+
+            if caption.alignments:
+                caption.alignments = supervisions
+            else:
+                caption.supervisions = supervisions
+        else:
+            # Simple detection without event matching
+            led_output = self.detect(
+                input_media=input_media,
+                vad_chunk_size=vad_chunk_size,
+                vad_max_gap=vad_max_gap,
+                fast_mode=fast_mode,
+            )
+            caption.event = led_output
+
+        return caption

lattifai/mixin.py

@@ -8,12 +8,12 @@ import colorful
 from lhotse.utils import Pathlike
 
 from lattifai.audio2 import AudioData
-from lattifai.caption import Caption
+from lattifai.data import Caption
 from lattifai.errors import CaptionProcessingError
 from lattifai.utils import safe_print
 
 if TYPE_CHECKING:
-    from .config import AlignmentConfig, CaptionConfig, ClientConfig, DiarizationConfig, TranscriptionConfig
+    from .config import AlignmentConfig, DiarizationConfig, EventConfig, TranscriptionConfig
 
 
 class LattifAIClientMixin:
@@ -170,9 +170,10 @@ class LattifAIClientMixin:
         alignment_config: Optional["AlignmentConfig"],
         transcription_config: Optional["TranscriptionConfig"],
         diarization_config: Optional["DiarizationConfig"] = None,
+        event_config: Optional["EventConfig"] = None,
     ) -> tuple:
         """Initialize all configs with defaults if not provided."""
-        from .config import AlignmentConfig, DiarizationConfig, TranscriptionConfig
+        from .config import AlignmentConfig, DiarizationConfig, EventConfig, TranscriptionConfig
 
         if alignment_config is None:
             alignment_config = AlignmentConfig()
@@ -180,20 +181,24 @@ class LattifAIClientMixin:
             transcription_config = TranscriptionConfig()
         if diarization_config is None:
             diarization_config = DiarizationConfig()
+        if event_config is None:
+            event_config = EventConfig()
 
         from lattifai.utils import _resolve_model_path
 
-        if transcription_config is not None:
-            transcription_config.lattice_model_path = _resolve_model_path(
-                alignment_config.model_name, getattr(alignment_config, "model_hub", "huggingface")
-            )
+        model_path = _resolve_model_path(
+            alignment_config.model_name, getattr(alignment_config, "model_hub", "modelscope")
+        )
+        transcription_config.lattice_model_path = model_path
+        event_config.model_path = model_path
 
         # Set client_wrapper for all configs
         alignment_config.client_wrapper = self
         transcription_config.client_wrapper = self
         diarization_config.client_wrapper = self
+        event_config.client_wrapper = self
 
-        return alignment_config, transcription_config, diarization_config
+        return alignment_config, transcription_config, diarization_config, event_config
 
     def _init_shared_components(
         self,
@@ -220,19 +225,16 @@ class LattifAIClientMixin:
     def downloader(self):
         """Lazy load YouTube downloader."""
         if self._downloader is None:
-            from .workflow.youtube import YouTubeDownloader
+            from .youtube import YouTubeDownloader
 
             self._downloader = YouTubeDownloader()
         return self._downloader
 
     def _prepare_youtube_output_dir(self, output_dir: Optional["Pathlike"]) -> Path:
         """Prepare and return output directory for YouTube downloads."""
-        if output_dir is None:
-            output_dir = Path(tempfile.gettempdir()) / "lattifai_youtube"
-        else:
-            output_dir = Path(output_dir).expanduser()
-        output_dir.mkdir(parents=True, exist_ok=True)
-        return output_dir
+        output_path = Path(output_dir).expanduser() if output_dir else Path(tempfile.gettempdir()) / "lattifai_youtube"
+        output_path.mkdir(parents=True, exist_ok=True)
+        return output_path
 
     def _determine_media_format(self, media_format: Optional[str]) -> str:
         """Determine media format from parameter or config."""
@@ -242,11 +244,11 @@ class LattifAIClientMixin:
         self, output_caption_path: Optional["Pathlike"], media_file: str, output_dir: Path
     ) -> Path:
         """Generate output caption path if not provided."""
-        if not output_caption_path:
-            media_name = Path(media_file).stem
-            output_format = self.caption_config.output_format or "srt"
-            output_caption_path = output_dir / f"{media_name}_LattifAI.{output_format}"
-        return Path(output_caption_path)
+        if output_caption_path:
+            return Path(output_caption_path)
+        media_name = Path(media_file).stem
+        output_format = self.caption_config.output_format or "srt"
+        return output_dir / f"{media_name}_LattifAI.{output_format}"
 
     def _validate_transcription_setup(self) -> None:
         """Validate that transcription is properly configured if requested."""
@@ -287,18 +289,18 @@ class LattifAIClientMixin:
                 format=input_caption_format,
                 normalize_text=normalize_text if normalize_text is not None else self.caption_config.normalize_text,
             )
-            diarization_file = Path(str(input_caption)).with_suffix(".SpkDiar")
+            diarization_file = Path(str(input_caption)).with_suffix(".Diarization")
             if diarization_file.exists():
                 if verbose:
                     safe_print(colorful.cyan(f"📖 Step1b: Reading speaker diarization from {diarization_file}"))
-                caption.read_speaker_diarization(diarization_file)
-            events_file = Path(str(input_caption)).with_suffix(".AED")
-            if events_file.exists():
+                caption.read_diarization(diarization_file)
+            event_file = Path(str(input_caption)).with_suffix(".LED")
+            if event_file.exists():
                 if verbose:
-                    safe_print(colorful.cyan(f"📖 Step1c: Reading audio events from {events_file}"))
-                from tgt import read_textgrid
+                    safe_print(colorful.cyan(f"📖 Step1c: Reading audio events from {event_file}"))
+                from lattifai_core.event import LEDOutput
 
-                caption.audio_events = read_textgrid(events_file)
+                caption.event = LEDOutput.read(event_file)
 
             if verbose:
                 safe_print(colorful.green(f"         ✓ Parsed {len(caption)} caption segments"))
@@ -332,11 +334,13 @@ class LattifAIClientMixin:
             result = caption.write(
                 output_caption_path,
                 include_speaker_in_text=self.caption_config.include_speaker_in_text,
+                word_level=self.caption_config.word_level,
+                karaoke_config=self.caption_config.karaoke,
             )
             diarization_file = Path(str(output_caption_path)).with_suffix(".SpkDiar")
-            if not diarization_file.exists() and caption.speaker_diarization:
+            if not diarization_file.exists() and caption.diarization:
                 safe_print(colorful.green(f"    Writing speaker diarization to: {diarization_file}"))
-                caption.write_speaker_diarization(diarization_file)
+                caption.write_diarization(diarization_file)
 
             safe_print(colorful.green(f"🎉🎉🎉🎉🎉 Caption file written to: {output_caption_path}"))
             return result
@@ -353,14 +357,22 @@ class LattifAIClientMixin:
         output_dir: Path,
         media_format: str,
         force_overwrite: bool,
+        audio_track_id: Optional[str] = "original",
+        quality: str = "best",
     ) -> str:
         """Download media from YouTube (async implementation)."""
         safe_print(colorful.cyan("📥 Downloading media from YouTube..."))
+        if audio_track_id:
+            safe_print(colorful.cyan(f"    Audio track: {audio_track_id}"))
+        if quality != "best":
+            safe_print(colorful.cyan(f"    Quality: {quality}"))
         media_file = await self.downloader.download_media(
             url=url,
             output_dir=str(output_dir),
             media_format=media_format,
             force_overwrite=force_overwrite,
+            audio_track_id=audio_track_id,
+            quality=quality,
         )
         safe_print(colorful.green(f"    ✓ Media downloaded: {media_file}"))
         return media_file
@@ -371,11 +383,15 @@ class LattifAIClientMixin:
         output_dir: Path,
         media_format: str,
         force_overwrite: bool,
+        audio_track_id: Optional[str] = "original",
+        quality: str = "best",
     ) -> str:
         """Download media from YouTube (sync wrapper)."""
         import asyncio
 
-        return asyncio.run(self._download_media(url, output_dir, media_format, force_overwrite))
+        return asyncio.run(
+            self._download_media(url, output_dir, media_format, force_overwrite, audio_track_id, quality)
+        )
 
     def _transcribe(
         self,
@@ -408,7 +424,7 @@ class LattifAIClientMixin:
                 # Generate transcript file path
                 transcript_file = output_dir / f"{Path(str(media_file)).stem}_{self.transcriber.file_name}"
                 if transcript_file.exists():
-                    safe_print(colorful.cyan(f"    Using existing transcript file: {transcript_file}"))
+                    safe_print(colorful.cyan(f"     Using existing transcript file: {transcript_file}"))
                     transcription = self._read_caption(transcript_file, normalize_text=False)
                     return transcription
 
@@ -485,11 +501,12 @@ class LattifAIClientMixin:
         """
         import asyncio
 
-        from lattifai.workflow.youtube import TRANSCRIBE_CHOICE
+        from lattifai.workflow.file_manager import TRANSCRIBE_CHOICE
 
         transcriber_name = self.transcriber.name
 
         async def _async_impl():
+            nonlocal use_transcription  # Allow modification of outer variable
             # First check if caption input_path is already provided
             if self.caption_config.input_path:
                 caption_path = Path(self.caption_config.input_path)