lattifai 1.0.4__py3-none-any.whl → 1.1.0__py3-none-any.whl

lattifai/cli/diarization.py

@@ -0,0 +1,108 @@
+"""Speaker diarization CLI entry point with nemo_run."""
+
+from pathlib import Path
+from typing import Optional
+
+import colorful
+import nemo_run as run
+from typing_extensions import Annotated
+
+from lattifai.client import LattifAI
+from lattifai.config import CaptionConfig, ClientConfig, DiarizationConfig, MediaConfig
+from lattifai.utils import safe_print
+
+__all__ = ["diarize"]
+
+
+@run.cli.entrypoint(name="run", namespace="diarization")
+def diarize(
+    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,
+    diarization: Annotated[Optional[DiarizationConfig], run.Config[DiarizationConfig]] = None,
+):
+    """Run speaker diarization on aligned captions and audio."""
+
+    media_config = media or MediaConfig()
+    caption_config = caption or CaptionConfig()
+    diarization_config = diarization or DiarizationConfig()
+
+    if input_media and media_config.input_path:
+        raise ValueError("Cannot specify both positional input_media and media.input_path.")
+    if input_media:
+        media_config.set_input_path(input_media)
+    if not media_config.input_path:
+        raise ValueError("Input media path must be provided via positional input_media or media.input_path.")
+
+    if input_caption and caption_config.input_path:
+        raise ValueError("Cannot specify both positional input_caption and caption.input_path.")
+    if input_caption:
+        caption_config.set_input_path(input_caption)
+    if not caption_config.input_path:
+        raise ValueError("Input caption path must be provided via positional input_caption or caption.input_path.")
+
+    if output_caption and caption_config.output_path:
+        raise ValueError("Cannot specify both positional output_caption and caption.output_path.")
+    if output_caption:
+        caption_config.set_output_path(output_caption)
+
+    diarization_config.enabled = True
+
+    client_instance = LattifAI(
+        client_config=client,
+        caption_config=caption_config,
+        diarization_config=diarization_config,
+    )
+
+    safe_print(colorful.cyan("🎧 Loading media for diarization..."))
+    media_audio = client_instance.audio_loader(
+        media_config.input_path,
+        channel_selector=media_config.channel_selector,
+        streaming_chunk_secs=media_config.streaming_chunk_secs,
+    )
+
+    safe_print(colorful.cyan("📖 Loading caption segments..."))
+    caption_obj = client_instance._read_caption(
+        caption_config.input_path,
+        input_caption_format=None if caption_config.input_format == "auto" else caption_config.input_format,
+        verbose=False,
+    )
+
+    if not caption_obj.alignments:
+        caption_obj.alignments = caption_obj.supervisions
+
+    if not caption_obj.alignments:
+        raise ValueError("Caption does not contain segments for diarization.")
+
+    if caption_config.output_path:
+        output_path = caption_config.output_path
+    else:
+        from datetime import datetime
+
+        input_caption_path = Path(caption_config.input_path)
+        timestamp = datetime.now().strftime("%Y%m%d_%H")
+        default_output = (
+            input_caption_path.parent / f"{input_caption_path.stem}.diarized.{timestamp}.{caption_config.output_format}"
+        )
+        caption_config.set_output_path(default_output)
+        output_path = caption_config.output_path
+
+    safe_print(colorful.cyan("🗣️ Performing speaker diarization..."))
+    diarized_caption = client_instance.speaker_diarization(
+        input_media=media_audio,
+        caption=caption_obj,
+        output_caption_path=output_path,
+    )
+
+    return diarized_caption
+
+
+def main():
+    run.cli.main(diarize)
+
+
+if __name__ == "__main__":
+    main()

lattifai/cli/server.py

@@ -4,6 +4,8 @@ import os
 import colorful
 import uvicorn
 
+from lattifai.utils import safe_print
+
 
 def main():
     """Launch the LattifAI Web Interface."""
@@ -29,7 +31,7 @@ def main():
 
     args = parser.parse_args()
 
