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

lattifai-1.2.2.dist-info/RECORD

@@ -0,0 +1,76 @@
+lattifai/__init__.py,sha256=RXa1IK8Qt6jsAnLlxecOCZmREqv2naXx6T1Fy0g6pqU,1953
+lattifai/audio2.py,sha256=P3N8_BwiscbetzDbkbj-n8BcMu2vWD6-MvtQvGwWWf0,17448
+lattifai/client.py,sha256=pTtpOZRpc3weXkjKZ_-FZLsbbs1CrzVqM4fVqRjiYTc,17179
+lattifai/errors.py,sha256=LyWRGVhQ6Ak2CYn9FBYAPRgQ7_VHpxzNsXI31HXD--s,11291
+lattifai/logging.py,sha256=MbUEeOUFlF92pA9v532DiPPWKl03S7UHCJ6Z652cf0w,2860
+lattifai/mixin.py,sha256=0I-rwvZumaYt8KFTfiVPT2wpXs-JfTEnLOPTdI5r-bM,26115
+lattifai/types.py,sha256=SjYBfwrCBOXlICvH04niFQJ7OzTx7oTaa_npfRkB67U,659
+lattifai/utils.py,sha256=5LeunAN0OQ1jWoKMIThpXSEOxFYD2dCRTdsglosodUU,7963
+lattifai/alignment/__init__.py,sha256=ggOF4MlbnBD7U9yrcyRb1caBR3se_KGA87cfYlyX8RY,450
+lattifai/alignment/lattice1_aligner.py,sha256=WG3mJM4fGyYkY7FdqhPE10yXwBzhdj2TkS-6LF8F_9k,6463
+lattifai/alignment/lattice1_worker.py,sha256=hQbZTgncPq3n-b_l-gUPDPfm460EwuZTKveErgWLWNk,10891
+lattifai/alignment/phonemizer.py,sha256=fbhN2DOl39lW4nQWKzyUUTMUabg7v61lB1kj8SKK-Sw,1761
+lattifai/alignment/punctuation.py,sha256=qLcvuXhBzoEa6bznWZiAB5TAxR6eLr_ZV-PnnCY90UA,1218
+lattifai/alignment/segmenter.py,sha256=0s0eABe0rLAo7eNfl0l5e_knxmZba_BjabPdqsRD45E,6284
+lattifai/alignment/sentence_splitter.py,sha256=2ORvfAgW9yQaqHjts2zlSFjTiNDZF5Fhd5KZX19QWe0,14781
+lattifai/alignment/text_align.py,sha256=PN7RNL5d6jim96zeCUdfdFEdGw--I8zc0kcgWIFJIXU,14910
+lattifai/alignment/tokenizer.py,sha256=AQzXbJ_AW8cg4CAd5TVl1Qd3zH56uy9whX9LVFQ4AaA,17835
+lattifai/caption/__init__.py,sha256=tyIsUvCbImw_qrhp0Nxxrk4vt9szJIPlRcTBviOQkuI,2641
+lattifai/caption/caption.py,sha256=2PHLRDG0Ks4JMl6jNDeXlrI1kpYinektbZ15GwwTcFI,23479
+lattifai/caption/standardize.py,sha256=1pAB8BmziTqYkgj7abCXUcNmNwSV1EAR0PrmbpAEipU,21491
+lattifai/caption/supervision.py,sha256=DRrM8lfKU_x9aVBcLG6xnT0xIJrnc8jzHpzcSwQOg8c,905
+lattifai/caption/utils.py,sha256=YOdJCXhy-6DdrZUkdrJHuPE9sbEHsE9Z7-Vdo4Z5lLY,14406
+lattifai/caption/formats/__init__.py,sha256=UGl7Y0ybMf_F4hiNMMwoKOrpWNxs5m2tiD5zkbwjokY,5240
+lattifai/caption/formats/base.py,sha256=gGeKLKEAB2Hs05R09QMkq5KlXMIQ7bbkUhLct40IcU8,6314
+lattifai/caption/formats/gemini.py,sha256=zIxK7Vxo2YB1eXFiWnsNrz9WSx69lMN0rL-Sd3r57iI,29389
+lattifai/caption/formats/json.py,sha256=s3tFWMUzkWx_IL46phPJnFbJW476Yh_GsxcwD7Q_Mfw,6416
+lattifai/caption/formats/lrc.py,sha256=CWS9wD3Tp6xuvF5gP1nTlVBsBXYnu59_4m4zNRem-c0,11084
+lattifai/caption/formats/pysubs2.py,sha256=eOTQKRbsFStW9gTHaxuAtD7ha1OnrFdqcNLsjdxpHRY,22591
+lattifai/caption/formats/sbv.py,sha256=QUgm5lfRSc2IGSX955yQ7rPiSlaYrOHvniUigr2sF7Y,4520
+lattifai/caption/formats/tabular.py,sha256=HHoiif2yIkMjO9f1bRNAk5Pc0CfkA1mtCFHk5sdLocM,11701
+lattifai/caption/formats/textgrid.py,sha256=m2jMTwLhQa8gbm0Fs1XyEUdiHJaSfCxB9jrYsdk8j7Q,6659
+lattifai/caption/formats/ttml.py,sha256=pJ_wd9pX-MwOhDFMeAHnCpbDiLtIhs888rkW26T7w9Y,23236
+lattifai/caption/formats/vtt.py,sha256=f5OWqsr-2-ddW3CnMtiiqYKQz-hLYRn2B9WM_eT4-AM,17102
+lattifai/caption/formats/nle/__init__.py,sha256=DPBnWPtxEKCC0J_8DCeTyXULPgkrqFT2jbKvkazAx0s,257
+lattifai/caption/formats/nle/audition.py,sha256=65ipbUPdwgvNcUA--dQuisWCbmlt6nHPRbSdl4UUF2Q,18076
+lattifai/caption/formats/nle/avid.py,sha256=UQwFlN4-Myly-kXZxuJTu-7IunEN2_PtAcK9YGQVpMA,14403
+lattifai/caption/formats/nle/fcpxml.py,sha256=76NL6PeIR3KAG1BZscAZdoFJr5wcNdoS4j3VZsOxFV8,18317
+lattifai/caption/formats/nle/premiere.py,sha256=Y2nXSWxI0J0YhV3iHJ9jDrFs0S_5sX32_fEi9SJyVt0,21319
+lattifai/caption/parsers/__init__.py,sha256=z1JMr47FVl7CGbBDg92PKj9RabKktJIUv9iTmmKfEes,227
+lattifai/caption/parsers/text_parser.py,sha256=rQv-aedTWowBe7crvYEOrHqrgKdpNBPcM8HeU-jElHY,4793
+lattifai/cli/__init__.py,sha256=PdqoCTqRSFSWrqL3FjBTa5VzJy_e6Rq0OzyT7YkyHpc,541
+lattifai/cli/alignment.py,sha256=06em-Uaf6NhSz1ce4dwT2r8n56NrtibR7ZsSkmc18Kc,5954
+lattifai/cli/caption.py,sha256=b2mSVFVgL76b4FB5UoJ7AW5iGzPfKiWiLhbM96z_QoA,10371
+lattifai/cli/diarization.py,sha256=GTd2vnTm6cJN6Q3mFP-ShY9bZBl1_zKzWFu-4HHcMzk,4075
+lattifai/cli/transcribe.py,sha256=YhEalG3TQRK7esAN5SOZUQPwIk3TAI9ZknO8cW8C21Q,8038
+lattifai/cli/youtube.py,sha256=CqAxSC_sErslnrnx2RSwAHc7INKET0wLG9Mf_144O-A,6238
+lattifai/config/__init__.py,sha256=JOOn2WbvWXBN6a_3fSNt24W7xnJY7wn8RyNLa0XIY3s,724
+lattifai/config/alignment.py,sha256=ObWf896GGLfP4jsxJaSk6nUyzeF4MvW-ULoPYa8kd9w,4987
+lattifai/config/caption.py,sha256=D4sKNUestwFessU1nZrUqCTsIzYPgpTg12SZlm0HzbQ,15200
+lattifai/config/client.py,sha256=46b816MiYja3Uan_3wjnhtqDr0M6T-FqEygJ3e50IZc,1664
+lattifai/config/diarization.py,sha256=cIkwCfsYqfMns3i6tKWcwBBBkdnhhmB_Eo0TuOPCw9o,2484
+lattifai/config/media.py,sha256=nxvgC7zeLsthCARPPUbnK2eMJY8R1d-1XgiAsy8kroA,15568
+lattifai/config/transcription.py,sha256=_gPJD6cob_jWNdf841nBHhAqJGCxS6PfSyvx2W_vPcM,3082
+lattifai/diarization/__init__.py,sha256=-ZZ_a5hIQgnlHIOehCTtmVmWOWC2H6eOhSs4AcVtRtk,1782
+lattifai/diarization/lattifai.py,sha256=tCnFL6ywITqeKR8YoCsYvyJxNoIwoC6GsnI9zkXNB-Q,3128
+lattifai/transcription/__init__.py,sha256=vMHciyCEPKhhfM3KjMCeDqnyxU1oghF8g5o5SvpnT_4,2669
+lattifai/transcription/base.py,sha256=A2qnocdRCCbvy8mKP0f3K3mx3ZvYyxVXir3aJ2iU19s,4592
+lattifai/transcription/gemini.py,sha256=LJSQt9nGqQdEG6ZFXoHWltumyMEM7-Ezy8ss0iPJb7k,12414
+lattifai/transcription/lattifai.py,sha256=Sik4IyvzdqIMCvgkaxCzqvo-j7u0MfX045z8AJunjhg,3556
+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=aEOnd8jp4w1ZZkTfxppl7yz2TVdxMTkb8lGCqQxLqxE,47128
+lattifai/youtube/types.py,sha256=80RgBmvM4tRbxqyNv9GU6hr9vPp_yhKrK0RJ_vG2h4E,472
+lattifai-1.2.2.dist-info/licenses/LICENSE,sha256=xGMLmdFJy6Jkz3Hd0znyQLmcxC93FSZB5isKnEDMoQQ,1066
+lattifai-1.2.2.dist-info/METADATA,sha256=NncEA5sSiDyj2DfZCt251tLSranIOn2Gd4KD2D0Q118,19757
+lattifai-1.2.2.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+lattifai-1.2.2.dist-info/entry_points.txt,sha256=MfoqXNjXrhD7VMApHgaHmAECTcGVUMUiR0uqnTg7Ads,502
+lattifai-1.2.2.dist-info/top_level.txt,sha256=tHSoXF26r-IGfbIP_JoYATqbmf14h5NrnNJGH4j5reI,9
+lattifai-1.2.2.dist-info/RECORD,,

