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

lattifai-1.3.0.dist-info/RECORD

@@ -0,0 +1,57 @@
+lattifai/_init.py,sha256=ZpiYRpP7kPh6XpQK6nX1zKKvtQE3Xr0T2Ed5S4wDiwU,609
+lattifai/audio2.py,sha256=JpMvwB0e09hLoffji8zOSlgrIhqUUq_zq0ubT_QMspc,15317
+lattifai/client.py,sha256=d6WpodzseoSv6aA8jkj4hwiMOz3irSkD15i1hr2JUsQ,18182
+lattifai/errors.py,sha256=aPTMhTaeQjY0KMifnm-Kpo9MQPsoYsEanZB2f0AA6qQ,11911
+lattifai/logging.py,sha256=MbUEeOUFlF92pA9v532DiPPWKl03S7UHCJ6Z652cf0w,2860
+lattifai/mixin.py,sha256=_d-kzu2w5Y4mZTFMEumh30baWzKsQ9n_IS432woi5vQ,26295
+lattifai/types.py,sha256=JK7KVaZhX89BiKPm4okY0DWLHY1S8aj-YiZXoVH1akw,667
+lattifai/utils.py,sha256=5LeunAN0OQ1jWoKMIThpXSEOxFYD2dCRTdsglosodUU,7963
+lattifai/alignment/__init__.py,sha256=aOyC1P5DqESNLpDh6Gu6LyUZAVMba-IKI7Ugz7v9G4w,344
+lattifai/alignment/lattice1_aligner.py,sha256=MvBpPnhfF8NYtH2ANhQszKNRQROUiSYrBz3aN1bdT3U,11120
+lattifai/alignment/lattice1_worker.py,sha256=Z7hxaS-nucNsUmrphbD8tgBBYPkJOgQb-85nFON94_I,13041
+lattifai/alignment/phonemizer.py,sha256=fbhN2DOl39lW4nQWKzyUUTMUabg7v61lB1kj8SKK-Sw,1761
+lattifai/alignment/punctuation.py,sha256=qLcvuXhBzoEa6bznWZiAB5TAxR6eLr_ZV-PnnCY90UA,1218
+lattifai/alignment/segmenter.py,sha256=JTbBYEXn8hkFwy0tITORy7nKoUPiNYLfi3w1DJNeHZ0,6303
+lattifai/alignment/text_align.py,sha256=sF-6Tsf863BhJcii3joeNa6Auv-7l3SiOhh9j8oPGME,14935
+lattifai/alignment/tokenizer.py,sha256=OIpMGHg1rJ7n97zncDMPpXy32uGOSt1yXiNO4sO6eP0,18839
+lattifai/cli/__init__.py,sha256=PdqoCTqRSFSWrqL3FjBTa5VzJy_e6Rq0OzyT7YkyHpc,541
+lattifai/cli/alignment.py,sha256=rqg6wU2vf6RJ058yWVoXft_UJfOCrEpmE-ye5fhTphg,6129
+lattifai/cli/caption.py,sha256=jkMme73sJ16dkVpRh7O6qjbr14SUeBif00vCTBn7ed0,10339
+lattifai/cli/diarization.py,sha256=GTd2vnTm6cJN6Q3mFP-ShY9bZBl1_zKzWFu-4HHcMzk,4075
+lattifai/cli/transcribe.py,sha256=vZIV0TCbZG_IL2F_Mg49cCGSCBinOOFAtROajVTpNWE,7853
+lattifai/cli/youtube.py,sha256=FJwDl48-cuacP1sdPvX19vdszXdT7EoOZgGYzJpoLeM,6360
+lattifai/config/__init__.py,sha256=nJUVk03JRj4rujoEmkCkQ8akZF7kqIj7ci3XphU9uVA,1249
+lattifai/config/alignment.py,sha256=3JUtgHBueIK_lH9PgeBPjuHGL4VvDEYVs9fvylir6bc,5392
+lattifai/config/caption.py,sha256=OMLsW8QKDWM6A3G5V3Gf-9bgB3D1PC5gO8LiiNNeOwM,7195
+lattifai/config/client.py,sha256=qqHKFPV4iEjVHCDOuGx7kj-tYFtgZZAszOQRFsNFbO8,2359
+lattifai/config/diarization.py,sha256=cIkwCfsYqfMns3i6tKWcwBBBkdnhhmB_Eo0TuOPCw9o,2484
+lattifai/config/event.py,sha256=P-_2yOzSATZSXz-ctlWeJQGOKCbNLFnWLBvUZ8JclyA,3845
+lattifai/config/media.py,sha256=nxvgC7zeLsthCARPPUbnK2eMJY8R1d-1XgiAsy8kroA,15568
+lattifai/config/transcription.py,sha256=V0WtZ_p-WsBienRbGyd-zLdX6F_XRsDWGlba_qzwet0,4115
+lattifai/data/__init__.py,sha256=hdUhvlUjPgb3_Hd_cJ30f2oXHBMZRGzaSafd64b3vYA,168
+lattifai/data/caption.py,sha256=MVuZiQ47Lr3A1afFqGkqFzpWjPakmsQusQ86t210Y2Y,7800
+lattifai/diarization/__init__.py,sha256=-ZZ_a5hIQgnlHIOehCTtmVmWOWC2H6eOhSs4AcVtRtk,1782
+lattifai/diarization/lattifai.py,sha256=tCnFL6ywITqeKR8YoCsYvyJxNoIwoC6GsnI9zkXNB-Q,3128
+lattifai/event/__init__.py,sha256=PPAWzrkRK8YgWhG6CtIUkb7nH8svd9_zGOhxjz0_dcM,2448
+lattifai/event/lattifai.py,sha256=QJqUxJsIWryVVoud_qE8af6zoJ89ZyPgHDvQp4OzXg0,5826
+lattifai/transcription/__init__.py,sha256=vMHciyCEPKhhfM3KjMCeDqnyxU1oghF8g5o5SvpnT_4,2669
+lattifai/transcription/base.py,sha256=ywRjIGg6emTx1v8PCSPyHcdugR6PvdTl10H64Iu1iqs,4617
+lattifai/transcription/gemini.py,sha256=p6uZlhPQuzzUsj226Jk-INOt7NF5g4TIN6yEn1ZwrBI,18030
+lattifai/transcription/lattifai.py,sha256=DA7QSN-a_yIZq79Nc_f6lf8_VWW4qqhyXfoZ1Um-31M,3451
+lattifai/transcription/prompts/README.md,sha256=X49KWSQVdjWxxWUp4R2w3ZqKrAOi6_kDNHh1hMaQ4PE,694
+lattifai/transcription/prompts/__init__.py,sha256=G9b42COaCYv3sPPNkHsGDLOMBuVGKt4mXGYal_BYtYQ,1351
+lattifai/transcription/prompts/gemini/README.md,sha256=rt7f7yDGtaobKBo95LG3u56mqa3ABOXQd0UVgJYtYuo,781
+lattifai/transcription/prompts/gemini/transcription_gem.txt,sha256=cljzZ--BDgnnKzqVCakr-fTp2Xk38UOsUquvruNX-LU,4600
+lattifai/workflow/__init__.py,sha256=INpQgc9gZ2Fp-aTHcpR3TEHGtEtPzjOB8T7-jLzVM0E,1547
+lattifai/workflow/agents.py,sha256=yEOnxnhcTvr1iOhCorNvp8B76P6nQsLRXJCu_rCYFfM,38
+lattifai/workflow/base.py,sha256=8QoVIBZwJfr5mppJbtUFafHv5QR9lL-XrULjTWD0oBg,6257
+lattifai/workflow/file_manager.py,sha256=yc29Vb7JNUMJ9rwM_YjkAHfDInl8HMVAl9A7z7XiIOU,32974
+lattifai/youtube/__init__.py,sha256=_uO3KCx-t6I-JaYFpcYLYpvkbmEOOni3xBqGEbExg68,1587
+lattifai/youtube/client.py,sha256=VU8FC1N7YYpbc4LeJNAsahNAI1R7e3_7Yjmb1rz7tyI,52878
+lattifai/youtube/types.py,sha256=80RgBmvM4tRbxqyNv9GU6hr9vPp_yhKrK0RJ_vG2h4E,472
+lattifai-1.3.0.dist-info/licenses/LICENSE,sha256=xGMLmdFJy6Jkz3Hd0znyQLmcxC93FSZB5isKnEDMoQQ,1066
+lattifai-1.3.0.dist-info/METADATA,sha256=WMgLRzKiJv_Zn1aoxPjWofNZRE4tSjTWxa16zWNYVTk,23008
+lattifai-1.3.0.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+lattifai-1.3.0.dist-info/entry_points.txt,sha256=MfoqXNjXrhD7VMApHgaHmAECTcGVUMUiR0uqnTg7Ads,502
+lattifai-1.3.0.dist-info/top_level.txt,sha256=tHSoXF26r-IGfbIP_JoYATqbmf14h5NrnNJGH4j5reI,9
+lattifai-1.3.0.dist-info/RECORD,,

