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

lattifai/mixin.py

@@ -290,12 +290,12 @@ class LattifAIClientMixin:
             diarization_file = Path(str(input_caption)).with_suffix(".SpkDiar")
             if diarization_file.exists():
                 if verbose:
-                    safe_print(colorful.cyan(f"📖 Step 1b: Reading speaker diarization from {diarization_file}"))
+                    safe_print(colorful.cyan(f"📖 Step1b: Reading speaker diarization from {diarization_file}"))
                 caption.read_speaker_diarization(diarization_file)
             events_file = Path(str(input_caption)).with_suffix(".AED")
             if events_file.exists():
                 if verbose:
-                    safe_print(colorful.cyan(f"📖 Step 1c: Reading audio events from {events_file}"))
+                    safe_print(colorful.cyan(f"📖 Step1c: Reading audio events from {events_file}"))
                 from tgt import read_textgrid
 
                 caption.audio_events = read_textgrid(events_file)
@@ -404,6 +404,14 @@ class LattifAIClientMixin:
             # Transcription mode: use Transcriber to transcribe
             self._validate_transcription_setup()
 
+            if output_dir:
+                # Generate transcript file path
+                transcript_file = output_dir / f"{Path(str(media_file)).stem}_{self.transcriber.file_name}"
+                if transcript_file.exists():
+                    safe_print(colorful.cyan(f"    Using existing transcript file: {transcript_file}"))
+                    transcription = self._read_caption(transcript_file, normalize_text=False)
+                    return transcription
+
             safe_print(colorful.cyan(f"🎤 Transcribing({self.transcriber.name}) media: {str(media_file)} ..."))
             transcription = await self.transcriber.transcribe_file(media_file, language=source_lang)
             safe_print(colorful.green("         ✓ Transcription completed."))
@@ -442,8 +450,6 @@ class LattifAIClientMixin:
                         safe_print(colorful.yellow(f"First segment: {transcription.transcription[0].text}"))
 
             if output_dir:
-                # Generate transcript file path
-                transcript_file = output_dir / f"{Path(str(media_file)).stem}_{self.transcriber.file_name}"
                 await asyncio.to_thread(self.transcriber.write, transcription, transcript_file, encoding="utf-8")
                 safe_print(colorful.green(f"         ✓ Transcription saved to: {transcript_file}"))
 
@@ -491,10 +497,13 @@ class LattifAIClientMixin:
                     safe_print(colorful.green(f"📄 Using provided caption file: {caption_path}"))
                     return str(caption_path)
                 else:
-                    raise FileNotFoundError(f"Provided caption path does not exist: {caption_path}")
-
-            # Generate transcript file path
-            transcript_file = output_dir / f"{Path(str(media_file)).stem}_{self.transcriber.file_name}"
+                    safe_print(colorful.red(f"Provided caption path does not exist: {caption_path}, use transcription"))
+                    use_transcription = True
+                    transcript_file = caption_path
+                    caption_path.parent.mkdir(parents=True, exist_ok=True)
+            else:
+                # Generate transcript file path
+                transcript_file = output_dir / f"{Path(str(media_file)).stem}_{self.transcriber.file_name}"
 
             if use_transcription:
                 # Transcription mode: use Transcriber to transcribe

lattifai/utils.py

@@ -68,7 +68,7 @@ def _is_cache_valid(cache_dir: Path) -> bool:
         date_str = latest_marker.name.replace(".done", "")
         marker_date = datetime.strptime(date_str, "%Y%m%d")
         # Check if marker is older than 1 days
-        if datetime.now() - marker_date > timedelta(days=1):
+        if datetime.now() - marker_date > timedelta(days=7):
             return False
         return True
     except (ValueError, IndexError):
@@ -108,12 +108,18 @@ def _resolve_model_path(model_name_or_path: str, model_hub: str = "huggingface")
         return str(Path(model_name_or_path).expanduser())
 
     if hub == "huggingface":
-        from huggingface_hub import snapshot_download
+        from huggingface_hub import HfApi, snapshot_download
         from huggingface_hub.constants import HF_HUB_CACHE
         from huggingface_hub.errors import LocalEntryNotFoundError
 
