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

lattifai/{workflows → workflow}/file_manager.py

@@ -17,6 +17,9 @@ except ImportError:  # pragma: no cover - optional dependency
     questionary = None
 
 
+TRANSCRIBE_CHOICE = "transcribe"
+
+
 class FileExistenceManager:
     """Utility class for handling file existence checks and user confirmations"""
 
@@ -24,37 +27,37 @@ class FileExistenceManager:
         "media": ("🎬", "Media"),
         # 'audio': ('📱', 'Audio'),
         # 'video': ('🎬', 'Video'),
-        "subtitle": ("📝", "Subtitle"),
+        "caption": ("📝", "Caption"),
     }
 
     @staticmethod
     def check_existing_files(
         video_id: str,
-        output_dir: str,
+        output_path: str,
         media_formats: List[str] = None,
-        subtitle_formats: List[str] = None,
+        caption_formats: List[str] = None,
     ) -> Dict[str, List[str]]:
         """
         Enhanced version to check for existing media files with customizable formats
 
         Args:
             video_id: Video ID from any platform
-            output_dir: Output directory to check
+            output_path: Output directory to check
             media_formats: List of media formats to check (audio and video combined)
-            subtitle_formats: List of subtitle formats to check
+            caption_formats: List of caption formats to check
 
         Returns:
-            Dictionary with 'media', 'subtitle' keys containing lists of existing files
+            Dictionary with 'media', 'caption' keys containing lists of existing files
         """
-        output_path = Path(output_dir).expanduser()
-        existing_files = {"media": [], "subtitle": []}
+        output_path = Path(output_path).expanduser()
+        existing_files = {"media": [], "caption": []}
 
         if not output_path.exists():
             return existing_files
 
         # Default formats - combine audio and video formats
         media_formats = media_formats or ["mp3", "wav", "m4a", "aac", "opus", "mp4", "webm", "mkv", "avi"]
-        subtitle_formats = subtitle_formats or ["md", "srt", "vtt", "ass", "ssa", "sub", "sbv", "txt"]
+        caption_formats = caption_formats or ["md", "srt", "vtt", "ass", "ssa", "sub", "sbv", "txt"]
 
         # Check for media files (audio and video)
         for ext in set(media_formats):  # Remove duplicates
@@ -69,44 +72,41 @@ class FileExistenceManager:
                 if file_path not in existing_files["media"]:
                     existing_files["media"].append(file_path)
 
-        # Check for subtitle files
-        for ext in set(subtitle_formats):  # Remove duplicates
-            # Check multiple naming patterns for subtitle files
+        # Check for caption files
+        for ext in set(caption_formats):  # Remove duplicates
+            # Check multiple naming patterns for caption files
             # Pattern 1: Simple pattern like {video_id}.vtt
-            subtitle_file = output_path / f"{video_id}.{ext}"
-            if subtitle_file.exists():
-                existing_files["subtitle"].append(str(subtitle_file))
+            caption_file = output_path / f"{video_id}.{ext}"
+            if caption_file.exists():
+                existing_files["caption"].append(str(caption_file))
 
             # Pattern 2: With language/track suffix like {video_id}.en-trackid.vtt
-            for sub_file in output_path.glob(f"{video_id}.*.{ext}"):
+            for sub_file in output_path.glob(f"{video_id}*.{ext}"):
                 file_path = str(sub_file)
-                if file_path not in existing_files["subtitle"]:
-                    existing_files["subtitle"].append(file_path)
-
-        if "md" in subtitle_formats:
-            # Gemini-specific pattern: {video_id}_Gemini.md
-            gemini_subtitle_file = output_path / f"{video_id}_Gemini.md"
-            if gemini_subtitle_file.exists():
-                existing_files["subtitle"].append(str(gemini_subtitle_file))
+                if file_path not in existing_files["caption"]:
+                    existing_files["caption"].append(file_path)
 
         return existing_files
 
     @staticmethod