lattifai/__init__.py

@@ -1,88 +0,0 @@
-import os
-import warnings
-from importlib.metadata import version
-
-# Suppress SWIG deprecation warnings before any imports
-warnings.filterwarnings("ignore", category=DeprecationWarning, message=".*SwigPy.*")
-
-# Suppress PyTorch transformer nested tensor warning
-warnings.filterwarnings("ignore", category=UserWarning, message=".*enable_nested_tensor.*")
-
-# Disable tokenizers parallelism warning
-os.environ["TOKENIZERS_PARALLELISM"] = "false"
-
-# Re-export I/O classes
-from .caption import Caption
-
-# Re-export client classes
-from .client import LattifAI
-
-# Re-export config classes
-from .config import (
-    AUDIO_FORMATS,
-    MEDIA_FORMATS,
-    VIDEO_FORMATS,
-    AlignmentConfig,
-    CaptionConfig,
-    ClientConfig,
-    DiarizationConfig,
-    MediaConfig,
-)
-from .errors import (
-    AlignmentError,
-    APIError,
-    AudioFormatError,
-    AudioLoadError,
-    AudioProcessingError,
-    CaptionParseError,
-    CaptionProcessingError,
-    ConfigurationError,
-    DependencyError,
-    LatticeDecodingError,
-    LatticeEncodingError,
-    LattifAIError,
-    ModelLoadError,
-)
-from .logging import get_logger, set_log_level, setup_logger
-
-try:
-    __version__ = version("lattifai")
-except Exception:
-    __version__ = "0.1.0"  # fallback version
-
-
-__all__ = [
-    # Client classes
-    "LattifAI",
-    # Config classes
-    "AlignmentConfig",
-    "ClientConfig",
-    "CaptionConfig",
-    "DiarizationConfig",
-    "MediaConfig",
-    "AUDIO_FORMATS",
-    "VIDEO_FORMATS",
-    "MEDIA_FORMATS",
-    # Error classes
-    "LattifAIError",
-    "AudioProcessingError",
-    "AudioLoadError",
-    "AudioFormatError",
-    "CaptionProcessingError",
-    "CaptionParseError",
-    "AlignmentError",
-    "LatticeEncodingError",
-    "LatticeDecodingError",
-    "ModelLoadError",
-    "DependencyError",
-    "APIError",
-    "ConfigurationError",
-    # Logging
-    "setup_logger",
-    "get_logger",
-    "set_log_level",
-    # I/O
-    "Caption",
-    # Version
-    "__version__",
-]

