lattifai 0.4.5__py3-none-any.whl → 1.0.0__py3-none-any.whl

lattifai/cli/caption.py

@@ -0,0 +1,204 @@
+"""Caption CLI entry point with nemo_run."""
+
+from typing import Optional
+
+import nemo_run as run
+from lhotse.utils import Pathlike
+from typing_extensions import Annotated
+
+from lattifai.config import CaptionConfig
+
+
+@run.cli.entrypoint(name="convert", namespace="caption")
+def convert(
+    input_path: Pathlike,
+    output_path: Pathlike,
+    include_speaker_in_text: bool = True,
+    normalize_text: bool = False,
+):
+    """
+    Convert caption file to another format.
+
+    This command reads a caption file from one format and writes it to another format,
+    preserving all timing information, text content, and speaker labels (if present).
+    Supports common caption formats including SRT, VTT, JSON, and Praat TextGrid.
+
+    Shortcut: invoking ``laisub-convert`` is equivalent to running ``lai caption convert``.
+
+    Args:
+        input_path: Path to input caption file (supports SRT, VTT, JSON, TextGrid formats)
+        output_path: Path to output caption file (format determined by file extension)
+        include_speaker_in_text: Preserve speaker labels in caption text content.
+        normalize_text: Whether to normalize caption text during conversion.
+            This applies text cleaning such as removing HTML tags, decoding entities,
+            collapsing whitespace, and standardizing punctuation.
+
+    Examples:
+        # Basic format conversion (positional arguments)
+        lai caption convert input.srt output.vtt
+
+        # Convert with text normalization
+        lai caption convert input.srt output.json normalize_text=true
+
+        # Mixing positional and keyword arguments
+        lai caption convert input.srt output.vtt \\
+            include_speaker_in_text=false \\
+            normalize_text=true
+
+        # Using keyword arguments (traditional syntax)
+        lai caption convert \\
+            input_path=input.srt \\
+            output_path=output.TextGrid
+    """
+    from lattifai.caption import Caption
+
+    caption = Caption.read(input_path, normalize_text=normalize_text)
+    caption.write(output_path, include_speaker_in_text=include_speaker_in_text)
+
+    print(f"✅ Converted {input_path} -> {output_path}")
+    return output_path
+
+
+@run.cli.entrypoint(name="normalize", namespace="caption")
+def normalize(
+    input_path: Pathlike,
+    output_path: Pathlike,
+    caption: Annotated[Optional[CaptionConfig], run.Config[CaptionConfig]] = None,
+):
+    """
+    Normalize caption text by cleaning HTML entities and whitespace.
+
+    This command reads a caption file and normalizes all text content by applying
+    the following transformations:
+    - Decode common HTML entities (&, <, >, ", ',  )
+    - Remove HTML tags (e.g., <i>, <font>, <b>, <br>)
+    - Collapse multiple whitespace characters into single spaces
+    - Convert curly apostrophes to straight ones in contractions
+    - Strip leading and trailing whitespace from each segment
+
+    Shortcut: invoking ``laisub-normalize`` is equivalent to running ``lai caption normalize``.
+
+    Args:
+        input_path: Path to input caption file to normalize
+        output_path: Path to output caption file (defaults to overwriting input file)
+        caption: Caption configuration for text normalization.
+            Fields: input_format, output_format, normalize_text (automatically enabled),
+                    encoding
+
+    Examples:
+        # Normalize and save to new file (positional arguments)
+        lai caption normalize input.srt output.srt
+
+        # Normalize with format conversion
+        lai caption normalize input.vtt output.srt
+
+        # Normalize with custom caption config
+        lai caption normalize input.srt output.srt \\
+            caption.encoding=utf-8
+
+        # Using keyword arguments (traditional syntax)
+        lai caption normalize \\
+            input_path=input.srt \\
+            output_path=output.srt
+    """
+    from pathlib import Path
+
+    from lattifai.caption import Caption
+
+    input_path = Path(input_path).expanduser()
+    output_path = Path(output_path).expanduser()
+
+    caption_obj = Caption.read(input_path, normalize_text=True)
+    caption_obj.write(output_path, include_speaker_in_text=True)
+
+    if output_path == input_path:
+        print(f"✅ Normalized {input_path} (in-place)")
+    else:
+        print(f"✅ Normalized {input_path} -> {output_path}")
+
+    return output_path
+
+
+@run.cli.entrypoint(name="shift", namespace="caption")
+def shift(
+    input_path: Pathlike,
+    output_path: Pathlike,
+    seconds: float,
+    caption: Annotated[Optional[CaptionConfig], run.Config[CaptionConfig]] = None,
+):
+    """
+    Shift caption timestamps by a specified number of seconds.
+
+    This command reads a caption file and adjusts all timestamps by adding or
+    subtracting a specified offset. Use positive values to delay captions and
+    negative values to make them appear earlier.
+
+    Shortcut: invoking ``laisub-shift`` is equivalent to running ``lai caption shift``.
+
+    Args:
+        input_path: Path to input caption file
+        output_path: Path to output caption file (can be same as input for in-place modification)
+        seconds: Number of seconds to shift timestamps. Positive values delay captions,
+                 negative values advance them earlier.
+        caption: Caption configuration for reading/writing.
+            Fields: input_format, output_format, encoding
+
+    Examples:
+        # Delay captions by 2 seconds (positional arguments)
+        lai caption shift input.srt output.srt 2.0
+
+        # Make captions appear 1.5 seconds earlier
+        lai caption shift input.srt output.srt -1.5
+
+        # Shift and convert format
+        lai caption shift input.vtt output.srt seconds=0.5
+
+        # Using keyword arguments (traditional syntax)
+        lai caption shift \\
+            input_path=input.srt \\
+            output_path=output.srt \\
+            seconds=3.0
+    """
+    from pathlib import Path
+
+    from lattifai.caption import Caption
+
+    input_path = Path(input_path).expanduser()
+    output_path = Path(output_path).expanduser()
+
+    # Read captions
+    caption_obj = Caption.read(input_path)
+
+    # Shift timestamps
+    shifted_caption = caption_obj.shift_time(seconds)
+
+    # Write shifted captions
+    shifted_caption.write(output_path, include_speaker_in_text=True)
+
+    if seconds >= 0:
+        direction = f"delayed by {seconds}s"
+    else:
+        direction = f"advanced by {abs(seconds)}s"
+
+    if output_path == input_path:
+        print(f"✅ Shifted timestamps {direction} in {input_path} (in-place)")
+    else:
+        print(f"✅ Shifted timestamps {direction}: {input_path} -> {output_path}")
+
+    return output_path
+
+
+def main_convert():
+    run.cli.main(convert)
+
+
+def main_normalize():
+    run.cli.main(normalize)
+
+
+def main_shift():
+    run.cli.main(shift)
+
+
+if __name__ == "__main__":
+    main_convert()