+        # Support repo_id@revision syntax
+        hf_repo_id = model_name_or_path
+        revision = None
+        if "@" in model_name_or_path:
+            hf_repo_id, revision = model_name_or_path.split("@", 1)
+
         # Determine cache directory for this model
-        cache_dir = Path(HF_HUB_CACHE) / f'models--{model_name_or_path.replace("/", "--")}'
+        cache_dir = Path(HF_HUB_CACHE) / f'models--{hf_repo_id.replace("/", "--")}'
 
         # Check if we have a valid cached version
         if _is_cache_valid(cache_dir):
@@ -126,8 +132,23 @@ def _resolve_model_path(model_name_or_path: str, model_hub: str = "huggingface")
                     latest_snapshot = max(snapshot_dirs, key=lambda p: p.stat().st_mtime)
                     return str(latest_snapshot)
 
+        # If no specific revision/commit is provided, try to fetch the real latest SHA
+        # to bypass Hugging Face's model_info (metadata) sync lag.
+        if not revision:
+            try:
+                api = HfApi()
+                refs = api.list_repo_refs(repo_id=hf_repo_id, repo_type="model")
+                # Look for the default branch (usually 'main')
+                for branch in refs.branches:
+                    if branch.name == "main":
+                        revision = branch.target_commit
+                        break
+            except Exception:
+                # Fallback to default behavior if API call fails
+                revision = None
+
         try:
-            downloaded_path = snapshot_download(repo_id=model_name_or_path, repo_type="model")
+            downloaded_path = snapshot_download(repo_id=hf_repo_id, repo_type="model", revision=revision)
             _create_cache_marker(cache_dir)
             return downloaded_path
         except LocalEntryNotFoundError:
@@ -151,8 +172,23 @@ def _resolve_model_path(model_name_or_path: str, model_hub: str = "huggingface")
     # modelscope path
     from modelscope.hub.snapshot_download import snapshot_download as ms_snapshot
 
+    # Determine cache directory for ModelScope
+    # ModelScope uses ~/.cache/modelscope/hub/models/{org}/{model} structure
+    modelscope_cache = Path.home() / ".cache" / "modelscope" / "hub" / "models"
+    cache_dir = modelscope_cache / model_name_or_path
+
+    # Check if we have a valid cached version
+    if _is_cache_valid(cache_dir):
+        # Return the cached path directly
+        if cache_dir.exists():
+            return str(cache_dir)
+
     try:
         downloaded_path = ms_snapshot(model_name_or_path)
+        # Create cache marker after successful download
+        if downloaded_path:
+            actual_cache_dir = Path(downloaded_path)
+            _create_cache_marker(actual_cache_dir)
         return downloaded_path
     except Exception as e:  # pragma: no cover
         raise ModelLoadError(model_name_or_path, original_error=e)

lattifai/workflow/youtube.py

@@ -429,79 +429,77 @@ class YouTubeDownloader:
             result = await loop.run_in_executor(
                 None, lambda: subprocess.run(ytdlp_options, capture_output=True, text=True, check=True)
             )
-
             # Only log success message, not full yt-dlp output
             self.logger.debug(f"yt-dlp output: {result.stdout.strip()}")