lattifai/alignment/sentence_splitter.py

@@ -1,350 +0,0 @@
-import re
-from typing import List, Optional
-
-from lattifai.alignment.punctuation import END_PUNCTUATION
-from lattifai.caption import Supervision
-from lattifai.utils import _resolve_model_path
-
-
-class SentenceSplitter:
-    """Lazy-initialized sentence splitter using wtpsplit."""
-
-    def __init__(self, device: str = "cpu", model_hub: Optional[str] = "modelscope", lazy_init: bool = True):
-        """Initialize sentence splitter with lazy loading.
-
-        Args:
-            device: Device to run the model on (cpu, cuda, mps)
-            model_hub: Model hub to use (None for huggingface, "modelscope" for modelscope)
-        """
-        self.device = device
-        self.model_hub = model_hub
-        self._splitter = None
-        if not lazy_init:
-            self._init_splitter()
-
-    def _init_splitter(self):
-        """Initialize the sentence splitter model on first use."""
-        if self._splitter is not None:
-            return
-
-        import onnxruntime as ort
-        from wtpsplit import SaT
-
-        providers = []
-        device = self.device
-        if device.startswith("cuda") and ort.get_all_providers().count("CUDAExecutionProvider") > 0:
-            providers.append("CUDAExecutionProvider")
-        elif device.startswith("mps") and ort.get_all_providers().count("MPSExecutionProvider") > 0:
-            providers.append("MPSExecutionProvider")
-
-        if self.model_hub == "modelscope":
-            downloaded_path = _resolve_model_path("LattifAI/OmniTokenizer", model_hub="modelscope")
-            sat = SaT(
-                f"{downloaded_path}/sat-3l-sm",
-                tokenizer_name_or_path=f"{downloaded_path}/xlm-roberta-base",
-                ort_providers=providers + ["CPUExecutionProvider"],
-            )
-        else:
-            sat_path = _resolve_model_path("segment-any-text/sat-3l-sm", model_hub="huggingface")
-            sat = SaT(
-                sat_path,
-                tokenizer_name_or_path="facebookAI/xlm-roberta-base",
-                hub_prefix="segment-any-text",
-                ort_providers=providers + ["CPUExecutionProvider"],
-            )
-        self._splitter = sat
-
-    @staticmethod
-    def _distribute_time_info(
-        input_supervisions: List[Supervision],
-        split_texts: List[str],
-    ) -> List[Supervision]:
-        """Distribute time information from input supervisions to split sentences.
-
-        Args:
-            input_supervisions: Original supervisions with time information
-            split_texts: List of split sentence texts
-
-        Returns:
-            List of Supervision objects with distributed time information.
-            Custom attributes are inherited from first_sup with conflict markers.
-        """
-        if not input_supervisions:
-            return [Supervision(text=text, id="", recording_id="", start=0, duration=0) for text in split_texts]
-
-        # Build concatenated input text
-        input_text = " ".join(sup.text for sup in input_supervisions)
-
-        # Pre-compute supervision position mapping for O(1) lookup
-        # Format: [(start_pos, end_pos, supervision), ...]
-        sup_ranges = []
-        char_pos = 0
-        for sup in input_supervisions:
-            sup_start = char_pos
-            sup_end = char_pos + len(sup.text)
-            sup_ranges.append((sup_start, sup_end, sup))
-            char_pos = sup_end + 1  # +1 for space separator
-
-        # Process each split text
-        result = []
-        search_start = 0
-        sup_idx = 0  # Track current supervision index to skip processed ones
-
-        for split_text in split_texts:
-            text_start = input_text.find(split_text, search_start)
-            if text_start == -1:
-                raise ValueError(f"Could not find split text '{split_text}' in input supervisions.")
-
-            text_end = text_start + len(split_text)
-            search_start = text_end
-
-            # Find overlapping supervisions, starting from last used index
-            first_sup = None
-            last_sup = None
-            first_char_idx = None
-            last_char_idx = None
-            overlapping_customs = []  # Track all custom dicts for conflict detection
-
-            # Start from sup_idx, which is the first supervision that might overlap
-            for i in range(sup_idx, len(sup_ranges)):
-                sup_start, sup_end, sup = sup_ranges[i]
-
-                # Skip if no overlap (before text_start)
-                if sup_end <= text_start:
-                    sup_idx = i + 1  # Update starting point for next iteration
-                    continue
-
-                # Stop if no overlap (after text_end)
-                if sup_start >= text_end:
-                    break
-
-                # Found overlap
-                if first_sup is None:
-                    first_sup = sup
-                    first_char_idx = max(0, text_start - sup_start)
-
-                last_sup = sup
-                last_char_idx = min(len(sup.text) - 1, text_end - 1 - sup_start)
-
-                # Collect custom dict for conflict detection
-                if getattr(sup, "custom", None):
-                    overlapping_customs.append(sup.custom)
-
-            if first_sup is None or last_sup is None:
-                raise ValueError(f"Could not find supervisions for split text: {split_text}")
-
-            # Calculate timing
-            start_time = first_sup.start + (first_char_idx / len(first_sup.text)) * first_sup.duration
-            end_time = last_sup.start + ((last_char_idx + 1) / len(last_sup.text)) * last_sup.duration
-
-            # Inherit custom from first_sup, mark conflicts if multiple sources
-            merged_custom = None
-            if overlapping_customs:
-                # Start with first_sup's custom (inherit strategy)
-                merged_custom = overlapping_customs[0].copy() if overlapping_customs[0] else {}
-
-                # Detect conflicts if multiple overlapping supervisions have different custom values
-                if len(overlapping_customs) > 1:
-                    has_conflict = False
-                    for other_custom in overlapping_customs[1:]:
-                        if other_custom and other_custom != overlapping_customs[0]:
-                            has_conflict = True
-                            break
-
-                    if has_conflict:
-                        # Mark that this supervision spans multiple sources with different customs
-                        merged_custom["_split_from_multiple"] = True
-                        merged_custom["_source_count"] = len(overlapping_customs)
-
-            result.append(
-                Supervision(
-                    id="",
-                    text=split_text,
-                    start=start_time,
-                    duration=end_time - start_time,
-                    recording_id=first_sup.recording_id,
-                    custom=merged_custom,
-                )
-            )
-
-        return result
-
-    @staticmethod
-    def _resplit_special_sentence_types(sentence: str) -> List[str]:
-        """
-        Re-split special sentence types.
-
-        Examples:
-        '[APPLAUSE] &gt;&gt; MIRA MURATI:' -> ['[APPLAUSE]', '&gt;&gt; MIRA MURATI:']
-        '[MUSIC] &gt;&gt; SPEAKER:' -> ['[MUSIC]', '&gt;&gt; SPEAKER:']
-
-        Special handling patterns:
-        1. Separate special marks at the beginning (e.g., [APPLAUSE], [MUSIC], etc.) from subsequent speaker marks
-        2. Use speaker marks (&gt;&gt; or other separators) as split points
-
-        Args:
-            sentence: Input sentence string
-
-        Returns:
-            List of re-split sentences. If no special marks are found, returns the original sentence in a list
-        """
-        # Detect special mark patterns: [SOMETHING] &gt;&gt; SPEAKER:
-        # or other forms like [SOMETHING] SPEAKER:
-
-        # Pattern 1: [mark] HTML-encoded separator speaker:
-        pattern1 = r"^(\[[^\]]+\])\s+(&gt;&gt;|>>)\s+(.+)$"
-        match1 = re.match(pattern1, sentence.strip())
-        if match1:
-            special_mark = match1.group(1)
-            separator = match1.group(2)
-            speaker_part = match1.group(3)
-            return [special_mark, f"{separator} {speaker_part}"]
-
-        # Pattern 2: [mark] speaker:
-        pattern2 = r"^(\[[^\]]+\])\s+([^:]+:)(.*)$"
-        match2 = re.match(pattern2, sentence.strip())
-        if match2:
-            special_mark = match2.group(1)
-            speaker_label = match2.group(2)
-            remaining = match2.group(3).strip()
-            if remaining:
-                return [special_mark, f"{speaker_label} {remaining}"]
-            else:
-                return [special_mark, speaker_label]
-
-        # If no special pattern matches, return the original sentence
-        return [sentence]
-
-    def split_sentences(self, supervisions: List[Supervision], strip_whitespace=True) -> List[Supervision]:
-        """Split supervisions into sentences using the sentence splitter.
-
-        Careful about speaker changes.
-
-        Args:
-            supervisions: List of Supervision objects to split
-            strip_whitespace: Whether to strip whitespace from split sentences
-
-        Returns:
-            List of Supervision objects with split sentences
-        """
-        self._init_splitter()
-
-        texts, speakers = [], []
-        text_len, sidx = 0, 0
-
-        def flush_segment(end_idx: int, speaker: Optional[str] = None):
-            """Flush accumulated text from sidx to end_idx with given speaker."""
-            nonlocal text_len, sidx
-            if sidx <= end_idx:
-                if len(speakers) < len(texts) + 1:
-                    speakers.append(speaker)
-                text = " ".join(sup.text for sup in supervisions[sidx : end_idx + 1])
-                texts.append(text)
-                sidx = end_idx + 1
-                text_len = 0
-
-        for s, supervision in enumerate(supervisions):
-            text_len += len(supervision.text)
-            is_last = s == len(supervisions) - 1
-
-            if supervision.speaker:
-                # Flush previous segment without speaker (if any)
-                if sidx < s:
-                    flush_segment(s - 1, None)
-                    text_len = len(supervision.text)
-
-                # Check if we should flush this speaker's segment now
-                next_has_speaker = not is_last and supervisions[s + 1].speaker
-                if is_last or next_has_speaker:
-                    flush_segment(s, supervision.speaker)
-                else:
-                    speakers.append(supervision.speaker)
-
-            elif text_len >= 2000 or is_last:
-                flush_segment(s, None)
-
-        if len(speakers) != len(texts):
-            raise ValueError(f"len(speakers)={len(speakers)} != len(texts)={len(texts)}")
-        sentences = self._splitter.split(texts, threshold=0.15, strip_whitespace=strip_whitespace, batch_size=8)
-
-        # First pass: collect all split texts with their speakers
-        split_texts_with_speakers = []
-        remainder = ""
-        remainder_speaker = None
-
-        for k, (_speaker, _sentences) in enumerate(zip(speakers, sentences)):
-            # Prepend remainder from previous iteration to the first sentence
-            if _sentences and remainder:
-                _sentences[0] = remainder + _sentences[0]
-                _speaker = remainder_speaker if remainder_speaker else _speaker
-                remainder = ""
-                remainder_speaker = None
-
-            if not _sentences:
-                continue
-
-            # Process and re-split special sentence types
-            processed_sentences = []
-            for s, _sentence in enumerate(_sentences):
-                if remainder:
-                    _sentence = remainder + _sentence
-                    remainder = ""
-                # Detect and split special sentence types: e.g., '[APPLAUSE] &gt;&gt; MIRA MURATI:' -> ['[APPLAUSE]', '&gt;&gt; MIRA MURATI:']  # noqa: E501
-                resplit_parts = self._resplit_special_sentence_types(_sentence)
-                if any(resplit_parts[-1].endswith(sp) for sp in [":", "："]):
-                    if s < len(_sentences) - 1:
-                        _sentences[s + 1] = resplit_parts[-1] + " " + _sentences[s + 1]
-                    else:  # last part
-                        remainder = resplit_parts[-1] + " "
-                    processed_sentences.extend(resplit_parts[:-1])
-                else:
-                    processed_sentences.extend(resplit_parts)
-            _sentences = processed_sentences
-
-            if not _sentences:
-                if remainder:
-                    _sentences, remainder = [remainder.strip()], ""
-                else:
-                    continue
-
-            if any(_sentences[-1].endswith(ep) for ep in END_PUNCTUATION):
-                split_texts_with_speakers.extend(
-                    (text, _speaker if s == 0 else None) for s, text in enumerate(_sentences)
-                )
-                _speaker = None  # reset speaker after use
-            else:
-                split_texts_with_speakers.extend(
-                    (text, _speaker if s == 0 else None) for s, text in enumerate(_sentences[:-1])
-                )
-                remainder = _sentences[-1] + " " + remainder
-                if k < len(speakers) - 1 and speakers[k + 1] is not None:  # next speaker is set
-                    split_texts_with_speakers.append((remainder.strip(), _speaker if len(_sentences) == 1 else None))
-                    remainder = ""
-                    remainder_speaker = None
-                elif len(_sentences) == 1:
-                    remainder_speaker = _speaker
-                    if k == len(speakers) - 1:
-                        pass  # keep _speaker for the last supervision
-                    elif speakers[k + 1] is not None:
-                        raise ValueError(f"Expected speakers[{k + 1}] to be None, got {speakers[k + 1]}")
-                    else:
-                        speakers[k + 1] = _speaker
-                elif len(_sentences) > 1:
-                    _speaker = None  # reset speaker if sentence not ended
-                    remainder_speaker = None
-                else:
-                    raise ValueError(f"Unexpected state: len(_sentences)={len(_sentences)}")
-
-        if remainder.strip():
-            split_texts_with_speakers.append((remainder.strip(), remainder_speaker))
-
-        # Second pass: distribute time information
-        split_texts = [text for text, _ in split_texts_with_speakers]
-        result_supervisions = self._distribute_time_info(supervisions, split_texts)
-
-        # Third pass: add speaker information
-        for sup, (_, speaker) in zip(result_supervisions, split_texts_with_speakers):
-            if speaker:
-                sup.speaker = speaker
-
-        return result_supervisions