-    def prompt_user_confirmation(existing_files: Dict[str, List[str]], operation: str = "download") -> str:
+    def prompt_user_confirmation(
+        existing_files: Dict[str, List[str]], operation: str = "download", transcriber_name: str = None
+    ) -> str:
         """
         Prompt user for confirmation when files already exist (legacy, confirms all files together)
 
         Args:
             existing_files: Dictionary of existing files
             operation: Type of operation (e.g., "download", "generate")
+            transcriber_name: Name of the transcriber to display (e.g., "Gemini_2.5_Pro")
 
         Returns:
             User choice: 'use' (use existing), 'overwrite' (regenerate), or 'cancel'
         """
         has_media = bool(existing_files.get("media", []))
-        has_subtitle = bool(existing_files.get("subtitle", []))
+        has_caption = bool(existing_files.get("caption", []))
 
-        if not has_media and not has_subtitle:
+        if not has_media and not has_caption:
             return "proceed"  # No existing files, proceed normally
 
         # Header with warning color
@@ -116,24 +116,39 @@ class FileExistenceManager:
         file_paths = []
         if has_media:
             file_paths.extend(existing_files["media"])
-        if has_subtitle:
-            file_paths.extend(existing_files["subtitle"])
+        if has_caption:
+            file_paths.extend(existing_files["caption"])
 
         # Create display options with emojis
-        options = []
-        for file_path in file_paths:
+        options, shift_length = [], 0
+        for file_path in sorted(file_paths):
             # Determine emoji based on file type
             if has_media and file_path in existing_files["media"]:
                 display_text = f'{colorful.green("•")} 🎬 Media file: {file_path}'
+                shift_length = len("Media file:")
             else:
-                display_text = f'{colorful.green("•")} 📝 Subtitle file: {file_path}'
+                display_text = f'{colorful.green("•")} 📝 Caption file: {file_path}'
+                shift_length = len("Caption file:")
             options.append((display_text, file_path))
 
-        # Add overwrite and cancel options
+        # Add overwrite and cancel options with aligned spacing
+        overwrite_text, overwrite_op = "Overwrite existing files (re-generate or download)", "overwrite"
+        if transcriber_name:
+            options.append(
+                (
+                    f'{colorful.green("•")} 🔄 {" " * shift_length} {overwrite_text}',
+                    overwrite_op,
+                )
+            )
+            overwrite_text, overwrite_op = f"Transcribe with {transcriber_name}", TRANSCRIBE_CHOICE
+
         options.extend(
             [
-                ("                  Overwrite existing files (re-generate or download)", "overwrite"),
-                ("                  Cancel operation", "cancel"),
+                (
+                    f'{colorful.green("•")} 🔄 {" " * shift_length} {overwrite_text}',
+                    overwrite_op,
+                ),
+                (f'{colorful.green("•")} ❌ {" " * shift_length} Cancel operation', "cancel"),
             ]
         )
 
@@ -143,6 +158,8 @@ class FileExistenceManager:
 
         if choice == "overwrite":
             print(f'{colorful.yellow("🔄 Overwriting existing files")}')
+        elif choice == TRANSCRIBE_CHOICE:
+            print(f'{colorful.magenta(f"✨ Will transcribe with {transcriber_name}")}')
         elif choice == "cancel":
             print(f'{colorful.red("❌ Operation cancelled")}')
         elif choice in file_paths:
@@ -158,7 +175,7 @@ class FileExistenceManager:
         Prompt user for confirmation for a specific file type
 
         Args:
-            file_type: Type of file ('audio', 'video', 'subtitle', 'gemini')
+            file_type: Type of file ('audio', 'video', 'caption', 'gemini')
             files: List of existing files of this type
             operation: Type of operation (e.g., "download", "generate")
 
@@ -174,21 +191,21 @@ class FileExistenceManager:
         # Header with warning color
         print(f'\n{colorful.bold_yellow(f"⚠️  Existing {label} files found:")}')
 
-        for file_path in files:
+        for file_path in sorted(files):
             print(f'   {colorful.green("•")} {file_path}')
 
-        prompt_message = f"What would you like to do with {label.lower()} files?"
+        prompt_message = f"What would you like to do with {label} files?"
         options = [
-            (f"Use existing {label.lower()} files (skip {operation})", "use"),
-            (f"Overwrite {label.lower()} files (re-{operation})", "overwrite"),
+            (f"Use existing {label} files (skip {operation})", "use"),
+            (f"Overwrite {label} files (re-{operation})", "overwrite"),
             ("Cancel operation", "cancel"),
         ]
         choice = FileExistenceManager._prompt_user_choice(prompt_message, options, default="use")
 
         if choice == "use":
