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

lattifai/{io → caption}/supervision.py

@@ -24,6 +24,7 @@ class Supervision(SupervisionSegment):
     """
 
     text: Optional[str] = None
+    speaker: Optional[str] = None
     id: str = ""
     recording_id: str = ""
     start: Seconds = 0.0

lattifai/{io → caption}/text_parser.py

@@ -2,6 +2,10 @@ import logging
 import re
 from typing import Optional, Tuple
 
+# Timestamp pattern: [start-end] text
+# Example: [1.23-4.56] Hello world
+TIMESTAMP_PATTERN = re.compile(r"^\[([\d.]+)-([\d.]+)\]\s*(.*)$")
+
 # 来自于字幕中常见的说话人标记格式
 SPEAKER_PATTERN = re.compile(r"((?:>>|>>|>|>).*?[:：])\s*(.*)")
 
@@ -16,8 +20,19 @@ SPEAKER_LATTIFAI = re.compile(r"(^\[SPEAKER_.*?\][:：])\s*(.*)")
 SPEAKER_PATTERN2 = re.compile(r"^([A-Z]{1,15}(?:\s+[A-Z]{1,15})?[:：])\s*(.*)$")
 
 
-def normalize_html_text(text: str) -> str:
-    """Normalize HTML text by decoding entities and stripping whitespace."""
+def normalize_text(text: str) -> str:
+    """Normalize caption text by:
+    - Decoding common HTML entities
+    - Removing HTML tags (e.g., <i>, <font>, <b>, <br>)
+    - Collapsing multiple whitespace into a single space
+    - Converting curly apostrophes to straight ones in common contractions
+    """
+    if not text:
+        return ""
+
+    # # Remove HTML tags first (replace with space to avoid concatenation)
+    # text = re.sub(r"<[^>]+>", " ", text)
+
     html_entities = {
         "&amp;": "&",
         "&lt;": "<",
@@ -26,20 +41,18 @@ def normalize_html_text(text: str) -> str:
         "&#39;": "'",
         "&nbsp;": " ",
         "\\N": " ",
-        "…": " ",
+        "…": " ",  # replace ellipsis with space to avoid merging words
     }
     for entity, char in html_entities.items():
         text = text.replace(entity, char)
 
-    text = re.sub(r"\s+", " ", text)  # Replace multiple spaces with a single space
-
     # Convert curly apostrophes to straight apostrophes for common English contractions
-    # Handles: 't 's 'll 're 've 'd 'm
-    # For example, convert "don't" to "don't"
     text = re.sub(r"([a-zA-Z])’([tsdm]|ll|re|ve)\b", r"\1'\2", text, flags=re.IGNORECASE)
-    # For example, convert "5’s" to "5's"
     text = re.sub(r"([0-9])’([s])\b", r"\1'\2", text, flags=re.IGNORECASE)
 
+    # Collapse whitespace (after replacements)
+    text = re.sub(r"\s+", " ", text)
+
     return text.strip()
 
 
@@ -70,6 +83,36 @@ def parse_speaker_text(line) -> Tuple[Optional[str], str]:
     return None, line
 
 
+def parse_timestamp_text(line: str) -> Tuple[Optional[float], Optional[float], str]:
+    """
+    Parse a line of text to extract timestamp and content.
+
+    Format: [start-end] text
+    Example: [1.23-4.56] Hello world
+
+    Args:
+        line: Input line to parse
+
+    Returns:
+        Tuple of (start_time, end_time, text)
+        - start_time: Start timestamp in seconds, or None if not found
+        - end_time: End timestamp in seconds, or None if not found
+        - text: The text content after the timestamp
+    """
+    match = TIMESTAMP_PATTERN.match(line)
+    if match:
+        try:
+            start = float(match.group(1))
+            end = float(match.group(2))
+            text = match.group(3).strip()
+            return start, end, text
+        except ValueError:
+            # If conversion fails, treat as plain text
+            return None, None, line
+
+    return None, None, line
+
+
 if __name__ == "__main__":
     pattern = re.compile(r">>\s*(.*?)\s*[:：]\s*(.*)")
     pattern = re.compile(r"(>>.*?[:：])\s*(.*)")
@@ -85,8 +128,8 @@ if __name__ == "__main__":
         match = pattern.match(text)
         if match:
             print(f"Input: '{text}'")
-            print(f"  Key:   '{match.group(1)}'")
-            print(f"  Value: '{match.group(2)}'")
+            print(f"Speaker:   '{match.group(1)}'")
+            print(f"Content: '{match.group(2)}'")
             print("-------------")
 
     # pattern2

lattifai/cli/__init__.py

@@ -0,0 +1,17 @@
+"""CLI module for LattifAI with nemo_run entry points."""
+
+import nemo_run as run  # noqa: F401
+
+# Import and re-export entrypoints at package level so NeMo Run can find them
+from lattifai.cli.alignment import align
+from lattifai.cli.caption import convert
+from lattifai.cli.transcribe import transcribe, transcribe_align
+from lattifai.cli.youtube import youtube
+
+__all__ = [
+    "align",
+    "convert",
+    "transcribe",
+    "transcribe_align",
+    "youtube",
+]

lattifai/cli/alignment.py

@@ -0,0 +1,153 @@
+"""Alignment 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.client import LattifAI
+from lattifai.config import (
+    AlignmentConfig,
+    CaptionConfig,
+    ClientConfig,
+    DiarizationConfig,
+    MediaConfig,
+    TranscriptionConfig,
+)
+
+__all__ = ["align"]
+
+
+@run.cli.entrypoint(name="align", namespace="alignment")
+def align(
+    input_media: Optional[str] = None,
+    input_caption: 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,
+):
+    """
+    Align audio/video with caption file.
+
+    This command performs forced alignment between audio/video media and caption text,
+    generating accurate timestamps for each caption segment and optionally word-level
+    timestamps. The alignment engine uses advanced speech recognition models to ensure
+    precise synchronization between audio and text.
+
+    Shortcut: invoking ``lai-align`` is equivalent to running ``lai alignment align``.
+
+    Args:
+        media: Media configuration for audio/video input and output handling.
+            Fields: input_path, media_format, sample_rate, channels, output_dir,
+                    output_path, output_format, prefer_audio, default_audio_format,
+                    default_video_format, force_overwrite
+        client: API client configuration.
+            Fields: api_key, timeout, max_retries, default_headers
+        alignment: Alignment configuration (model selection and inference settings).
+            Fields: model_name, device, batch_size
+        caption: Caption I/O configuration (file reading/writing and formatting).
+            Fields: input_format, input_path, output_format, output_path,
+                    normalize_text, split_sentence, word_level,
+                    include_speaker_in_text, encoding
+
+    Examples:
+        # Basic usage with positional arguments
+        lai alignment align audio.wav caption.srt output.srt
+
+        # Mixing positional and keyword arguments
+        lai alignment align audio.mp4 caption.srt output.json \\
+            alignment.device=cuda \\
+            caption.word_level=true
+
+        # Smart sentence splitting with custom output format
+        lai alignment align audio.wav caption.srt output.vtt \\
+            caption.split_sentence=true
+
+        # Using keyword arguments (traditional syntax)
+        lai alignment align \\
+            input_media=audio.wav \\
+            input_caption=caption.srt \\
+            output_caption=output.srt
+
+        # Full configuration with nested config objects
+        lai alignment align audio.wav caption.srt aligned.json \\
+            media.output_dir=/tmp/output \\
+            caption.split_sentence=true \\
+            caption.word_level=true \\
+            caption.normalize_text=true \\
+            alignment.device=mps \\
+            alignment.model_name=Lattifai/Lattice-1-Alpha
+    """
+    media_config = media or MediaConfig()
+
+    # Validate that input_media and media_config.input_path are not both provided
+    if input_media and media_config.input_path:
+        raise ValueError(
+            "Cannot specify both positional input_media and media.input_path. "
+            "Use either positional argument or config, not both."
+        )
+
+    # Assign input_media to media_config.input_path if provided
+    if input_media:
+        media_config.set_input_path(input_media)
+
+    if not media_config.input_path:
+        raise ValueError("Input media path must be specified via positional argument input_media= or media.input_path=")
+
+    caption_config = caption or CaptionConfig()
+
+    # Validate that output_caption_path and caption_config.output_path are not both provided
+    if output_caption and caption_config.output_path:
+        raise ValueError(
+            "Cannot specify both positional output_caption and caption.output_path. "
+            "Use either positional argument or config, not both."
+        )
+
+    # Assign paths to caption_config if provided
+    if input_caption:
+        caption_config.set_input_path(input_caption)
+
+    if output_caption:
+        caption_config.set_output_path(output_caption)
+
+    client = LattifAI(
+        client_config=client,
+        alignment_config=alignment,
+        caption_config=caption_config,
+        transcription_config=transcription,
+        diarization_config=diarization,
+    )
+
+    is_url = media_config.input_path.startswith(("http://", "https://"))
+    if is_url:
+        # Call the client's youtube method
+        return 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,
+        )
+
+    return client.alignment(
+        input_media=media_config.input_path,
+        input_caption=caption_config.input_path,
+        output_caption_path=caption_config.output_path,
+        split_sentence=caption_config.split_sentence,
+        channel_selector=media_config.channel_selector,
+    )
+
+
+def main():
+    run.cli.main(align)
+
+
+if __name__ == "__main__":
+    main()

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()