lattifai/caption/__init__.py

@@ -1,96 +0,0 @@
-"""Caption processing module for LattifAI.
-
-This module provides comprehensive caption/subtitle processing capabilities:
-- Multi-format reading and writing (SRT, VTT, ASS, TTML, etc.)
-- Professional NLE integration (Avid, Final Cut Pro, Premiere Pro, DaVinci Resolve)
-- Audio workstation support (Pro Tools, Adobe Audition)
-- Advanced features: timecode offset, overlap resolution, word-level timing
-"""
-
-from ..config.caption import InputCaptionFormat, OutputCaptionFormat
-from .caption import Caption
-from .formats.gemini import GeminiReader, GeminiSegment, GeminiWriter
-from .formats.nle.audition import (
-    AuditionCSVConfig,
-    AuditionCSVWriter,
-    EdiMarkerConfig,
-    EdiMarkerWriter,
-)
-
-# Professional NLE format writers (re-exported from formats/)
-from .formats.nle.avid import AvidDSConfig, AvidDSWriter, FrameRate
-from .formats.nle.fcpxml import FCPXMLConfig, FCPXMLStyle, FCPXMLWriter
-from .formats.nle.premiere import PremiereXMLConfig, PremiereXMLWriter
-from .formats.ttml import TTMLConfig, TTMLFormat, TTMLRegion, TTMLStyle
-from .parsers.text_parser import normalize_text
-from .standardize import (
-    CaptionStandardizer,
-    CaptionValidator,
-    StandardizationConfig,
-    ValidationResult,
-    apply_margins_to_captions,
-    standardize_captions,
-)
-from .supervision import Supervision
-
-# Create TTMLWriter alias for backward compatibility
-TTMLWriter = TTMLFormat
-
-# Utility functions
-from .utils import (
-    CollisionMode,
-    TimecodeOffset,
-    apply_timecode_offset,
-    detect_overlaps,
-    format_srt_timestamp,
-    generate_srt_content,
-    resolve_overlaps,
-    split_long_lines,
-)
-
-__all__ = [
-    # Core classes
-    "Caption",
-    "Supervision",
-    # Standardization
-    "CaptionStandardizer",
-    "CaptionValidator",
-    "StandardizationConfig",
-    "ValidationResult",
-    "standardize_captions",
-    "apply_margins_to_captions",
-    # Gemini format support
-    "GeminiReader",
-    "GeminiWriter",
-    "GeminiSegment",
-    # Text utilities
-    "normalize_text",
-    # Format types
-    "InputCaptionFormat",
-    "OutputCaptionFormat",
-    # Professional format writers
-    "AvidDSWriter",
-    "AvidDSConfig",
-    "FCPXMLWriter",
-    "FCPXMLConfig",
-    "FCPXMLStyle",
-    "PremiereXMLWriter",
-    "PremiereXMLConfig",
-    "AuditionCSVWriter",
-    "AuditionCSVConfig",
-    "EdiMarkerWriter",
-    "EdiMarkerConfig",
-    "TTMLWriter",
-    "TTMLConfig",
-    "TTMLStyle",
-    "TTMLRegion",
-    # Utilities
-    "CollisionMode",
-    "TimecodeOffset",
-    "apply_timecode_offset",
-    "resolve_overlaps",
-    "detect_overlaps",
-    "split_long_lines",
-    "format_srt_timestamp",
-    "generate_srt_content",
-]