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

lattifai/cli/youtube.py

@@ -25,6 +25,7 @@ def youtube(
     caption: Annotated[Optional[CaptionConfig], run.Config[CaptionConfig]] = None,
     transcription: Annotated[Optional[TranscriptionConfig], run.Config[TranscriptionConfig]] = None,
     diarization: Annotated[Optional[DiarizationConfig], run.Config[DiarizationConfig]] = None,
+    use_transcription: bool = False,
 ):
     """
     Download media from YouTube (when needed) and align captions.
@@ -55,6 +56,11 @@ def youtube(
             Fields: gemini_api_key, model_name, language, device
         diarization: Speaker diarization configuration.
             Fields: enabled, num_speakers, min_speakers, max_speakers, device
+        use_transcription: If True, skip YouTube caption download and directly use
+            transcription.model_name to transcribe. If False (default), first try to
+            download YouTube captions; if download fails (no captions available or
+            errors like HTTP 429), automatically fallback to transcription if
+            transcription.model_name is configured.
 
     Examples:
         # Download from YouTube and align (positional argument)
@@ -108,7 +114,11 @@ def youtube(
         transcription_config=transcription,
         diarization_config=diarization,
     )
+
     # Call the client's youtube method
+    # If use_transcription=True, skip YouTube caption download and use transcription directly.
+    # If use_transcription=False (default), try YouTube captions first; on failure,
+    # automatically fallback to transcription if transcription.model_name is configured.
     return lattifai_client.youtube(
         url=media_config.input_path,
         output_dir=media_config.output_dir,
@@ -118,6 +128,7 @@ def youtube(
         split_sentence=caption_config.split_sentence,
         channel_selector=media_config.channel_selector,
         streaming_chunk_secs=media_config.streaming_chunk_secs,
+        use_transcription=use_transcription,
     )
 
 

lattifai/client.py

@@ -56,6 +56,7 @@ class LattifAI(LattifAIClientMixin, SyncAPIClient):
 
         # Initialize base API client
         super().__init__(config=client_config)
+        self.config = client_config
 
         # Initialize all configs with defaults
         alignment_config, transcription_config, diarization_config = self._init_configs(
@@ -269,6 +270,10 @@ class LattifAI(LattifAIClientMixin, SyncAPIClient):
             if output_caption_path:
                 self._write_caption(caption, output_caption_path)
 
+            # Profile if enabled
+            if self.config.profile:
+                self.aligner.profile()
+
         except (CaptionProcessingError, LatticeEncodingError, AlignmentError, LatticeDecodingError):
             # Re-raise our specific errors as-is
             raise

lattifai/config/client.py

@@ -26,6 +26,11 @@ class ClientConfig:
     default_headers: Optional[Dict[str, str]] = field(default=None)
     """Optional static headers to include in all requests."""
 
+    profile: bool = False
+    """Enable profiling of client operations tasks.
+    When True, prints detailed timing information for various stages of the process.
+    """
+
     def __post_init__(self):
         """Validate and auto-populate configuration after initialization."""
 

lattifai/mixin.py

@@ -491,10 +491,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

@@ -44,49 +44,6 @@ def safe_print(text: str, **kwargs) -> None:
             print(text.encode("utf-8", errors="replace").decode("utf-8"), **kwargs)
 
 
-def _get_cache_marker_path(cache_dir: Path) -> Path:
-    """Get the path for the cache marker file with current date."""
-    today = datetime.now().strftime("%Y%m%d")
-    return cache_dir / f".done{today}"
-
-
-def _is_cache_valid(cache_dir: Path) -> bool:
-    """Check if cached model is valid (exists and not older than 1 days)."""
-    if not cache_dir.exists():
-        return False
-
-    # Find any .done* marker files
-    marker_files = list(cache_dir.glob(".done*"))
-    if not marker_files:
-        return False
-
-    # Get the most recent marker file
-    latest_marker = max(marker_files, key=lambda p: p.stat().st_mtime)
-
-    # Extract date from marker filename (format: .doneYYYYMMDD)
-    try:
-        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):
-            return False
-        return True
-    except (ValueError, IndexError):
-        # Invalid marker file format, treat as invalid cache
-        return False
-
-
-def _create_cache_marker(cache_dir: Path) -> None:
-    """Create a cache marker file with current date and clean old markers."""
-    # Remove old marker files
-    for old_marker in cache_dir.glob(".done*"):
-        old_marker.unlink(missing_ok=True)
-
-    # Create new marker file
-    marker_path = _get_cache_marker_path(cache_dir)
-    marker_path.touch()
-
-
 def _resolve_model_path(model_name_or_path: str, model_hub: str = "huggingface") -> str:
     """Resolve model path, downloading from the specified model hub when necessary.
 
@@ -108,27 +65,32 @@ 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.constants import HF_HUB_CACHE
+        from huggingface_hub import HfApi, snapshot_download
         from huggingface_hub.errors import LocalEntryNotFoundError
 
-        # Determine cache directory for this model
-        cache_dir = Path(HF_HUB_CACHE) / f'models--{model_name_or_path.replace("/", "--")}'
+        # 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)
 
-        # Check if we have a valid cached version
-        if _is_cache_valid(cache_dir):
-            # Return the snapshot path (latest version)
-            snapshots_dir = cache_dir / "snapshots"
-            if snapshots_dir.exists():
-                snapshot_dirs = [d for d in snapshots_dir.iterdir() if d.is_dir()]
-                if snapshot_dirs:
-                    # Return the most recent snapshot
-                    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")
-            _create_cache_marker(cache_dir)
+            downloaded_path = snapshot_download(repo_id=hf_repo_id, repo_type="model", revision=revision)
             return downloaded_path
         except LocalEntryNotFoundError:
             # Fall back to modelscope if HF entry not found

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]]:
         """