lattifai/cli/server.py

@@ -0,0 +1,19 @@
+import os
+
+import colorful
+import uvicorn
+
+
+def main():
+    """Launch the LattifAI Web Interface."""
+    print(colorful.bold_green("🚀 Launching LattifAI Web Interface..."))
+    print(colorful.cyan("See http://localhost:8001"))
+
+    # Ensure the directory contains the app
+    # We might need to adjust python path or just rely on installed package
+
+    uvicorn.run("lattifai.server.app:app", host="0.0.0.0", port=8001, reload=True, log_level="info")
+
+
+if __name__ == "__main__":
+    main()

lattifai/cli/transcribe.py

@@ -0,0 +1,197 @@
+"""Transcription CLI entry point with nemo_run."""
+
+from typing import Optional
+
+import nemo_run as run
+from lhotse.utils import Pathlike
+from typing_extensions import Annotated
+
+from lattifai.audio2 import AudioLoader, ChannelSelectorType
+from lattifai.cli.alignment import align as alignment_align
+from lattifai.config import (
+    AlignmentConfig,
+    CaptionConfig,
+    ClientConfig,
+    DiarizationConfig,
+    MediaConfig,
+    TranscriptionConfig,
+)
+from lattifai.utils import _resolve_model_path
+
+
+@run.cli.entrypoint(name="run", namespace="transcribe")
+def transcribe(
+    input: Optional[str] = None,
+    output_caption: Optional[str] = None,
+    output_dir: Optional[Pathlike] = None,
+    media_format: str = "mp3",
+    channel_selector: Optional[ChannelSelectorType] = "average",
+    transcription: Annotated[Optional[TranscriptionConfig], run.Config[TranscriptionConfig]] = None,
+):
+    """
+    Transcribe audio/video file or YouTube URL to caption.
+
+    This command performs automatic speech recognition (ASR) on audio/video files
+    or YouTube videos, generating timestamped transcriptions in various caption formats.
+
+    Shortcut: invoking ``lai-transcribe`` is equivalent to running ``lai transcribe run``.
+
+    Args:
+        input: Path to input audio/video file or YouTube URL (can be provided as positional argument)
+        output_caption: Path for output caption file (can be provided as positional argument)
+        output_dir: Directory for output files when using YouTube URL
+        media_format: Media format for YouTube downloads (default: mp3)
+        channel_selector: Audio channel selection strategy (default: average)
+            Options: average, left, right, or an integer channel index.
+            Note: Ignored when input is a URL and Gemini transcriber is used.
+        transcription: Transcription service configuration.
+            Fields: model_name, device, language, gemini_api_key
+
+    Examples:
+        # Transcribe local file with positional arguments
+        lai transcribe run audio.wav output.srt
+
+        # Transcribe YouTube video
+        lai transcribe run "https://www.youtube.com/watch?v=VIDEO_ID" ./output
+
+        # Using specific transcription model
+        lai transcribe run audio.mp4 output.ass \\
+            transcription.model_name=nvidia/parakeet-tdt-0.6b-v3
+
+        # Using Gemini transcription (requires API key)
+        lai transcribe run audio.wav output.srt \\
+            transcription.model_name=gemini-2.5-pro \\
+            transcription.gemini_api_key=YOUR_KEY
+
+        # Specify language for transcription
+        lai transcribe run audio.wav output.srt \\
+            transcription.language=zh
+
+        # Full configuration with keyword arguments
+        lai transcribe run \\
+            input=audio.wav \\
+            output_caption=output.srt \\
+            transcription.device=cuda \\
+            transcription.model_name=iic/SenseVoiceSmall
+    """
+    import asyncio
+    from pathlib import Path
+
+    import colorful
+
+    from lattifai.transcription import create_transcriber
+
+    # Initialize transcription config with defaults
+    transcription_config = transcription or TranscriptionConfig()
+
+    # Validate input is required
+    if not input:
+        raise ValueError("Input is required. Provide input as positional argument (file path or URL).")
+
+    # Detect if input is a URL
+    is_url = input.startswith(("http://", "https://"))
+
+    # Prepare output paths
+    if is_url:
+        # For URLs, use output_dir
+        if output_dir:
+            output_path = Path(str(output_dir)).expanduser()
+            output_path.mkdir(parents=True, exist_ok=True)
+        else:
+            output_path = Path.cwd()
+    else:
+        # For files, use input path directory
+        input_path = Path(str(input))
+        output_path = input_path.parent
+
+    # Create transcriber
+    if not transcription_config.lattice_model_path:
+        transcription_config.lattice_model_path = _resolve_model_path("Lattifai/Lattice-1")
+    transcriber = create_transcriber(transcription_config=transcription_config)
+
+    print(colorful.cyan(f"🎤 Starting transcription with {transcriber.name}..."))
+    print(colorful.cyan(f"    Input: {input}"))
+
+    # Perform transcription
+    if is_url and transcriber.supports_url:
+        # Check if transcriber supports URL directly
+        print(colorful.cyan("    Transcribing from URL directly..."))
+        transcript = asyncio.run(transcriber.transcribe(input))
+    else:
+        if is_url:
+            # Download media first, then transcribe
+            print(colorful.cyan("    Downloading media from URL..."))
+            from lattifai.workflow.youtube import YouTubeDownloader
+
+            downloader = YouTubeDownloader()
+            input_path = asyncio.run(
+                downloader.download_media(
+                    url=input,
+                    output_dir=str(output_path),
+                    media_format=media_format,
+                    force_overwrite=False,
+                )
+            )
+            print(colorful.cyan(f"    Media downloaded to: {input_path}"))
+        else:
+            input_path = Path(str(input))
+
+        print(colorful.cyan("    Loading audio..."))
+        # For files, load audio first
+        audio_loader = AudioLoader(device=transcription_config.device)
+        media_audio = audio_loader(input_path, channel_selector=channel_selector)
+        transcript = asyncio.run(transcriber.transcribe(media_audio))
+
+    # Determine output caption path
+    if output_caption:
+        final_output = Path(str(output_caption))
+        final_output.parent.mkdir(parents=True, exist_ok=True)
+    else:
+        if is_url:
+            # For URLs, generate output filename based on transcriber
+            output_format = transcriber.file_suffix.lstrip(".")
+            final_output = output_path / f"youtube_LattifAI_{transcriber.name}.{output_format}"
+        else:
+            # For files, use input filename with suffix
+            final_output = Path(str(input)).with_suffix(".LattifAI.srt")
+
+    print(colorful.cyan(f"   Output: {final_output}"))
+
+    # Write output
+    transcriber.write(transcript, final_output, encoding="utf-8", cache_audio_events=False)
+
+    print(colorful.green(f"🎉 Transcription completed: {final_output}"))
+
+    return transcript
+
+
+@run.cli.entrypoint(name="align", namespace="transcribe")
+def transcribe_align(
+    input_media: Optional[str] = None,
+    output_caption: Optional[str] = None,
+    media: Annotated[Optional[MediaConfig], run.Config[MediaConfig]] = None,
+    caption: Annotated[Optional[CaptionConfig], run.Config[CaptionConfig]] = None,
+    client: Annotated[Optional[ClientConfig], run.Config[ClientConfig]] = None,
+    alignment: Annotated[Optional[AlignmentConfig], run.Config[AlignmentConfig]] = None,
+    transcription: Annotated[Optional[TranscriptionConfig], run.Config[TranscriptionConfig]] = None,
+    diarization: Annotated[Optional[DiarizationConfig], run.Config[DiarizationConfig]] = None,
+):
+    return alignment_align(
+        input_media=input_media,
+        output_caption=output_caption,
+        media=media,
+        caption=caption,
+        client=client,
+        alignment=alignment,
+        transcription=transcription,
+        diarization=diarization,
+    )
+
+
+def main():
+    """Entry point for lai-transcribe command."""
+    run.cli.main(transcribe)
+
+
+if __name__ == "__main__":
+    main()