-            print(f'{colorful.green(f"✅ Using existing {label.lower()} files")}')
+            print(f'{colorful.green(f"✅ Using existing {label} files")}')
         elif choice == "overwrite":
-            print(f'{colorful.yellow(f"🔄 Overwriting {label.lower()} files")}')
+            print(f'{colorful.yellow(f"🔄 Overwriting {label} files")}')
         elif choice == "cancel":
             print(f'{colorful.red("❌ Operation cancelled")}')
 
@@ -196,19 +213,23 @@ class FileExistenceManager:
 
     @staticmethod
     def prompt_file_selection(
-        file_type: str, files: List[str], operation: str = "use", enable_gemini: bool = False
+        file_type: str,
+        files: List[str],
+        operation: str = "use",
+        transcriber_name: str = None,
     ) -> str:
         """
         Prompt user to select a specific file from a list, or choose to overwrite/cancel
 
         Args:
-            file_type: Type of file (e.g., 'gemini transcript', 'subtitle')
+            file_type: Type of file (e.g., 'gemini transcript', 'caption')
             files: List of existing files to choose from
             operation: Type of operation (e.g., "transcribe", "download")
-            enable_gemini: If True, adds "Transcribe with Gemini" option
+            transcriber_name: Name of the transcriber to display (e.g., "Gemini_2.5_Pro").
+                If provided, adds transcribe option for the transcriber.
 
         Returns:
-            Selected file path, 'overwrite' to regenerate, 'gemini' to transcribe with Gemini, or 'cancel' to abort
+            Selected file path, 'overwrite' to regenerate, 'gemini' to transcribe with transcriber, or 'cancel' to abort
         """
         if not files:
             return "proceed"
@@ -228,16 +249,17 @@ class FileExistenceManager:
 
         # Create options with full file paths
         options = []
-        for i, file_path in enumerate(files, 1):
+        for i, file_path in enumerate(sorted(files), 1):
             # Display full path for clarity
             options.append((f"{colorful.cyan(file_path)}", file_path))
 
-        # Add Gemini transcription option if enabled
-        if enable_gemini:
-            options.append((colorful.magenta("✨ Transcribe with Gemini 2.5 Pro"), "gemini"))
-
-        # Add overwrite and cancel options
-        options.append((colorful.yellow(f"Overwrite (re-{operation} or download)"), "overwrite"))
+        # Add transcription or overwrite option
+        if transcriber_name:
+            transcribe_text = f"✨ Transcribe with {transcriber_name}"
+            options.append((colorful.magenta(transcribe_text), TRANSCRIBE_CHOICE))
+        else:
+            overwrite_text = f"Overwrite (re-{operation} or download)"
+            options.append((colorful.yellow(overwrite_text), "overwrite"))
         options.append((colorful.red("Cancel operation"), "cancel"))
 
         prompt_message = colorful.bold_black_on_cyan(f"Select which {file_type} to use:")
@@ -246,9 +268,11 @@ class FileExistenceManager:
         if choice == "cancel":
             print(f'{colorful.red("❌ Operation cancelled")}')
         elif choice == "overwrite":
-            print(f'{colorful.yellow(f"🔄 Overwriting all {file_type} files")}')
-        elif choice == "gemini":
-            print(f'{colorful.magenta("✨ Will transcribe with Gemini 2.5 Pro")}')
+            overwrite_msg = f"🔄 Overwriting all {file_type} files"
+            print(f"{colorful.yellow(overwrite_msg)}")
+        elif choice == TRANSCRIBE_CHOICE:
+            transcribe_msg = f"✨ Will transcribe with {transcriber_name}"
+            print(f"{colorful.magenta(transcribe_msg)}")
         else:
             print(f'{colorful.green(f"✅ Using: {choice}")}')
 
@@ -269,7 +293,7 @@ class FileExistenceManager:
             Dictionary mapping file type to user choice ('use', 'overwrite', 'proceed', or 'cancel')
         """
         ordered_types = []
-        for preferred in ["media", "audio", "video", "subtitle"]:
+        for preferred in ["media", "audio", "video", "caption"]:
             if preferred not in ordered_types:
                 ordered_types.append(preferred)
         for file_type in existing_files.keys():