-    print(colorful.bold_green("🚀 Launching LattifAI Backend Server..."))
+    safe_print(colorful.bold_green("🚀 Launching LattifAI Backend Server..."))
     print(colorful.cyan(f"Server running at http://localhost:{args.port}"))
     print(colorful.yellow(f"Host: {args.host}"))
     print(colorful.yellow(f"Auto-reload: {'disabled' if args.no_reload else 'enabled'}"))

lattifai/cli/transcribe.py

@@ -3,10 +3,8 @@
 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,
@@ -23,9 +21,8 @@ from lattifai.utils import _resolve_model_path
 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",
+    media: Annotated[Optional[MediaConfig], run.Config[MediaConfig]] = None,
+    client: Annotated[Optional[ClientConfig], run.Config[ClientConfig]] = None,
     transcription: Annotated[Optional[TranscriptionConfig], run.Config[TranscriptionConfig]] = None,
 ):
     """
@@ -39,11 +36,8 @@ def transcribe(
     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.
+        media: Media configuration for input/output handling.
+            Fields: input_path, output_dir, media_format, channel_selector, streaming_chunk_secs
         transcription: Transcription service configuration.
             Fields: model_name, device, language, gemini_api_key
 
@@ -67,6 +61,11 @@ def transcribe(
         lai transcribe run audio.wav output.srt \\
             transcription.language=zh
 
+        # With MediaConfig settings
+        lai transcribe run audio.wav output.srt \\
+            media.channel_selector=left \\
+            media.streaming_chunk_secs=30.0
+
         # Full configuration with keyword arguments
         lai transcribe run \\
             input=audio.wav \\
@@ -78,68 +77,86 @@ def transcribe(
     from pathlib import Path
 
     import colorful
+    from lattifai_core.client import SyncAPIClient
 
+    from lattifai.audio2 import AudioLoader
     from lattifai.transcription import create_transcriber
+    from lattifai.utils import safe_print
 
-    # Initialize transcription config with defaults
+    # Initialize configs with defaults
+    client_config = client or ClientConfig()
     transcription_config = transcription or TranscriptionConfig()
+    media_config = media or MediaConfig()
+
+    # Initialize client wrapper to properly set client_wrapper
+    client_wrapper = SyncAPIClient(config=client_config)
+    transcription_config.client_wrapper = client_wrapper
+
+    # Initialize client wrapper to properly set client_wrapper
+    client_wrapper = SyncAPIClient(config=client_config)
+    transcription_config.client_wrapper = client_wrapper
 
     # Validate input is required
-    if not input:
-        raise ValueError("Input is required. Provide input as positional argument (file path or URL).")
+    if not input and not media_config.input_path:
+        raise ValueError("Input is required. Provide input as positional argument or media.input_path.")
+
+    # Assign input to media_config if provided
+    if input:
+        media_config.set_input_path(input)
 
     # Detect if input is a URL
-    is_url = input.startswith(("http://", "https://"))
+    is_url = media_config.is_input_remote()
 
     # 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()
+        # For URLs, use output_dir from media_config or current directory
+        output_path = media_config.output_dir
     else:
         # For files, use input path directory
-        input_path = Path(str(input))
-        output_path = input_path.parent
+        output_path = Path(media_config.input_path).parent
 
     # Create transcriber
     if not transcription_config.lattice_model_path:
-        transcription_config.lattice_model_path = _resolve_model_path("Lattifai/Lattice-1")
+        transcription_config.lattice_model_path = _resolve_model_path(
+            "LattifAI/Lattice-1", getattr(transcription_config, "model_hub", "huggingface")
+        )
     transcriber = create_transcriber(transcription_config=transcription_config)
 
-    print(colorful.cyan(f"🎤 Starting transcription with {transcriber.name}..."))
-    print(colorful.cyan(f"    Input: {input}"))
+    safe_print(colorful.cyan(f"🎤 Starting transcription with {transcriber.name}..."))
+    safe_print(colorful.cyan(f"    Input: {media_config.input_path}"))
 
     # 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))
+        safe_print(colorful.cyan("    Transcribing from URL directly..."))
+        transcript = asyncio.run(transcriber.transcribe(media_config.input_path))
     else:
         if is_url:
             # Download media first, then transcribe
-            print(colorful.cyan("    Downloading media from URL..."))
+            safe_print(colorful.cyan("    Downloading media from URL..."))
             from lattifai.workflow.youtube import YouTubeDownloader
 
             downloader = YouTubeDownloader()
             input_path = asyncio.run(
                 downloader.download_media(
-                    url=input,
+                    url=media_config.input_path,
                     output_dir=str(output_path),
-                    media_format=media_format,
-                    force_overwrite=False,
+                    media_format=media_config.normalize_format(),
+                    force_overwrite=media_config.force_overwrite,
                 )
             )
-            print(colorful.cyan(f"    Media downloaded to: {input_path}"))
+            safe_print(colorful.cyan(f"    Media downloaded to: {input_path}"))
         else:
-            input_path = Path(str(input))
+            input_path = Path(media_config.input_path)
 
-        print(colorful.cyan("    Loading audio..."))
+        safe_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)
+        media_audio = audio_loader(
+            input_path,
+            channel_selector=media_config.channel_selector,
+            streaming_chunk_secs=media_config.streaming_chunk_secs,
+        )
         transcript = asyncio.run(transcriber.transcribe(media_audio))
 
     # Determine output caption path
@@ -153,14 +170,14 @@ def transcribe(
             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")
+            final_output = Path(media_config.input_path).with_suffix(".LattifAI.srt")
 
-    print(colorful.cyan(f"   Output: {final_output}"))
+    safe_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}"))
+    safe_print(colorful.green(f"🎉 Transcription completed: {final_output}"))
 
     return transcript
 

lattifai/cli/youtube.py

@@ -117,6 +117,7 @@ def youtube(
         force_overwrite=media_config.force_overwrite,
         split_sentence=caption_config.split_sentence,
         channel_selector=media_config.channel_selector,
+        streaming_chunk_secs=media_config.streaming_chunk_secs,
     )
 
 

lattifai/client.py

@@ -18,6 +18,7 @@ from lattifai.errors import (
     LatticeEncodingError,
 )
 from lattifai.mixin import LattifAIClientMixin
+from lattifai.utils import safe_print
 
 if TYPE_CHECKING:
     from lattifai.diarization import LattifAIDiarizer  # noqa: F401
@@ -91,6 +92,7 @@ class LattifAI(LattifAIClientMixin, SyncAPIClient):
         input_caption_format: Optional[InputCaptionFormat] = None,
         split_sentence: Optional[bool] = None,
         channel_selector: Optional[str | int] = "average",
+        streaming_chunk_secs: Optional[float] = None,
     ) -> Caption:
         try:
             # Step 1: Get caption
@@ -100,10 +102,17 @@ class LattifAI(LattifAIClientMixin, SyncAPIClient):
                 media_audio = self.audio_loader(
                     input_media,
                     channel_selector=channel_selector,
+                    streaming_chunk_secs=streaming_chunk_secs,
                 )
 
             if not input_caption:
-                caption = self._transcribe(media_audio, source_lang=self.caption_config.source_lang, is_async=False)
+                output_dir = None
+                if output_caption_path:
+                    output_dir = Path(str(output_caption_path)).parent
+                    output_dir.mkdir(parents=True, exist_ok=True)
+                caption = self._transcribe(
+                    media_audio, source_lang=self.caption_config.source_lang, is_async=False, output_dir=output_dir
+                )
             else:
                 caption = self._read_caption(input_caption, input_caption_format)
 
@@ -113,7 +122,7 @@ class LattifAI(LattifAIClientMixin, SyncAPIClient):
             alignment_strategy = self.aligner.config.strategy
 
             if alignment_strategy != "entire" or caption.transcription:
-                print(colorful.cyan(f"🔄 Using segmented alignment strategy: {alignment_strategy}"))
+                safe_print(colorful.cyan(f"🔄 Using segmented alignment strategy: {alignment_strategy}"))
 
                 if caption.supervisions and alignment_strategy == "transcription":
                     # raise NotImplementedError("Transcription-based alignment is not yet implemented.")
@@ -126,7 +135,7 @@ class LattifAI(LattifAIClientMixin, SyncAPIClient):
                     if not caption.transcription:
                         import asyncio
 
-                        print(colorful.cyan("📝 Transcribing media for alignment..."))
+                        safe_print(colorful.cyan("📝 Transcribing media for alignment..."))
                         if output_caption_path:
                             transcript_file = (
                                 Path(str(output_caption_path)).parent
@@ -223,11 +232,11 @@ class LattifAI(LattifAIClientMixin, SyncAPIClient):
                         continue
 
                     offset = round(start, 4)
-                    emission = self.aligner.emission(
-                        media_audio.tensor[
-                            :, int(start * media_audio.sampling_rate) : int(end * media_audio.sampling_rate)
-                        ]
-                    )
+                    # Extract audio slice
+                    audio_slice_ndarray = media_audio.ndarray[
+                        :, int(start * media_audio.sampling_rate) : int(end * media_audio.sampling_rate)
+                    ]
+                    emission = self.aligner.emission(audio_slice_ndarray)
 
                     # Align segment
                     _supervisions, _alignments = self.aligner.alignment(
@@ -257,18 +266,9 @@ class LattifAI(LattifAIClientMixin, SyncAPIClient):
             caption.supervisions = supervisions
             caption.alignments = alignments
 
-            # Step 5: Speaker diarization
-            if self.diarization_config.enabled and self.diarizer:
-                print(colorful.cyan("🗣️  Performing speaker diarization..."))
-                caption = self.speaker_diarization(
-                    input_media=media_audio,
-                    caption=caption,
-                    output_caption_path=output_caption_path,
-                )
-            elif output_caption_path:
+            if output_caption_path:
                 self._write_caption(caption, output_caption_path)
 
-            return caption
         except (CaptionProcessingError, LatticeEncodingError, AlignmentError, LatticeDecodingError):
             # Re-raise our specific errors as-is
             raise
@@ -281,6 +281,17 @@ class LattifAI(LattifAIClientMixin, SyncAPIClient):
                 context={"original_error": str(e), "error_type": e.__class__.__name__},
             )
 
+        # Step 5: Speaker diarization
+        if self.diarization_config.enabled and self.diarizer:
+            safe_print(colorful.cyan("🗣️  Performing speaker diarization..."))
+            caption = self.speaker_diarization(
+                input_media=media_audio,
+                caption=caption,
+                output_caption_path=output_caption_path,
+            )
+
+        return caption
+
     def speaker_diarization(
         self,
         input_media: AudioData,
@@ -308,11 +319,18 @@ class LattifAI(LattifAIClientMixin, SyncAPIClient):
         if output_caption_path:
             diarization_file = Path(str(output_caption_path)).with_suffix(".SpkDiar")
             if diarization_file.exists():
-                print(colorful.cyan(f"Reading existing speaker diarization from {diarization_file}"))
+                safe_print(colorful.cyan(f"Reading existing speaker diarization from {diarization_file}"))
                 caption.read_speaker_diarization(diarization_file)
 
         diarization, alignments = self.diarizer.diarize_with_alignments(
-            input_media, caption.alignments, diarization=caption.speaker_diarization
+            input_media,
+            caption.alignments,
+            diarization=caption.speaker_diarization,
+            alignment_fn=self.aligner.alignment,
+            transcribe_fn=self.transcriber.transcribe_numpy if self.transcriber else None,
+            separate_fn=self.aligner.separate if self.aligner.worker.separator_ort else None,
+            debug=self.diarizer.config.debug,
+            output_path=output_caption_path,
         )
         caption.alignments = alignments
         caption.speaker_diarization = diarization
@@ -321,105 +339,6 @@ class LattifAI(LattifAIClientMixin, SyncAPIClient):
         if output_caption_path:
             self._write_caption(caption, output_caption_path)
 
-            if self.diarizer.config.debug:
-                # debug
-                from tgt import Interval, IntervalTier, TextGrid, write_to_file
-
-                debug_tg = TextGrid()
-                transcript_tier = IntervalTier(
-                    start_time=0,
-                    end_time=input_media.duration,
-                    name="transcript",
-                    objects=[Interval(sup.start, sup.end, sup.text) for sup in caption.alignments],
-                )
-                debug_tg.add_tier(transcript_tier)
-
-                speaker_tier = IntervalTier(
-                    start_time=0,
-                    end_time=input_media.duration,
-                    name="speaker",
-                    objects=[Interval(sup.start, sup.end, sup.speaker) for sup in caption.alignments],
-                )
-                debug_tg.add_tier(speaker_tier)
-
-                from collections import defaultdict
-
-                spk2intervals = defaultdict(lambda: [])
-                num_multispk = 0
-
-                segments, skipks = [], []
-                for k, supervision in enumerate(caption.alignments):  # TODO: alignments 本身存在 overlap, eg: [event]
-                    # supervision = caption.alignments[k]
-                    if supervision.custom.get("speaker", []):
-                        num_multispk += 1
-                    else:
-                        continue
-
-                    if k in skipks:
-                        continue
-
-                    for speaker in supervision.custom.get("speaker", []):
-                        for name, start_time, end_time in speaker:
-                            spk2intervals[name].append(Interval(start_time, end_time, name))
-
-                    _segments = []
-                    if k > 0:
-                        _segments.append(caption.alignments[k - 1])
-                    _segments.append(supervision)
-                    while k + 1 < len(caption.alignments):
-                        skipks.append(k + 1)
-                        next_sup = caption.alignments[k + 1]
-                        if not next_sup.custom.get("speaker", []):
-                            k += 1
-                            break
-                        _segments.append(next_sup)
-                        k += 1
-
-                    if segments:
-                        if _segments[0].start >= segments[-1][-1].end:
-                            segments.append(_segments)
-                        else:
-                            if _segments[1:]:
-                                segments.append(_segments[1:])
-                            else:
-                                pass
-                    else:
-                        segments.append(_segments)
-
-                print(
-                    f"Number of multi-speaker segments: {num_multispk}/{len(caption.alignments)} segments: {len(segments)}"
-                )
-
-                for speaker, intervals in sorted(spk2intervals.items(), key=lambda x: x[0]):
-                    speaker_tier = IntervalTier(
-                        start_time=0, end_time=input_media.duration, name=speaker, objects=intervals
-                    )
-                    debug_tg.add_tier(speaker_tier)
-
-                for tier in caption.speaker_diarization.tiers:
-                    tier.name = f"Diarization-{tier.name}"
-                    debug_tg.add_tier(tier)
-
-                tier = IntervalTier(
-                    start_time=0,
-                    end_time=input_media.duration,
-                    name="resegment",
-                    objects=[
-                        Interval(round(sup.start, 2), round(sup.end, 2), sup.text)
-                        for _segments in segments
-                        for sup in _segments
-                    ],
-                )
-                debug_tg.add_tier(tier)
-
-                # if caption.audio_events:
-                #     for tier in caption.audio_events.tiers:
-                #         # tier.name = f"{tier.name}"
-                #         debug_tg.add_tier(tier)
-
-                debug_tgt_file = Path(str(output_caption_path)).with_suffix(".DiarizationDebug.TextGrid")
-                write_to_file(debug_tg, debug_tgt_file, format="long")
-
         return caption
 
     def youtube(
@@ -433,12 +352,13 @@ class LattifAI(LattifAIClientMixin, SyncAPIClient):
         split_sentence: Optional[bool] = None,
         use_transcription: bool = False,
         channel_selector: Optional[str | int] = "average",
+        streaming_chunk_secs: Optional[float] = None,
     ) -> Caption:
         # Prepare output directory and media format
         output_dir = self._prepare_youtube_output_dir(output_dir)
         media_format = self._determine_media_format(media_format)
 
-        print(colorful.cyan(f"🎬 Starting YouTube workflow for: {url}"))
+        safe_print(colorful.cyan(f"🎬 Starting YouTube workflow for: {url}"))
 
         # Step 1: Download media
         media_file = self._download_media_sync(url, output_dir, media_format, force_overwrite)
@@ -460,7 +380,7 @@ class LattifAI(LattifAIClientMixin, SyncAPIClient):
         output_caption_path = self._generate_output_caption_path(output_caption_path, media_file, output_dir)
 
         # Step 4: Perform alignment
-        print(colorful.cyan("🔗 Performing forced alignment..."))
+        safe_print(colorful.cyan("🔗 Performing forced alignment..."))
 
         caption: Caption = self.alignment(
             input_media=media_audio,
@@ -468,6 +388,7 @@ class LattifAI(LattifAIClientMixin, SyncAPIClient):
             output_caption_path=output_caption_path,
             split_sentence=split_sentence,
             channel_selector=channel_selector,
+            streaming_chunk_secs=streaming_chunk_secs,
         )
 
         return caption

lattifai/config/alignment.py

@@ -18,8 +18,11 @@ class AlignmentConfig:
     """
 
     # Alignment configuration