{lattifai-1.2.0.dist-info → lattifai-1.2.2.dist-info}/entry_points.txt

@@ -1,11 +1,10 @@
 [console_scripts]
 lai-align = lattifai.cli.alignment:main
-lai-app-install = lattifai.cli.app_installer:main
 lai-diarize = lattifai.cli.diarization:main
-lai-server = lattifai.cli.server:main
 lai-transcribe = lattifai.cli.transcribe:main
 lai-youtube = lattifai.cli.youtube:main
 laicap-convert = lattifai.cli.caption:main_convert
+laicap-diff = lattifai.cli.caption:main_diff
 laicap-normalize = lattifai.cli.caption:main_normalize
 laicap-shift = lattifai.cli.caption:main_shift
 

lattifai/caption/gemini_reader.py

@@ -1,371 +0,0 @@
-"""Reader for YouTube transcript files with speaker labels and timestamps."""
-
-import re
-from dataclasses import dataclass
-from pathlib import Path
-from typing import List, Optional
-
-from lhotse.utils import Pathlike
-
-from .supervision import Supervision
-
-
-@dataclass
-class GeminiSegment:
-    """Represents a segment in the Gemini transcript with metadata."""
-
-    text: str
-    timestamp: Optional[float] = None
-    speaker: Optional[str] = None
-    section: Optional[str] = None
-    segment_type: str = "dialogue"  # 'dialogue', 'event', or 'section_header'
-    line_number: int = 0
-
-    @property
-    def start(self) -> float:
-        """Return start time in seconds."""
-        return self.timestamp if self.timestamp is not None else 0.0
-
-
-class GeminiReader:
-    """Parser for YouTube transcript format with speaker labels and timestamps."""
-
-    # Regex patterns for parsing (supports both [HH:MM:SS] and [MM:SS] formats)
-    TIMESTAMP_PATTERN = re.compile(r"\[(\d{1,2}):(\d{2}):(\d{2})\]|\[(\d{1,2}):(\d{2})\]")
-    SECTION_HEADER_PATTERN = re.compile(r"^##\s*\[(\d{1,2}):(\d{2}):(\d{2})\]\s*(.+)$")
-    SPEAKER_PATTERN = re.compile(r"^\*\*(.+?[:：])\*\*\s*(.+)$")
-    EVENT_PATTERN = re.compile(r"^\[([^\]]+)\]\s*\[(?:(\d{1,2}):(\d{2}):(\d{2})|(\d{1,2}):(\d{2}))\]$")
-    INLINE_TIMESTAMP_PATTERN = re.compile(r"^(.+?)\s*\[(?:(\d{1,2}):(\d{2}):(\d{2})|(\d{1,2}):(\d{2}))\]$")
-
-    # New patterns for YouTube link format: [[MM:SS](URL&t=seconds)]
-    YOUTUBE_SECTION_PATTERN = re.compile(r"^##\s*\[\[(\d{1,2}):(\d{2})\]\([^)]*&t=(\d+)\)\]\s*(.+)$")
-    YOUTUBE_INLINE_PATTERN = re.compile(r"^(.+?)\s*\[\[(\d{1,2}):(\d{2})\]\([^)]*&t=(\d+)\)\]$")
-
-    @classmethod
-    def parse_timestamp(cls, *args) -> float:
-        """Convert timestamp to seconds.
-
-        Supports both HH:MM:SS and MM:SS formats.
-        Args can be (hours, minutes, seconds) or (minutes, seconds).
-        Can also accept a single argument which is seconds.
-        """
-        if len(args) == 3:
-            # HH:MM:SS format
-            hours, minutes, seconds = args
-            return int(hours) * 3600 + int(minutes) * 60 + int(seconds)
-        elif len(args) == 2:
-            # MM:SS format
-            minutes, seconds = args
-            return int(minutes) * 60 + int(seconds)
-        elif len(args) == 1:
-            # Direct seconds (from YouTube &t= parameter)
-            return int(args[0])
-        else:
-            raise ValueError(f"Invalid timestamp args: {args}")
-
-    @classmethod
-    def read(
-        cls,
-        transcript_path: Pathlike,
-        include_events: bool = False,
-        include_sections: bool = False,
-    ) -> List[GeminiSegment]:
-        """Parse YouTube transcript file and return list of transcript segments.
-
-        Args:
-                transcript_path: Path to the transcript file
-                include_events: Whether to include event descriptions like [Applause]
-                include_sections: Whether to include section headers
-
-        Returns:
-                List of GeminiSegment objects with all metadata
-        """
-        transcript_path = Path(transcript_path).expanduser().resolve()
-        if not transcript_path.exists():
-            raise FileNotFoundError(f"Transcript file not found: {transcript_path}")
-
-        segments: List[GeminiSegment] = []
-        current_section = None
-        current_speaker = None
-
-        with open(transcript_path, "r", encoding="utf-8") as f:
-            lines = f.readlines()
-
-        for line_num, line in enumerate(lines, start=1):
-            line = line.strip()
-            if not line:
-                continue
-
-            # Skip table of contents
-            if line.startswith("* ["):
-                continue
-            if line.startswith("## Table of Contents"):
-                continue
-
-            # Parse section headers
-            section_match = cls.SECTION_HEADER_PATTERN.match(line)
-            if section_match:
-                hours, minutes, seconds, section_title = section_match.groups()
-                timestamp = cls.parse_timestamp(hours, minutes, seconds)
-                current_section = section_title.strip()
-                if include_sections:
-                    segments.append(
-                        GeminiSegment(
-                            text=section_title.strip(),
-                            timestamp=timestamp,
-                            section=current_section,
-                            segment_type="section_header",
-                            line_number=line_num,
-                        )
-                    )
-                continue
-
-            # Parse YouTube format section headers: ## [[MM:SS](URL&t=seconds)] Title
-            youtube_section_match = cls.YOUTUBE_SECTION_PATTERN.match(line)
-            if youtube_section_match:
-                minutes, seconds, url_seconds, section_title = youtube_section_match.groups()
-                # Use the URL seconds for more accuracy
-                timestamp = cls.parse_timestamp(url_seconds)
-                current_section = section_title.strip()
-                if include_sections:
-                    segments.append(
-                        GeminiSegment(
-                            text=section_title.strip(),
-                            timestamp=timestamp,
-                            section=current_section,
-                            segment_type="section_header",
-                            line_number=line_num,
-                        )
-                    )
-                continue
-
-            # Parse event descriptions [event] [HH:MM:SS] or [MM:SS]
-            event_match = cls.EVENT_PATTERN.match(line)
-            if event_match:
-                groups = event_match.groups()
-                event_text = groups[0]
-                # Parse timestamp - can be HH:MM:SS (groups 1,2,3) or MM:SS (groups 4,5)
-                if groups[1] is not None:  # HH:MM:SS format
-                    timestamp = cls.parse_timestamp(groups[1], groups[2], groups[3])
-                elif groups[4] is not None:  # MM:SS format
-                    timestamp = cls.parse_timestamp(groups[4], groups[5])
-                else:
-                    timestamp = None
-
-                if include_events and timestamp is not None:
-                    segments.append(
-                        GeminiSegment(
-                            text=event_text.strip(),
-                            timestamp=timestamp,
-                            section=current_section,
-                            segment_type="event",
-                            line_number=line_num,
-                        )
-                    )
-                continue
-
-            # Parse speaker dialogue: **Speaker:** Text [HH:MM:SS] or [MM:SS]
-            speaker_match = cls.SPEAKER_PATTERN.match(line)
-            if speaker_match:
-                speaker, text_with_timestamp = speaker_match.groups()
-                current_speaker = speaker.strip()
-
-                # Extract timestamp from the end of the text
-                timestamp_match = cls.INLINE_TIMESTAMP_PATTERN.match(text_with_timestamp.strip())
-                youtube_match = cls.YOUTUBE_INLINE_PATTERN.match(text_with_timestamp.strip())
-
-                if timestamp_match:
-                    groups = timestamp_match.groups()
-                    text = groups[0]
-                    # Parse timestamp - can be HH:MM:SS (groups 1,2,3) or MM:SS (groups 4,5)
-                    if groups[1] is not None:  # HH:MM:SS format
-                        timestamp = cls.parse_timestamp(groups[1], groups[2], groups[3])
-                    elif groups[4] is not None:  # MM:SS format
-                        timestamp = cls.parse_timestamp(groups[4], groups[5])
-                    else:
-                        timestamp = None
-                elif youtube_match:
-                    groups = youtube_match.groups()
-                    text = groups[0]
-                    # Extract seconds from URL parameter
-                    url_seconds = groups[3]
-                    timestamp = cls.parse_timestamp(url_seconds)
-                else:
-                    text = text_with_timestamp.strip()
-                    timestamp = None
-
-                segments.append(
-                    GeminiSegment(
-                        text=text.strip(),
-                        timestamp=timestamp,
-                        speaker=current_speaker,
-                        section=current_section,
-                        segment_type="dialogue",
-                        line_number=line_num,
-                    )
-                )
-                current_speaker = None  # Reset speaker after use
-                continue
-
-            # Parse plain text with timestamp at the end
-            inline_match = cls.INLINE_TIMESTAMP_PATTERN.match(line)
-            youtube_inline_match = cls.YOUTUBE_INLINE_PATTERN.match(line)
-
-            if inline_match:
-                groups = inline_match.groups()
-                text = groups[0]
-                # Parse timestamp - can be HH:MM:SS (groups 1,2,3) or MM:SS (groups 4,5)
-                if groups[1] is not None:  # HH:MM:SS format
-                    timestamp = cls.parse_timestamp(groups[1], groups[2], groups[3])
-                elif groups[4] is not None:  # MM:SS format
-                    timestamp = cls.parse_timestamp(groups[4], groups[5])
-                else:
-                    timestamp = None
-
-                segments.append(
-                    GeminiSegment(
-                        text=text.strip(),
-                        timestamp=timestamp,
-                        speaker=current_speaker,
-                        section=current_section,
-                        segment_type="dialogue",
-                        line_number=line_num,
-                    )
-                )
-                continue
-            elif youtube_inline_match:
-                groups = youtube_inline_match.groups()
-                text = groups[0]
-                # Extract seconds from URL parameter
-                url_seconds = groups[3]
-                timestamp = cls.parse_timestamp(url_seconds)
-
-                segments.append(
-                    GeminiSegment(
-                        text=text.strip(),
-                        timestamp=timestamp,
-                        speaker=current_speaker,
-                        section=current_section,
-                        segment_type="dialogue",
-                        line_number=line_num,
-                    )
-                )
-                continue
-
-            # Skip markdown headers and other formatting
-            if line.startswith("#"):
-                continue
-
-        return segments
-
-    @classmethod
-    def extract_for_alignment(
-        cls,
-        transcript_path: Pathlike,
-        merge_consecutive: bool = False,
-        min_duration: float = 0.1,
-        merge_max_gap: float = 2.0,
-    ) -> List[Supervision]:
-        """Extract text segments for forced alignment.
-
-        This extracts only dialogue segments (not events or section headers)
-        and converts them to Supervision objects suitable for alignment.
-
-        Args:
-                transcript_path: Path to the transcript file
-                merge_consecutive: Whether to merge consecutive segments from same speaker
-                min_duration: Minimum duration for a segment
-                merge_max_gap: Maximum time gap (seconds) to merge consecutive segments
-
-        Returns:
-                List of Supervision objects ready for alignment
-        """
-        segments = cls.read(transcript_path, include_events=False, include_sections=False)
-
-        # Filter to only dialogue segments with timestamps
-        dialogue_segments = [s for s in segments if s.segment_type == "dialogue" and s.timestamp is not None]
-
-        if not dialogue_segments:
-            raise ValueError(f"No dialogue segments with timestamps found in {transcript_path}")
-
-        # Sort by timestamp
-        dialogue_segments.sort(key=lambda x: x.timestamp)
-
-        # Convert to Supervision objects
-        supervisions: List[Supervision] = []
-
-        for i, segment in enumerate(dialogue_segments):
-            # Estimate duration based on next segment
-            if i < len(dialogue_segments) - 1:
-                duration = dialogue_segments[i + 1].timestamp - segment.timestamp
-            else:
-                # Last segment: estimate based on text length (rough heuristic)
-                words = len(segment.text.split())
-                duration = words * 0.3  # ~0.3 seconds per word
-
-            supervisions.append(
-                Supervision(
-                    text=segment.text,
-                    start=segment.timestamp,
-                    duration=max(duration, min_duration),
-                    id=f"segment_{i:05d}",
-                    speaker=segment.speaker,
-                )
-            )
-
-        # Optionally merge consecutive segments from same speaker
-        if merge_consecutive:
-            merged = []
-            current_speaker = None
-            current_texts = []
-            current_start = None
-            last_end_time = None
-
-            for i, (segment, sup) in enumerate(zip(dialogue_segments, supervisions)):
-                # Check if we should merge with previous segment
-                should_merge = False
-                if segment.speaker == current_speaker and current_start is not None:
-                    # Same speaker - check time gap
-                    time_gap = sup.start - last_end_time if last_end_time else 0
-                    if time_gap <= merge_max_gap:
-                        should_merge = True
-
-                if should_merge:
-                    # Same speaker within time threshold, accumulate
-                    current_texts.append(segment.text)
-                    last_end_time = sup.start + sup.duration
-                else:
-                    # Different speaker or gap too large, save previous segment
-                    if current_texts:
-                        merged_text = " ".join(current_texts)
-                        merged.append(
-                            Supervision(
-                                text=merged_text,
-                                start=current_start,
-                                duration=last_end_time - current_start,
-                                id=f"merged_{len(merged):05d}",
-                            )
-                        )
-                    current_speaker = segment.speaker
-                    current_texts = [segment.text]
-                    current_start = sup.start
-                    last_end_time = sup.start + sup.duration
-
-            # Add final segment
-            if current_texts:
-                merged_text = " ".join(current_texts)
-                merged.append(
-                    Supervision(
-                        text=merged_text,
-                        start=current_start,
-                        duration=last_end_time - current_start,
-                        id=f"merged_{len(merged):05d}",
-                    )
-                )
-
-            supervisions = merged
-
-        return supervisions
-
-
-__all__ = ["GeminiReader", "GeminiSegment"]

