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

lattifai/caption/caption.py

@@ -4,17 +4,19 @@ import json
 import re
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, TypeVar
 
 from lhotse.supervision import AlignmentItem
 from lhotse.utils import Pathlike
 from tgt import TextGrid
 
-from ..config.caption import InputCaptionFormat, OutputCaptionFormat
+from ..config.caption import InputCaptionFormat, OutputCaptionFormat  # noqa: F401
 from .supervision import Supervision
 from .text_parser import normalize_text as normalize_text_fn
 from .text_parser import parse_speaker_text, parse_timestamp_text
 
+DiarizationOutput = TypeVar("DiarizationOutput")
+
 
 @dataclass
 class Caption:
@@ -40,7 +42,7 @@ class Caption:
     # Audio Event Detection results
     audio_events: Optional[TextGrid] = None
     # Speaker Diarization results
-    speaker_diarization: Optional[TextGrid] = None
+    speaker_diarization: Optional[DiarizationOutput] = None
     # Alignment results
     alignments: List[Supervision] = field(default_factory=list)
 
@@ -272,7 +274,7 @@ class Caption:
         cls,
         transcription: List[Supervision],
         audio_events: Optional[TextGrid] = None,
-        speaker_diarization: Optional[TextGrid] = None,
+        speaker_diarization: Optional[DiarizationOutput] = None,
         language: Optional[str] = None,
         source_path: Optional[Pathlike] = None,
         metadata: Optional[Dict[str, str]] = None,
@@ -283,7 +285,7 @@ class Caption:
         Args:
             transcription: List of transcription supervision segments
             audio_events: Optional TextGrid with audio event detection results
-            speaker_diarization: Optional TextGrid with speaker diarization results
+            speaker_diarization: Optional DiarizationOutput with speaker diarization results
             language: Language code
             source_path: Source file path
             metadata: Additional metadata
@@ -307,7 +309,7 @@ class Caption:
         cls,
         path: Pathlike,
         format: Optional[str] = None,