-    model_name: str = "Lattifai/Lattice-1"
-    """Model identifier or path to local model directory (e.g., 'Lattifai/Lattice-1')."""
+    model_name: str = "LattifAI/Lattice-1"
+    """Model identifier or path to local model directory (e.g., 'LattifAI/Lattice-1')."""
+
+    model_hub: Literal["huggingface", "modelscope"] = "huggingface"
+    """Which model hub to use when resolving remote model names: 'huggingface' or 'modelscope'."""
 
     device: Literal["cpu", "cuda", "mps", "auto"] = "auto"
     """Computation device: 'cpu' for CPU, 'cuda' for NVIDIA GPU, 'mps' for Apple Silicon."""
@@ -58,6 +61,38 @@ class AlignmentConfig:
     Default: 4.0 seconds. Useful for detecting scene changes or natural breaks in content.
     """
 
+    # Beam search parameters for forced alignment
+    search_beam: int = 200
+    """Search beam size for beam search decoding. Larger values explore more hypotheses but are slower.
+    Default: 200. Typical range: 20-500.
+    """
+
+    output_beam: int = 80
+    """Output beam size for keeping top hypotheses. Should be smaller than search_beam.
+    Default: 80. Typical range: 10-200.
+    """
+
+    min_active_states: int = 400
+    """Minimum number of active states during decoding. Controls memory and search space.
+    Default: 400. Typical range: 30-1000.
+    """
+
+    max_active_states: int = 10000
+    """Maximum number of active states during decoding. Prevents excessive memory usage.
+    Default: 10000. Typical range: 1000-20000.
+    """
+
+    # Alignment timing configuration
+    start_margin: float = 0.08
+    """Maximum start time margin (in seconds) to extend segment boundaries at the beginning.
+    Default: 0.08. Typical range: 0.0-0.5.
+    """
+
+    end_margin: float = 0.20
+    """Maximum end time margin (in seconds) to extend segment boundaries at the end.
+    Default: 0.20. Typical range: 0.0-0.5.
+    """
+
     client_wrapper: Optional["SyncAPIClient"] = field(default=None, repr=False)
     """Reference to the SyncAPIClient instance. Auto-set during client initialization."""
 

lattifai/config/caption.py

@@ -48,7 +48,7 @@ class CaptionConfig:
     include_speaker_in_text: bool = True
     """Preserve speaker labels in caption text content."""
 
-    normalize_text: bool = False
+    normalize_text: bool = True
     """Clean HTML entities and normalize whitespace in caption text."""
 
     split_sentence: bool = False