lattifai/caption/gemini_writer.py

@@ -1,173 +0,0 @@
-"""Writer for YouTube transcript files with corrected timestamps from alignment."""
-
-import re
-from pathlib import Path
-from typing import Dict, List, Optional
-
-from lhotse.utils import Pathlike
-
-from .gemini_reader import GeminiReader, GeminiSegment
-from .supervision import Supervision
-
-
-class GeminiWriter:
-    """Writer for updating YouTube transcript timestamps based on alignment results."""
-
-    @staticmethod
-    def format_timestamp(seconds: float) -> str:
-        """Convert seconds to [HH:MM:SS] format."""
-        hours = int(seconds // 3600)
-        minutes = int((seconds % 3600) // 60)
-        secs = int(seconds % 60)
-        return f"[{hours:02d}:{minutes:02d}:{secs:02d}]"
-
-    @classmethod
-    def update_timestamps(
-        cls,
-        original_transcript: Pathlike,
-        aligned_supervisions: List[Supervision],
-        output_path: Pathlike,
-        timestamp_mapping: Optional[Dict[int, float]] = None,
-    ) -> Pathlike:
-        """Update transcript file with corrected timestamps from alignment.
-
-        Args:
-                original_transcript: Path to the original transcript file
-                aligned_supervisions: List of aligned Supervision objects with corrected timestamps
-                output_path: Path to write the updated transcript
-                timestamp_mapping: Optional manual mapping from line_number to new timestamp
-
-        Returns:
-                Path to the output file
-        """
-        original_path = Path(original_transcript)
-        output_path = Path(output_path)
-
-        # Read original file
-        with open(original_path, "r", encoding="utf-8") as f:
-            lines = f.readlines()
-
-        # Parse original segments to get line numbers
-        original_segments = GeminiReader.read(original_transcript, include_events=True, include_sections=True)
-
-        # Create mapping from line number to new timestamp
-        if timestamp_mapping is None:
-            timestamp_mapping = cls._create_timestamp_mapping(original_segments, aligned_supervisions)
-
-        # Update timestamps in lines
-        updated_lines = []
-        for line_num, line in enumerate(lines, start=1):
-            if line_num in timestamp_mapping:
-                new_timestamp = timestamp_mapping[line_num]
-                updated_line = cls._replace_timestamp(line, new_timestamp)
-                updated_lines.append(updated_line)
-            else:
-                updated_lines.append(line)
-
-        # Write updated content
-        output_path.parent.mkdir(parents=True, exist_ok=True)
-        with open(output_path, "w", encoding="utf-8") as f:
-            f.writelines(updated_lines)
-
-        return output_path
-
-    @classmethod
-    def _create_timestamp_mapping(
-        cls, original_segments: List[GeminiSegment], aligned_supervisions: List[Supervision]
-    ) -> Dict[int, float]:
-        """Create mapping from line numbers to new timestamps based on alignment.
-
-        This performs text matching between original segments and aligned supervisions
-        to determine which timestamps should be updated.
-        """
-        mapping = {}
-
-        # Create a simple text-based matching
-        dialogue_segments = [s for s in original_segments if s.segment_type == "dialogue"]
-
-        # Try to match based on text content
-        for aligned_sup in aligned_supervisions:
-            aligned_text = aligned_sup.text.strip()
-
-            # Find best matching original segment
-            best_match = None
-            best_score = 0
-
-            for orig_seg in dialogue_segments:
-                orig_text = orig_seg.text.strip()
-
-                # Simple text similarity (could be improved with fuzzy matching)
-                if aligned_text == orig_text:
-                    best_match = orig_seg
-                    best_score = 1.0
-                    break
-                elif aligned_text in orig_text or orig_text in aligned_text:
-                    score = min(len(aligned_text), len(orig_text)) / max(len(aligned_text), len(orig_text))
-                    if score > best_score:
-                        best_score = score
-                        best_match = orig_seg
-
-            # If we found a good match, update the mapping
-            if best_match and best_score > 0.8:
-                mapping[best_match.line_number] = aligned_sup.start
-
-        return mapping
-
-    @classmethod
-    def _replace_timestamp(cls, line: str, new_timestamp: float) -> str:
-        """Replace timestamp in a line with new timestamp."""
-        new_ts_str = cls.format_timestamp(new_timestamp)
-
-        # Replace timestamp patterns
-        # Pattern 1: [HH:MM:SS] at the end or in brackets
-        line = re.sub(r"\[\d{2}:\d{2}:\d{2}\]", new_ts_str, line)
-
-        return line
-
-    @classmethod
-    def write_aligned_transcript(
-        cls,
-        aligned_supervisions: List[Supervision],
-        output_path: Pathlike,
-        include_word_timestamps: bool = False,
-    ) -> Pathlike:
-        """Write a new transcript file from aligned supervisions.
-
-        This creates a simplified transcript format with accurate timestamps.
-
-        Args:
-                aligned_supervisions: List of aligned Supervision objects
-                output_path: Path to write the transcript
-                include_word_timestamps: Whether to include word-level timestamps if available
-
-        Returns:
-                Path to the output file
-        """
-        output_path = Path(output_path)
-        output_path.parent.mkdir(parents=True, exist_ok=True)
-
-        with open(output_path, "w", encoding="utf-8") as f:
-            f.write("# Aligned Transcript\n\n")
-
-            for i, sup in enumerate(aligned_supervisions):
-                # Write segment with timestamp
-                start_ts = cls.format_timestamp(sup.start)
-                f.write(f"{start_ts} {sup.text}\n")
-
-                # Optionally write word-level timestamps
-                if include_word_timestamps and hasattr(sup, "alignment") and sup.alignment:
-                    if "word" in sup.alignment:
-                        f.write("  Words: ")
-                        word_parts = []
-                        for word_info in sup.alignment["word"]:
-                            word_ts = cls.format_timestamp(word_info["start"])
-                            word_parts.append(f'{word_info["symbol"]}{word_ts}')
-                        f.write(" ".join(word_parts))
-                        f.write("\n")
-
-                f.write("\n")
-
-        return output_path
-
-
-__all__ = ["GeminiWriter"]