lattifai 0.4.1__py3-none-any.whl → 0.4.3__py3-none-any.whl

lattifai/bin/agent.py

@@ -18,12 +18,15 @@ from lattifai.io import OUTPUT_SUBTITLE_FORMATS
 @cli.command()
 @click.option('--youtube', '--yt', is_flag=True, help='Process YouTube URL through agentic workflow.')
 @click.option(
+    '-K',
+    '-L',
     '--api-key',
     '--api_key',
     type=str,
     help='LattifAI API key for alignment (overrides LATTIFAI_API_KEY env var).',
 )
 @click.option(
+    '-G',
     '--gemini-api-key',
     '--gemini_api_key',
     type=str,
@@ -135,14 +138,6 @@ def agent(
     lattifai_api_key = api_key or os.getenv('LATTIFAI_API_KEY')
     gemini_key = gemini_api_key or os.getenv('GEMINI_API_KEY')
 
-    if not gemini_key:
-        click.echo(
-            colorful.red(
-                '❌ Gemini API key is required. Set GEMINI_API_KEY environment variable or use --gemini-api-key option.'
-            )
-        )
-        return
-
     try:
         # Run the YouTube workflow
         asyncio.run(

lattifai/bin/align.py

@@ -52,6 +52,8 @@ from lattifai.io import INPUT_SUBTITLE_FORMATS, OUTPUT_SUBTITLE_FORMATS
     help='Model name or path for alignment.',
 )
 @click.option(
+    '-K',
+    '-L',
     '--api-key',
     '--api_key',
     type=str,
@@ -178,6 +180,8 @@ def align(
     help='Model name or path for alignment.',
 )
 @click.option(
+    '-K',
+    '-L',
     '--api-key',
     '--api_key',
     type=str,
@@ -185,6 +189,7 @@ def align(
     help='API key for LattifAI.',
 )
 @click.option(
+    '-G',
     '--gemini-api-key',
     '--gemini_api_key',
     type=str,
@@ -223,13 +228,6 @@ def youtube(
 
     # Get Gemini API key
     gemini_key = gemini_api_key or os.getenv('GEMINI_API_KEY')
-    if not gemini_key:
-        click.echo(
-            colorful.red(
-                '❌ Gemini API key is required. Set GEMINI_API_KEY environment variable or use --gemini-api-key option.'
-            )
-        )
-        raise click.ClickException('Missing Gemini API key')
 
     async def _process():
         # Initialize components with their configuration (only config, not runtime params)

lattifai/bin/cli_base.py

@@ -9,9 +9,10 @@ def cli():
     The shell entry point to Lattifai, a tool for audio data manipulation.
     """
     # Load environment variables from .env file
-    from dotenv import load_dotenv
+    from dotenv import find_dotenv, load_dotenv
 
-    load_dotenv()
+    # Try to find and load .env file from current directory or parent directories
+    load_dotenv(find_dotenv(usecwd=True))
 
     logging.basicConfig(
         format='%(asctime)s %(levelname)s [%(filename)s:%(lineno)d] %(message)s',

lattifai/client.py

@@ -5,7 +5,6 @@ import os
 from typing import Dict, List, Optional, Tuple, Union
 
 import colorful
-from dotenv import load_dotenv
 from lhotse.utils import Pathlike
 
 from lattifai.base_client import AsyncAPIClient, SyncAPIClient
@@ -22,8 +21,6 @@ from lattifai.io import SubtitleFormat, SubtitleIO, Supervision
 from lattifai.tokenizer import AsyncLatticeTokenizer
 from lattifai.utils import _load_tokenizer, _load_worker, _resolve_model_path, _select_device
 
-load_dotenv()
-
 
 class LattifAI(SyncAPIClient):
     """Synchronous LattifAI client."""

lattifai/io/reader.py

@@ -4,8 +4,8 @@ from typing import List, Literal, Optional, Union
 
 from lhotse.utils import Pathlike
 
-from .parser import parse_speaker_text
 from .supervision import Supervision
+from .text_parser import parse_speaker_text
 
 SubtitleFormat = Literal['txt', 'srt', 'vtt', 'ass', 'auto']
 

lattifai/tokenizer/tokenizer.py

@@ -231,7 +231,7 @@ class LatticeTokenizer:
                     remainder = ''
                 # Detect and split special sentence types: e.g., '[APPLAUSE] >> MIRA MURATI:' -> ['[APPLAUSE]', '>> MIRA MURATI:']  # noqa: E501
                 resplit_parts = self._resplit_special_sentence_types(_sentence)
-                if any(resplit_parts[-1].endswith(sp) for sp in [':', '：', ']']):
+                if any(resplit_parts[-1].endswith(sp) for sp in [':', '：']):
                     if s < len(_sentences) - 1:
                         _sentences[s + 1] = resplit_parts[-1] + ' ' + _sentences[s + 1]
                     else:  # last part

lattifai/workflows/__init__.py

@@ -0,0 +1,34 @@
+"""
+LattifAI Agentic Workflows
+
+This module provides agentic workflow capabilities for automated processing
+of multimedia content through intelligent agent-based pipelines.
+"""
+
+# Import transcript processing functionality
+from lattifai.io import (
+    ALL_SUBTITLE_FORMATS,
+    INPUT_SUBTITLE_FORMATS,
+    OUTPUT_SUBTITLE_FORMATS,
+    SUBTITLE_FORMATS,
+    GeminiReader,
+    GeminiWriter,
+)
+
+from .agents import YouTubeSubtitleAgent
+from .base import WorkflowAgent, WorkflowResult, WorkflowStep
+from .file_manager import FileExistenceManager
+
+__all__ = [
+    'WorkflowAgent',
+    'WorkflowStep',
+    'WorkflowResult',
+    'YouTubeSubtitleAgent',
+    'FileExistenceManager',
+    'GeminiReader',
+    'GeminiWriter',
+    'SUBTITLE_FORMATS',
+    'INPUT_SUBTITLE_FORMATS',
+    'OUTPUT_SUBTITLE_FORMATS',
+    'ALL_SUBTITLE_FORMATS',
+]

lattifai/workflows/agents.py

@@ -0,0 +1,10 @@
+"""
+Subtitle Agents
+
+An agentic workflow for processing YouTube(or more) videos through:
+1. URL processing and audio download
+2. Gemini 2.5 Pro transcription
+3. LattifAI alignment
+"""
+
+from .youtube import YouTubeSubtitleAgent

lattifai/workflows/base.py

@@ -0,0 +1,192 @@
+"""
+Base classes for agentic workflows
+"""
+
+import abc
+import logging
+import time
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Dict, List, Optional, Union
+
+import colorful
+
+
+def setup_workflow_logger(name: str) -> logging.Logger:
+    """Setup a logger with consistent formatting for workflow modules"""
+    logger = logging.getLogger(f'workflows.{name}')
+
+    # Only add handler if it doesn't exist
+    if not logger.handlers:
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter(
+            '%(asctime)s - %(name)+17s.py:%(lineno)-4d - %(levelname)-8s - %(message)s', datefmt='%Y-%m-%d %H:%M:%S'
+        )
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+        logger.setLevel(logging.INFO)
+        logger.propagate = False
+
+    return logger
+
+
+logger = setup_workflow_logger('base')
+
+
+class WorkflowStatus(Enum):
+    """Workflow execution status"""
+
+    PENDING = 'pending'
+    RUNNING = 'running'
+    COMPLETED = 'completed'
+    FAILED = 'failed'
+    RETRYING = 'retrying'
+
+
+@dataclass
+class WorkflowResult:
+    """Result of a workflow execution"""
+
+    status: WorkflowStatus
+    data: Optional[Any] = None
+    error: Optional[str] = None
+    exception: Optional[Exception] = None  # Store the original exception object
+    execution_time: Optional[float] = None
+    step_results: Optional[List[Dict[str, Any]]] = None
+
+    @property
+    def is_success(self) -> bool:
+        return self.status == WorkflowStatus.COMPLETED
+
+    @property
+    def is_error(self) -> bool:
+        return self.status == WorkflowStatus.FAILED
+
+
+@dataclass
+class WorkflowStep:
+    """Individual step in a workflow"""
+
+    name: str
+    description: str
+    required: bool = True
+    retry_count: int = 0
+    max_retries: int = 1
+
+    def should_retry(self) -> bool:
+        return self.retry_count < self.max_retries
+
+
+class WorkflowAgent(abc.ABC):
+    """Base class for agentic workflows"""
+
+    def __init__(self, name: str, max_retries: int = 0):
+        self.name = name
+        self.max_retries = max_retries
+        self.steps: List[WorkflowStep] = []
+        self.logger = setup_workflow_logger('agent')
+
+    @abc.abstractmethod
+    def define_steps(self) -> List[WorkflowStep]:
+        """Define the workflow steps"""
+        pass
+
+    @abc.abstractmethod
+    async def execute_step(self, step: WorkflowStep, context: Dict[str, Any]) -> Any:
+        """Execute a single workflow step"""
+        pass
+
+    def setup(self):
+        """Setup the workflow"""
+        self.steps = self.define_steps()
+        for step in self.steps:
+            step.max_retries = self.max_retries
+
+    async def execute(self, **kwargs) -> WorkflowResult:
+        """Execute the complete workflow"""
+        if not self.steps:
+            self.setup()
+
+        start_time = time.time()
+        context = kwargs.copy()
+        step_results = []
+
+        self.logger.info(colorful.bold_white_on_green(f'🚀 Starting workflow: {self.name}'))
+
+        try:
+            for i, step in enumerate(self.steps):
+                step_info = f'📋 Step {i + 1}/{len(self.steps)}: {step.name}'
+                self.logger.info(colorful.bold_white_on_green(step_info))
+
+                step_start = time.time()
+                step_result = await self._execute_step_with_retry(step, context)
+                step_duration = time.time() - step_start
+
+                step_results.append(
+                    {'step_name': step.name, 'status': 'completed', 'duration': step_duration, 'result': step_result}
+                )
+
+                # Update context with step result
+                context[f'step_{i}_result'] = step_result
+                context[f'{step.name.lower().replace(" ", "_")}_result'] = step_result
+
+                self.logger.info(f'✅ Step {i + 1} completed in {step_duration:.2f}s')
+
+            execution_time = time.time() - start_time
+            self.logger.info(f'🎉 Workflow completed in {execution_time:.2f}s')
+
+            return WorkflowResult(
+                status=WorkflowStatus.COMPLETED, data=context, execution_time=execution_time, step_results=step_results
+            )
+
+        except Exception as e:
+            execution_time = time.time() - start_time
+            # For LattifAI errors, just log the error code and basic message
+            from lattifai.errors import LattifAIError
+
+            if isinstance(e, LattifAIError):
+                self.logger.error(f'❌ Workflow failed after {execution_time:.2f}s: [{e.error_code}] {e.message}')
+            else:
+                self.logger.error(f'❌ Workflow failed after {execution_time:.2f}s: {str(e)}')
+
+            return WorkflowResult(
+                status=WorkflowStatus.FAILED,
+                error=str(e),
+                exception=e,  # Store the original exception
+                execution_time=execution_time,
+                step_results=step_results,
+            )
+
+    async def _execute_step_with_retry(self, step: WorkflowStep, context: Dict[str, Any]) -> Any:
+        """Execute a step with retry logic"""
+        last_error = None
+
+        for attempt in range(step.max_retries + 1):
+            try:
+                if attempt > 0:
+                    self.logger.info(f'🔄 Retrying step {step.name} (attempt {attempt + 1}/{step.max_retries + 1})')
+
+                result = await self.execute_step(step, context)
+                return result
+
+            except Exception as e:
+                last_error = e
+                step.retry_count += 1
+
+                # For LattifAI errors, show simplified message in logs
+                from lattifai.errors import LattifAIError
+
+                error_summary = f'[{e.error_code}]' if isinstance(e, LattifAIError) else str(e)[:100]
+
+                if step.should_retry():
+                    self.logger.warning(f'⚠️ Step {step.name} failed: {error_summary}. Retrying...')
+                    continue
+                else:
+                    self.logger.error(
+                        f'❌ Step {step.name} failed after {step.max_retries + 1} attempts: {error_summary}'
+                    )
+                    raise e
+
+        # This should never be reached, but just in case
+        if last_error:
+            raise last_error