lattifai/cli/youtube.py

@@ -0,0 +1,128 @@
+"""YouTube workflow CLI entry point with nemo_run."""
+
+from typing import Optional
+
+import nemo_run as run
+from typing_extensions import Annotated
+
+from lattifai.client import LattifAI
+from lattifai.config import (
+    AlignmentConfig,
+    CaptionConfig,
+    ClientConfig,
+    DiarizationConfig,
+    MediaConfig,
+    TranscriptionConfig,
+)
+
+
+@run.cli.entrypoint(name="youtube", namespace="alignment")
+def youtube(
+    yt_url: Optional[str] = None,
+    media: Annotated[Optional[MediaConfig], run.Config[MediaConfig]] = None,
+    client: Annotated[Optional[ClientConfig], run.Config[ClientConfig]] = None,
+    alignment: Annotated[Optional[AlignmentConfig], run.Config[AlignmentConfig]] = None,
+    caption: Annotated[Optional[CaptionConfig], run.Config[CaptionConfig]] = None,
+    transcription: Annotated[Optional[TranscriptionConfig], run.Config[TranscriptionConfig]] = None,
+    diarization: Annotated[Optional[DiarizationConfig], run.Config[DiarizationConfig]] = None,
+):
+    """
+    Download media from YouTube (when needed) and align captions.
+
+    This command provides a convenient workflow for aligning captions with YouTube videos.
+    It can automatically download media from YouTube URLs and optionally transcribe audio
+    using Gemini or download available captions from YouTube.
+
+    When a YouTube URL is provided:
+    1. Downloads media in the specified format (audio or video)
+    2. Optionally transcribes audio with Gemini OR downloads YouTube captions
+    3. Performs forced alignment with the provided or generated captions
+
+    Shortcut: invoking ``lai-youtube`` is equivalent to running ``lai alignment youtube``.
+
+    Args:
+        yt_url: YouTube video URL (can be provided as positional argument)
+        media: Media configuration for controlling formats and output directories.
+            Fields: input_path (YouTube URL), output_dir, output_format, force_overwrite
+        client: API client configuration.
+            Fields: api_key, timeout, max_retries
+        alignment: Alignment configuration (model selection and inference settings).
+            Fields: model_name, device, batch_size
+        caption: Caption configuration for reading/writing caption files.
+            Fields: output_format, output_path, normalize_text,
+                    split_sentence, word_level, encoding
+        transcription: Transcription service configuration (enables Gemini transcription).
+            Fields: gemini_api_key, model_name, language, device
+        diarization: Speaker diarization configuration.
+            Fields: enabled, num_speakers, min_speakers, max_speakers, device
+
+    Examples:
+        # Download from YouTube and align (positional argument)
+        lai alignment youtube "https://www.youtube.com/watch?v=VIDEO_ID"
+
+        # With custom output directory and format
+        lai alignment youtube "https://www.youtube.com/watch?v=VIDEO_ID" \\
+            media.output_dir=/tmp/youtube \\
+            media.output_format=mp3
+
+        # Full configuration with smart splitting and word-level alignment
+        lai alignment youtube "https://www.youtube.com/watch?v=VIDEO_ID" \\
+            caption.output_path=aligned.srt \\
+            caption.split_sentence=true \\
+            caption.word_level=true \\
+            alignment.device=cuda
+
+        # Use Gemini transcription (requires API key)
+        lai alignment youtube "https://www.youtube.com/watch?v=VIDEO_ID" \\
+            transcription.gemini_api_key=YOUR_KEY \\
+            transcription.model_name=gemini-2.0-flash
+
+        # Using keyword argument (traditional syntax)
+        lai alignment youtube \\
+            yt_url="https://www.youtube.com/watch?v=VIDEO_ID" \\
+            alignment.device=mps
+    """
+    # Initialize configs with defaults
+    media_config = media or MediaConfig()
+    caption_config = caption or CaptionConfig()
+
+    # Validate URL input: require exactly one of yt_url or media.input_path
+    if yt_url and media_config.input_path:
+        raise ValueError(
+            "Cannot specify both positional yt_url and media.input_path. "
+            "Use either positional argument or config, not both."
+        )
+
+    if not yt_url and not media_config.input_path:
+        raise ValueError("YouTube URL is required. Provide either positional yt_url or media.input_path parameter.")
+
+    # Assign yt_url to media_config.input_path if provided
+    if yt_url:
+        media_config.set_input_path(yt_url)
+
+    # Create LattifAI client with all configurations
+    lattifai_client = LattifAI(
+        client_config=client,
+        alignment_config=alignment,
+        caption_config=caption_config,
+        transcription_config=transcription,
+        diarization_config=diarization,
+    )
+    # Call the client's youtube method
+    return lattifai_client.youtube(
+        url=media_config.input_path,
+        output_dir=media_config.output_dir,
+        output_caption_path=caption_config.output_path,
+        media_format=media_config.normalize_format() if media_config.output_format else None,
+        force_overwrite=media_config.force_overwrite,
+        split_sentence=caption_config.split_sentence,
+        channel_selector=media_config.channel_selector,
+    )
+
+
+def main():
+    run.cli.main(youtube)
+
+
+if __name__ == "__main__":
+    main()