-        normalize_text: bool = False,
+        normalize_text: bool = True,
     ) -> "Caption":
         """
         Read caption file and return Caption object.
@@ -384,9 +386,9 @@ class Caption:
         """
         Read speaker diarization TextGrid from file.
         """
-        from tgt import read_textgrid
+        from lattifai_core.diarization import DiarizationOutput
 
-        self.speaker_diarization = read_textgrid(path)
+        self.speaker_diarization = DiarizationOutput.read(path)
         return self.speaker_diarization
 
     def write_speaker_diarization(
@@ -399,9 +401,7 @@ class Caption:
         if not self.speaker_diarization:
             raise ValueError("No speaker diarization data to write.")
 
-        from tgt import write_to_file
-
-        write_to_file(self.speaker_diarization, path, format="long")
+        self.speaker_diarization.write(path)
         return path
 
     @staticmethod
@@ -451,7 +451,10 @@ class Caption:
                     else:
                         if include_speaker_in_text and sup.speaker is not None:
                             # Use [SPEAKER]: format for consistency with parsing
-                            text = f"[{sup.speaker}]: {sup.text}"
+                            if not sup.has_custom("original_speaker") or sup.custom["original_speaker"]:
+                                text = f"[{sup.speaker}]: {sup.text}"
+                            else:
+                                text = f"{sup.text}"
                         else:
                             text = sup.text
                         f.write(f"[{sup.start:.2f}-{sup.end:.2f}] {text}\n")
@@ -471,7 +474,12 @@ class Caption:
             tg = TextGrid()
             supervisions, words, scores = [], [], {"utterances": [], "words": []}
             for supervision in sorted(alignments, key=lambda x: x.start):
-                if include_speaker_in_text and supervision.speaker is not None:
+                # Respect `original_speaker` custom flag: default to include speaker when missing
+                if (
+                    include_speaker_in_text
+                    and supervision.speaker is not None
+                    and (not supervision.has_custom("original_speaker") or supervision.custom["original_speaker"])
+                ):
                     text = f"{supervision.speaker} {supervision.text}"
                 else:
                     text = supervision.text
@@ -505,6 +513,8 @@ class Caption:
             cls._write_csv(alignments, output_path, include_speaker_in_text)
         elif str(output_path)[-4:].lower() == ".aud":
             cls._write_aud(alignments, output_path, include_speaker_in_text)
+        elif str(output_path)[-4:].lower() == ".sbv":
+            cls._write_sbv(alignments, output_path, include_speaker_in_text)
         else:
             import pysubs2
 
@@ -524,7 +534,10 @@ class Caption:
                         )
                 else:
                     if include_speaker_in_text and sup.speaker is not None:
-                        text = f"{sup.speaker} {sup.text}"
+                        if not sup.has_custom("original_speaker") or sup.custom["original_speaker"]:
+                            text = f"{sup.speaker} {sup.text}"
+                        else:
+                            text = f"{sup.text}"
                     else:
                         text = sup.text
                     subs.append(
@@ -535,7 +548,14 @@ class Caption:
                             name=sup.speaker or "",
                         )
                     )
-            subs.save(output_path)
+
+            # MicroDVD format requires framerate to be specified
+            output_ext = str(output_path).lower().split(".")[-1]
+            if output_ext == "sub":
+                # Default to 25 fps for MicroDVD format if not specified
+                subs.save(output_path, fps=25.0)
+            else:
+                subs.save(output_path)
 
         return output_path
 
@@ -821,7 +841,16 @@ class Caption:
             if cls._is_youtube_vtt_with_word_timestamps(content):
                 return cls._parse_youtube_vtt_with_word_timestamps(content, normalize_text)
 
-        if format == "gemini" or str(caption).endswith("Gemini.md"):
+        # Match Gemini format: explicit format, or files ending with Gemini.md/Gemini3.md,
+        # or files containing "gemini" in the name with .md extension
+        caption_str = str(caption).lower()
+        is_gemini_format = (
+            format == "gemini"
+            or str(caption).endswith("Gemini.md")
+            or str(caption).endswith("Gemini3.md")
+            or ("gemini" in caption_str and caption_str.endswith(".md"))
+        )
+        if is_gemini_format:
             from .gemini_reader import GeminiReader
 
             supervisions = GeminiReader.extract_for_alignment(caption)
@@ -850,6 +879,8 @@ class Caption:
             supervisions = cls._parse_csv(caption, normalize_text)
         elif format == "aud" or str(caption)[-4:].lower() == ".aud":
             supervisions = cls._parse_aud(caption, normalize_text)
+        elif format == "sbv" or str(caption)[-4:].lower() == ".sbv":
+            supervisions = cls._parse_sbv(caption, normalize_text)
         elif format == "txt" or (format == "auto" and str(caption)[-4:].lower() == ".txt"):
             if not Path(str(caption)).exists():  # str
                 lines = [line.strip() for line in str(caption).split("\n")]
@@ -1113,6 +1144,101 @@ class Caption:
 
         return supervisions
 
+    @classmethod
+    def _parse_sbv(cls, caption: Pathlike, normalize_text: Optional[bool] = False) -> List[Supervision]:
+        """
+        Parse SubViewer (SBV) format caption file.
+
+        Format:
+        0:00:00.000,0:00:02.000
+        Text line 1
+
+        0:00:02.000,0:00:04.000
+        Text line 2
+
+        Args:
+            caption: Caption file path
+            normalize_text: Whether to normalize text
+
+        Returns:
+            List of Supervision objects
+        """
+        caption_path = Path(str(caption))
+        if not caption_path.exists():
+            raise FileNotFoundError(f"Caption file not found: {caption}")
+
+        supervisions = []
+
+        with open(caption_path, "r", encoding="utf-8") as f:
+            content = f.read()
+
+        # Split by double newlines to separate entries
+        entries = content.strip().split("\n\n")
+
+        for entry in entries:
+            lines = entry.strip().split("\n")
+            if len(lines) < 2:
+                continue
+
+            # First line: timestamp (H:MM:SS.mmm,H:MM:SS.mmm)
+            timestamp_line = lines[0].strip()
+            # Remaining lines: text
+            text_lines = lines[1:]
+
+            try:
+                # Parse timestamp: 0:00:00.000,0:00:02.000
+                if "," not in timestamp_line:
+                    continue
+
+                start_str, end_str = timestamp_line.split(",", 1)
+
+                # Parse start time
+                start_parts = start_str.strip().split(":")
+                if len(start_parts) == 3:
+                    h, m, s = start_parts
+                    s_parts = s.split(".")
+                    start = int(h) * 3600 + int(m) * 60 + int(s_parts[0])
+                    if len(s_parts) > 1:
+                        start += int(s_parts[1]) / 1000.0
+                else:
+                    continue
+
+                # Parse end time
+                end_parts = end_str.strip().split(":")
+                if len(end_parts) == 3:
+                    h, m, s = end_parts
+                    s_parts = s.split(".")
+                    end = int(h) * 3600 + int(m) * 60 + int(s_parts[0])
+                    if len(s_parts) > 1:
+                        end += int(s_parts[1]) / 1000.0
+                else:
+                    continue
+
+                # Parse text and speaker
+                text = " ".join(text_lines).strip()
+                speaker, text = parse_speaker_text(text)
+
+                if normalize_text:
+                    text = normalize_text_fn(text)
+
+                duration = end - start
+                if duration < 0:
+                    continue
+
+                supervisions.append(
+                    Supervision(
+                        text=text,
+                        start=start,
+                        duration=duration,
+                        speaker=speaker,
+                    )
+                )
+            except (ValueError, IndexError):
+                # Skip malformed entries
+                continue
+
+        return supervisions
+
     @classmethod
     def _write_tsv(
         cls,
@@ -1136,7 +1262,11 @@ class Caption:
             if include_speaker_in_text:
                 file.write("speaker\tstart\tend\ttext\n")
                 for supervision in alignments:
-                    speaker = supervision.speaker or ""
+                    # Respect `original_speaker` custom flag: default to True when missing
+                    include_speaker = supervision.speaker and (
+                        not supervision.has_custom("original_speaker") or supervision.custom["original_speaker"]
+                    )
+                    speaker = supervision.speaker if include_speaker else ""
                     start_ms = round(1000 * supervision.start)
                     end_ms = round(1000 * supervision.end)
                     text = supervision.text.strip().replace("\t", " ")
@@ -1174,7 +1304,10 @@ class Caption:
                 writer = csv.writer(file)
                 writer.writerow(["speaker", "start", "end", "text"])
                 for supervision in alignments:
-                    speaker = supervision.speaker or ""
+                    include_speaker = supervision.speaker and (
+                        not supervision.has_custom("original_speaker") or supervision.custom["original_speaker"]
+                    )
+                    speaker = supervision.speaker if include_speaker else ""
                     start_ms = round(1000 * supervision.start)
                     end_ms = round(1000 * supervision.end)
                     text = supervision.text.strip()
@@ -1212,11 +1345,72 @@ class Caption:
                 end = supervision.end
                 text = supervision.text.strip().replace("\t", " ")
 
-                if include_speaker_in_text and supervision.speaker:
+                # Respect `original_speaker` custom flag when adding speaker prefix
+                if (
+                    include_speaker_in_text
+                    and supervision.speaker
+                    and (not supervision.has_custom("original_speaker") or supervision.custom["original_speaker"])
+                ):
                     text = f"[[{supervision.speaker}]]{text}"
 
                 file.write(f"{start}\t{end}\t{text}\n")
 
+    @classmethod
+    def _write_sbv(
+        cls,
+        alignments: List[Supervision],
+        output_path: Pathlike,
+        include_speaker_in_text: bool = True,
+    ) -> None:
+        """
+        Write caption to SubViewer (SBV) format.
+
+        Format:
+        0:00:00.000,0:00:02.000
+        Text line 1
+
+        0:00:02.000,0:00:04.000
+        Text line 2
+
+        Args:
+            alignments: List of supervision segments to write
+            output_path: Path to output SBV file
+            include_speaker_in_text: Whether to include speaker in text
+        """
+        with open(output_path, "w", encoding="utf-8") as file:
+            for i, supervision in enumerate(alignments):
+                # Format timestamps as H:MM:SS.mmm
+                start_h = int(supervision.start // 3600)
+                start_m = int((supervision.start % 3600) // 60)
+                start_s = int(supervision.start % 60)
+                start_ms = int((supervision.start % 1) * 1000)
+
+                end_h = int(supervision.end // 3600)
+                end_m = int((supervision.end % 3600) // 60)
+                end_s = int(supervision.end % 60)
+                end_ms = int((supervision.end % 1) * 1000)
+
+                start_time = f"{start_h}:{start_m:02d}:{start_s:02d}.{start_ms:03d}"
+                end_time = f"{end_h}:{end_m:02d}:{end_s:02d}.{end_ms:03d}"
+
+                # Write timestamp line
+                file.write(f"{start_time},{end_time}\n")
+
+                # Write text (with optional speaker). Respect `original_speaker` custom flag.
+                text = supervision.text.strip()
+                if (
+                    include_speaker_in_text
+                    and supervision.speaker
+                    and (not supervision.has_custom("original_speaker") or supervision.custom["original_speaker"])
+                ):
+                    text = f"{supervision.speaker}: {text}"
+
+                file.write(f"{text}\n")
+
+                # Add blank line between entries (except after last one)
+                if i < len(alignments) - 1:
+                    file.write("\n")
+
     @classmethod
     def _parse_caption(
         cls, caption: Pathlike, format: Optional[OutputCaptionFormat], normalize_text: Optional[bool] = False

lattifai/cli/__init__.py

@@ -5,12 +5,14 @@ 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.diarization import diarize
 from lattifai.cli.transcribe import transcribe, transcribe_align
 from lattifai.cli.youtube import youtube
 
 __all__ = [
     "align",
     "convert",
+    "diarize",
     "transcribe",
     "transcribe_align",
     "youtube",

lattifai/cli/alignment.py

@@ -81,7 +81,7 @@ def align(
             caption.word_level=true \\
             caption.normalize_text=true \\
             alignment.device=mps \\
-            alignment.model_name=Lattifai/Lattice-1-Alpha
+            alignment.model_name=LattifAI/Lattice-1-Alpha
     """
     media_config = media or MediaConfig()
 