-
-            # Find the downloaded transcript file
-            caption_patterns = [
-                f"{video_id}.*vtt",
-                f"{video_id}.*srt",
-                f"{video_id}.*sub",
-                f"{video_id}.*sbv",
-                f"{video_id}.*ssa",
-                f"{video_id}.*ass",
-            ]
-
-            caption_files = []
-            for pattern in caption_patterns:
-                _caption_files = list(target_dir.glob(pattern))
-                for caption_file in _caption_files:
-                    self.logger.info(f"📥 Downloaded caption: {caption_file}")
-                caption_files.extend(_caption_files)
-
-            if not caption_files:
-                self.logger.warning("No caption available for this video")
-                return None
-
-            # If only one caption file, return it directly
-            if len(caption_files) == 1:
-                self.logger.info(f"✅ Using caption: {caption_files[0]}")
-                return str(caption_files[0])
-
-            # Multiple caption files found, let user choose
-            if FileExistenceManager.is_interactive_mode():
-                self.logger.info(f"📋 Found {len(caption_files)} caption files")
-                caption_choice = FileExistenceManager.prompt_file_selection(
-                    file_type="caption",
-                    files=[str(f) for f in caption_files],
-                    operation="use",
-                    transcriber_name=transcriber_name,
-                )
-
-                if caption_choice == "cancel":
-                    raise RuntimeError("Caption selection cancelled by user")
-                elif caption_choice == TRANSCRIBE_CHOICE:
-                    return caption_choice
-                elif caption_choice:
-                    self.logger.info(f"✅ Selected caption: {caption_choice}")
-                    return caption_choice
-                else:
-                    # Fallback to first file
-                    self.logger.info(f"✅ Using first caption: {caption_files[0]}")
-                    return str(caption_files[0])
-            else:
-                # Non-interactive mode: use first file
-                self.logger.info(f"✅ Using first caption: {caption_files[0]}")
-                return str(caption_files[0])
-
         except subprocess.CalledProcessError as e:
             error_msg = e.stderr.strip() if e.stderr else str(e)
 
             # Check for specific error conditions
             if "No automatic or manual captions found" in error_msg:
                 self.logger.warning("No captions available for this video")
-                return None
             elif "HTTP Error 429" in error_msg or "Too Many Requests" in error_msg:
                 self.logger.error("YouTube rate limit exceeded. Please try again later or use a different method.")
-                raise RuntimeError(
+                self.logger.error(
                     "YouTube rate limit exceeded (HTTP 429). "
                     "Try again later or use --cookies option with authenticated cookies. "
                     "See: https://github.com/yt-dlp/yt-dlp/wiki/FAQ#how-do-i-pass-cookies-to-yt-dlp"
                 )
             else:
                 self.logger.error(f"Failed to download transcript: {error_msg}")
-                raise RuntimeError(f"Failed to download transcript: {error_msg}")
+
+        # Find the downloaded transcript file
+        caption_patterns = [
+            f"{video_id}.*vtt",
+            f"{video_id}.*srt",
+            f"{video_id}.*sub",
+            f"{video_id}.*sbv",
+            f"{video_id}.*ssa",
+            f"{video_id}.*ass",
+        ]
+
+        caption_files = []
+        for pattern in caption_patterns:
+            _caption_files = list(target_dir.glob(pattern))
+            for caption_file in _caption_files:
+                self.logger.info(f"📥 Downloaded caption: {caption_file}")
+            caption_files.extend(_caption_files)
+
+        # If only one caption file, return it directly
+        if len(caption_files) == 1:
+            self.logger.info(f"✅ Using caption: {caption_files[0]}")
+            return str(caption_files[0])
+
+        # Multiple caption files found, let user choose
+        if FileExistenceManager.is_interactive_mode():
+            self.logger.info(f"📋 Found {len(caption_files)} caption files")
+            caption_choice = FileExistenceManager.prompt_file_selection(
+                file_type="caption",
+                files=[str(f) for f in caption_files],
+                operation="use",
+                transcriber_name=transcriber_name,
+            )
+
+            if caption_choice == "cancel":
+                raise RuntimeError("Caption selection cancelled by user")
+            elif caption_choice == TRANSCRIBE_CHOICE:
+                return caption_choice
+            elif caption_choice:
+                self.logger.info(f"✅ Selected caption: {caption_choice}")
+                return caption_choice
+            elif caption_files:
+                # Fallback to first file
+                self.logger.info(f"✅ Using first caption: {caption_files[0]}")
+                return str(caption_files[0])
+            else:
+                self.logger.warning("No caption files available after download")
+                return None
+        elif caption_files:
+            # Non-interactive mode: use first file
+            self.logger.info(f"✅ Using first caption: {caption_files[0]}")
+            return str(caption_files[0])
+        else:
+            self.logger.warning("No caption files available after download")
+            return None
 
     async def list_available_captions(self, url: str) -> List[Dict[str, Any]]:
         """