@@ -142,6 +142,7 @@ def align(
         output_caption_path=caption_config.output_path,
         split_sentence=caption_config.split_sentence,
         channel_selector=media_config.channel_selector,
+        streaming_chunk_secs=media_config.streaming_chunk_secs,
     )
 
 

lattifai/cli/app_installer.py

@@ -5,6 +5,8 @@ import subprocess
 import sys
 from pathlib import Path
 
+from lattifai.utils import safe_print
+
 
 def check_command_exists(cmd: str) -> bool:
     """Check if a command exists in PATH."""
@@ -19,17 +21,17 @@ def install_nodejs():
     """Install Node.js based on the operating system."""
     system = platform.system().lower()
 
-    print("📦 Node.js not found. Installing Node.js...\n")
+    safe_print("📦 Node.js not found. Installing Node.js...\n")
 
     try:
         if system == "darwin":  # macOS
             # Check if Homebrew is installed
             if check_command_exists("brew"):
-                print("🍺 Using Homebrew to install Node.js...")
+                safe_print("🍺 Using Homebrew to install Node.js...")
                 subprocess.run(["brew", "install", "node"], check=True)
-                print("✓ Node.js installed via Homebrew\n")
+                safe_print("✓ Node.js installed via Homebrew\n")
             else:
-                print("❌ Homebrew not found.")
+                safe_print("❌ Homebrew not found.")
                 print("   Please install Homebrew first:")
                 print(
                     '   /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"'
@@ -40,46 +42,46 @@ def install_nodejs():
         elif system == "linux":
             # Try common package managers
             if check_command_exists("apt"):
-                print("🐧 Using apt to install Node.js...")
+                safe_print("🐧 Using apt to install Node.js...")
                 subprocess.run(["sudo", "apt", "update"], check=True)
                 subprocess.run(["sudo", "apt", "install", "-y", "nodejs", "npm"], check=True)
-                print("✓ Node.js installed via apt\n")
+                safe_print("✓ Node.js installed via apt\n")
             elif check_command_exists("yum"):
-                print("🐧 Using yum to install Node.js...")
+                safe_print("🐧 Using yum to install Node.js...")
                 subprocess.run(["sudo", "yum", "install", "-y", "nodejs", "npm"], check=True)
-                print("✓ Node.js installed via yum\n")
+                safe_print("✓ Node.js installed via yum\n")
             elif check_command_exists("dnf"):
-                print("🐧 Using dnf to install Node.js...")
+                safe_print("🐧 Using dnf to install Node.js...")
                 subprocess.run(["sudo", "dnf", "install", "-y", "nodejs", "npm"], check=True)
-                print("✓ Node.js installed via dnf\n")
+                safe_print("✓ Node.js installed via dnf\n")
             elif check_command_exists("pacman"):
-                print("🐧 Using pacman to install Node.js...")
+                safe_print("🐧 Using pacman to install Node.js...")
                 subprocess.run(["sudo", "pacman", "-S", "--noconfirm", "nodejs", "npm"], check=True)
-                print("✓ Node.js installed via pacman\n")
+                safe_print("✓ Node.js installed via pacman\n")
             else:
-                print("❌ No supported package manager found (apt/yum/dnf/pacman).")
+                safe_print("❌ No supported package manager found (apt/yum/dnf/pacman).")
                 print("   Please install Node.js manually from: https://nodejs.org/")
                 sys.exit(1)
 
         elif system == "windows":
-            print("❌ Automatic installation on Windows is not supported.")
+            safe_print("❌ Automatic installation on Windows is not supported.")
             print("   Please download and install Node.js from: https://nodejs.org/")
             print("   Then run this command again.")
             sys.exit(1)
 
         else:
-            print(f"❌ Unsupported operating system: {system}")
+            safe_print(f"❌ Unsupported operating system: {system}")
             print("   Please install Node.js manually from: https://nodejs.org/")
             sys.exit(1)
 
         # Verify installation
         if not check_command_exists("npm"):
-            print("❌ Node.js installation verification failed.")
+            safe_print("❌ Node.js installation verification failed.")
             print("   Please restart your terminal and try again.")
             sys.exit(1)
 
     except subprocess.CalledProcessError as e:
-        print(f"\n❌ Error during Node.js installation: {e}")
+        safe_print(f"\n❌ Error during Node.js installation: {e}")
         print("   Please install Node.js manually from: https://nodejs.org/")
         sys.exit(1)
 
@@ -90,49 +92,49 @@ def main():
     app_dir = Path(__file__).parent.parent.parent.parent / "app"
 
     if not app_dir.exists():
-        print(f"❌ Error: app directory not found at {app_dir}")
+        safe_print(f"❌ Error: app directory not found at {app_dir}")
         print("   Make sure you're in the lattifai-python repository.")
         sys.exit(1)
 
-    print("🚀 Installing lai-app (LattifAI Web Application)...\n")
+    safe_print("🚀 Installing lai-app (LattifAI Web Application)...\n")
 
     # Check if npm is installed, if not, install Node.js
     if not check_command_exists("npm"):
         install_nodejs()
     else:
         npm_version = subprocess.run(["npm", "--version"], capture_output=True, text=True, check=True).stdout.strip()
-        print(f"✓ npm is already installed (v{npm_version})\n")
+        safe_print(f"✓ npm is already installed (v{npm_version})\n")
 
     # Change to app directory and run installation
     try:
-        print(f"📁 Working directory: {app_dir}\n")
+        safe_print(f"📁 Working directory: {app_dir}\n")
 
         # Install dependencies
-        print("📦 Installing dependencies...")
+        safe_print("📦 Installing dependencies...")
         subprocess.run(["npm", "install"], cwd=app_dir, check=True)
-        print("✓ Dependencies installed\n")
+        safe_print("✓ Dependencies installed\n")
 
         # Build the application
-        print("🔨 Building application...")
+        safe_print("🔨 Building application...")
         subprocess.run(["npm", "run", "build"], cwd=app_dir, check=True)
-        print("✓ Application built\n")
+        safe_print("✓ Application built\n")
 
         # Link globally
-        print("🔗 Linking lai-app command globally...")
+        safe_print("🔗 Linking lai-app command globally...")
         subprocess.run(["npm", "link"], cwd=app_dir, check=True)
-        print("✓ lai-app command linked globally\n")
+        safe_print("✓ lai-app command linked globally\n")
 
-        print("=" * 60)
-        print("✅ lai-app installed successfully!")
-        print("=" * 60)
-        print("\n🎉 You can now run:")
+        safe_print("=" * 60)
+        safe_print("✅ lai-app installed successfully!")
+        safe_print("=" * 60)
+        safe_print("\n🎉 You can now run:")
         print("   lai-app              # Start the web application")
         print("   lai-app --help       # Show help")
         print("   lai-app --port 8080  # Use custom port")
-        print("\n📖 For more information, see app/CLI_USAGE.md\n")
+        safe_print("\n📖 For more information, see app/CLI_USAGE.md\n")
 
     except subprocess.CalledProcessError as e:
-        print(f"\n❌ Error during installation: {e}")
+        safe_print(f"\n❌ Error during installation: {e}")
         sys.exit(1)
 
 

lattifai/cli/caption.py

@@ -7,13 +7,14 @@ from lhotse.utils import Pathlike
 from typing_extensions import Annotated
 
 from lattifai.config import CaptionConfig
+from lattifai.utils import safe_print
 
 
 @run.cli.entrypoint(name="convert", namespace="caption")
 def convert(
     input_path: Pathlike,
     output_path: Pathlike,
-    include_speaker_in_text: bool = True,
+    include_speaker_in_text: bool = False,
     normalize_text: bool = False,
 ):
     """
@@ -55,7 +56,7 @@ def convert(
     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}")
+    safe_print(f"✅ Converted {input_path} -> {output_path}")
     return output_path
 
 
@@ -63,7 +64,6 @@ def convert(
 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.
@@ -81,9 +81,6 @@ def 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)
@@ -92,13 +89,9 @@ def normalize(
         # 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 \\
+        lai caption normalize \
+            input_path=input.srt \
             output_path=output.srt
     """
     from pathlib import Path
@@ -112,9 +105,9 @@ def normalize(
     caption_obj.write(output_path, include_speaker_in_text=True)
 
     if output_path == input_path:
-        print(f"✅ Normalized {input_path} (in-place)")
+        safe_print(f"✅ Normalized {input_path} (in-place)")
     else:
-        print(f"✅ Normalized {input_path} -> {output_path}")
+        safe_print(f"✅ Normalized {input_path} -> {output_path}")
 
     return output_path
 
@@ -124,7 +117,6 @@ 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.
@@ -140,8 +132,6 @@ def shift(
         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)
@@ -181,9 +171,9 @@ def shift(
         direction = f"advanced by {abs(seconds)}s"
 
     if output_path == input_path:
-        print(f"✅ Shifted timestamps {direction} in {input_path} (in-place)")
+        safe_print(f"✅ Shifted timestamps {direction} in {input_path} (in-place)")
     else:
-        print(f"✅ Shifted timestamps {direction}: {input_path} -> {output_path}")
+        safe_print(f"✅ Shifted timestamps {direction}: {input_path} -> {output_path}")
 
     return output_path