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

lattifai/__init__.py

@@ -61,11 +61,16 @@ def __getattr__(name):
         from .client import LattifAI
 
         return LattifAI
+    if name == 'AsyncLattifAI':
+        from .client import AsyncLattifAI
+
+        return AsyncLattifAI
     raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
 
 
 __all__ = [
     'LattifAI',  # noqa: F822
+    'AsyncLattifAI',  # noqa: F822
     'LattifAIError',
     'AudioProcessingError',
     'AudioLoadError',

lattifai/base_client.py

@@ -113,3 +113,14 @@ class AsyncAPIClient(BaseAPIClient):
     ) -> httpx.Response:
         """Make an HTTP request."""
         return await self._client.request(method=method, url=url, json=json, files=files, **kwargs)
+
+    async def post(
+        self,
+        api_endpoint: str,
+        *,
+        json: Optional[Dict[str, Any]] = None,
+        files: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ) -> httpx.Response:
+        """Make a POST request to the specified API endpoint."""
+        return await self._request('POST', api_endpoint, json=json, files=files, **kwargs)

lattifai/bin/__init__.py

@@ -1,2 +1,3 @@
+from .agent import *  # noqa
 from .align import *  # noqa
 from .subtitle import *  # noqa

lattifai/bin/agent.py

@@ -0,0 +1,326 @@
+"""
+Agent command for YouTube workflow
+"""
+
+import asyncio
+import os
+import sys
+from typing import List, Optional
+
+import click
+import colorful
+from lhotse.utils import Pathlike
+
+from lattifai.bin.cli_base import cli
+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(
+    '--api-key',
+    '--api_key',
+    type=str,
+    help='LattifAI API key for alignment (overrides LATTIFAI_API_KEY env var).',
+)
+@click.option(
+    '--gemini-api-key',
+    '--gemini_api_key',
+    type=str,
+    help='Gemini API key for transcription (overrides GEMINI_API_KEY env var).',
+)
+@click.option(
+    '-D',
+    '--device',
+    type=click.Choice(['cpu', 'cuda', 'mps'], case_sensitive=False),
+    default='cpu',
+    help='Device to use for inference.',
+)
+@click.option(
+    '-M',
+    '--model-name-or-path',
+    '--model_name_or_path',
+    type=str,
+    default='Lattifai/Lattice-1-Alpha',
+    help='Model name or path for alignment.',
+)
+@click.option(
+    '--media-format',
+    '--media_format',
+    type=click.Choice(
+        ['mp3', 'wav', 'm4a', 'aac', 'opus', 'mp4', 'webm', 'mkv', 'avi', 'mov', 'flv', 'wmv', 'mpeg', 'mpg', '3gp'],
+        case_sensitive=False,
+    ),
+    default='mp4',
+    help='Media format for YouTube download (audio or video).',
+)
+@click.option(
+    '--output-format',
+    '--output_format',
+    type=click.Choice(OUTPUT_SUBTITLE_FORMATS, case_sensitive=False),
+    default='srt',
+    help='Subtitle output format.',
+)
+@click.option(
+    '--output-dir',
+    '--output_dir',
+    type=click.Path(exists=False, file_okay=False, dir_okay=True),
+    help='Output directory for generated files (default: current directory).',
+)
+@click.option(
+    '--max-retries',
+    '--max_retries',
+    type=int,
+    default=0,
+    help='Maximum number of retries for failed steps.',
+)
+@click.option(
+    '-S',
+    '--split-sentence',
+    '--split_sentence',
+    is_flag=True,
+    default=False,
+    help='Re-segment subtitles by semantics.',
+)
+@click.option(
+    '--word-level',
+    '--word_level',
+    is_flag=True,
+    default=False,
+    help='Include word-level alignment timestamps in output (for JSON, TextGrid, and subtitle formats).',
+)
+@click.option('--verbose', '-v', is_flag=True, help='Enable verbose logging.')
+@click.option('--force', '-f', is_flag=True, help='Force overwrite existing files without confirmation.')
+@click.argument('url', type=str, required=True)
+def agent(
+    youtube: bool,
+    url: str,
+    api_key: Optional[str] = None,
+    gemini_api_key: Optional[str] = None,
+    device: str = 'cpu',
+    model_name_or_path: str = 'Lattifai/Lattice-1-Alpha',
+    media_format: str = 'mp4',
+    output_format: str = 'srt',
+    output_dir: Optional[str] = None,
+    max_retries: int = 0,
+    split_sentence: bool = False,
+    word_level: bool = False,
+    verbose: bool = False,
+    force: bool = False,
+):
+    """
+    LattifAI Agentic Workflow Agent
+
+    Process multimedia content through intelligent agent-based pipelines.
+
+    Example:
+        lattifai agent --youtube https://www.youtube.com/watch?v=example
+    """
+
+    if not youtube:
+        click.echo(colorful.red('❌ Please specify a workflow type. Use --youtube for YouTube processing.'))
+        return
+
+    # Setup logging
+    import logging
+
+    log_level = logging.DEBUG if verbose else logging.INFO
+    logging.basicConfig(level=log_level, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+
+    # Set default output directory
+    if not output_dir:
+        output_dir = os.getcwd()
+
+    # Get API keys
+    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(
+            _run_youtube_workflow(
+                url=url,
+                lattifai_api_key=lattifai_api_key,
+                gemini_api_key=gemini_key,
+                device=device,
+                model_name_or_path=model_name_or_path,
+                media_format=media_format,
+                output_format=output_format,
+                output_dir=output_dir,
+                max_retries=max_retries,
+                split_sentence=split_sentence,
+                word_level=word_level,
+                force_overwrite=force,
+            )
+        )
+
+    except KeyboardInterrupt:
+        click.echo(colorful.yellow('\n⚠️ Process interrupted by user'))
+        sys.exit(1)
+    except Exception as e:
+        from lattifai.errors import LattifAIError
+
+        # Extract error message without support info (to avoid duplication)
+        if isinstance(e, LattifAIError):
+            # Use the get_message() method which includes proper formatting
+            click.echo(colorful.red('❌ Workflow failed:'))
+            click.echo(e.get_message())
+            # Show support info once at the end
+            click.echo(e.get_support_info())
+        else:
+            click.echo(colorful.red(f'❌ Workflow failed: {str(e)}'))
+
+        if verbose:
+            import traceback
+
+            traceback.print_exc()
+        sys.exit(1)
+
+
+async def _run_youtube_workflow(
+    url: str,
+    lattifai_api_key: Optional[str],
+    gemini_api_key: str,
+    device: str,
+    model_name_or_path: str,
+    media_format: str,
+    output_format: str,
+    output_dir: str,
+    max_retries: int,
+    split_sentence: bool = False,
+    word_level: bool = False,
+    force_overwrite: bool = False,
+):
+    """Run the YouTube processing workflow"""
+
+    click.echo(colorful.cyan('🚀 LattifAI Agentic Workflow - YouTube Processing'))
+    click.echo(f'📺      YouTube URL: {url}')
+    click.echo(f'🎬     Media format: {media_format}')
+    click.echo(f'📝    Output format: {output_format}')
+    click.echo(f'📁 Output directory: {output_dir}')
+    click.echo(f'🔄      Max retries: {max_retries}')
+    click.echo()
+
+    # Import workflow components
+    from lattifai.client import AsyncLattifAI
+    from lattifai.workflows import YouTubeSubtitleAgent
+    from lattifai.workflows.gemini import GeminiTranscriber
+    from lattifai.workflows.youtube import YouTubeDownloader
+
+    # Initialize components with their configuration (only persistent config, not runtime params)
+    downloader = YouTubeDownloader()
+    transcriber = GeminiTranscriber(api_key=gemini_api_key)
+    aligner = AsyncLattifAI(model_name_or_path=model_name_or_path, device=device, api_key=lattifai_api_key)
+
+    # Initialize agent with components
+    agent = YouTubeSubtitleAgent(
+        downloader=downloader,
+        transcriber=transcriber,
+        aligner=aligner,
+        max_retries=max_retries,
+    )
+
+    # Process the URL
+    result = await agent.process_youtube_url(
+        url=url,
+        output_dir=output_dir,
+        media_format=media_format,
+        force_overwrite=force_overwrite,
+        output_format=output_format,
+        split_sentence=split_sentence,
+        word_level=word_level,
+    )
+
+    # Display results
+    click.echo(colorful.bold_white_on_green('🎉 Workflow completed successfully!'))
+    click.echo()
+    click.echo(colorful.bold_white_on_green('📊 Results:'))
+
+    # Show metadata
+    metadata = result.get('metadata', {})
+    if metadata:
+        click.echo(f'🎬    Title: {metadata.get("title", "Unknown")}')
+        click.echo(f'👤 Uploader: {metadata.get("uploader", "Unknown").strip()}')
+        click.echo(f'⏱️  Duration: {metadata.get("duration", 0)} seconds')
+        click.echo()
+
+    # Show exported files
+    exported_files = result.get('exported_files', {})
+    if exported_files:
+        click.echo(colorful.bold_white_on_green('📄 Generated subtitle files:'))
+        for format_name, file_path in exported_files.items():
+            click.echo(f'  {format_name.upper()}: {file_path}')
+        click.echo()
+
+    # Show subtitle count
+    subtitle_count = result.get('subtitle_count', 0)
+    click.echo(f'📝 Generated {subtitle_count} subtitle segments')
+
+    click.echo(colorful.bold_white_on_green('✨ All done! Your aligned subtitles are ready.'))
+
+
+# Add dependencies check
+def check_dependencies():
+    """Check if required dependencies are installed"""
+    missing_deps = []
+
+    try:
+        from google import genai
+    except ImportError:
+        missing_deps.append('google-genai')
+
+    try:
+        import yt_dlp
+    except ImportError:
+        missing_deps.append('yt-dlp')
+
+    try:
+        from dotenv import load_dotenv
+    except ImportError:
+        missing_deps.append('python-dotenv')
+
+    if missing_deps:
+        click.echo(colorful.red('❌ Missing required dependencies:'))
+        for dep in missing_deps:
+            click.echo(f'  - {dep}')
+        click.echo()
+        click.echo('Install them with:')
+        click.echo(f'  pip install {" ".join(missing_deps)}')
+        return False
+
+    return True
+
+
+# Check dependencies when module is imported
+if not check_dependencies():
+    pass  # Don't exit on import, let the command handle it
+
+
+if __name__ == '__main__':
+    import os
+
+    asyncio.run(
+        _run_youtube_workflow(
+            # url='https://www.youtube.com/watch?v=7nv1snJRCEI',
+            url='https://www.youtube.com/watch?v=DQacCB9tDaw',
+            lattifai_api_key=os.getenv('LATTIFAI_API_KEY'),
+            gemini_api_key=os.getenv('GEMINI_API_KEY', ''),
+            device='mps',
+            model_name_or_path='Lattifai/Lattice-1-Alpha',
+            media_format='mp3',
+            output_format='TextGrid',
+            output_dir='~/Downloads/lattifai_youtube',
+            max_retries=0,
+            split_sentence=True,
+            word_level=False,
+            force_overwrite=False,
+        )
+    )

lattifai/bin/align.py

@@ -1,17 +1,40 @@
+import asyncio
+import os
+from pathlib import Path
+
 import click
 import colorful
 from lhotse.utils import Pathlike
 
 from lattifai.bin.cli_base import cli
+from lattifai.client import AsyncLattifAI, LattifAI
+from lattifai.io import INPUT_SUBTITLE_FORMATS, OUTPUT_SUBTITLE_FORMATS
 
 
 @cli.command()
 @click.option(
     '-F',
     '--input_format',
-    type=click.Choice(['srt', 'vtt', 'ass', 'txt', 'auto'], case_sensitive=False),
+    '--input-format',
+    type=click.Choice(INPUT_SUBTITLE_FORMATS, case_sensitive=False),
     default='auto',
-    help='Input Subtitle format.',
+    help='Input subtitle format.',
+)
+@click.option(
+    '-S',
+    '--split-sentence',
+    '--split_sentence',
+    is_flag=True,
+    default=False,
+    help='Re-segment subtitles by semantics.',
+)
+@click.option(
+    '-W',
+    '--word-level',
+    '--word_level',
+    is_flag=True,
+    default=False,
+    help='Include word-level alignment timestamps in output (for JSON, TextGrid, and subtitle formats).',
 )
 @click.option(
     '-D',
@@ -21,17 +44,22 @@ from lattifai.bin.cli_base import cli
     help='Device to use for inference.',
 )
 @click.option(
-    '-M', '--model_name_or_path', type=str, default='Lattifai/Lattice-1-Alpha', help='Lattifai model name or path'
+    '-M',
+    '--model-name-or-path',
+    '--model_name_or_path',
+    type=str,
+    default='Lattifai/Lattice-1-Alpha',
+    help='Model name or path for alignment.',
 )
 @click.option(
-    '-S',
-    '--split_sentence',
-    is_flag=True,
-    default=False,
-    help='Re-segment subtitles by semantics.',
+    '--api-key',
+    '--api_key',
+    type=str,
+    default=None,
+    help='API key for LattifAI.',
 )
 @click.argument(
-    'input_audio_path',
+    'input_media_path',
     type=click.Path(exists=True, dir_okay=False),
 )
 @click.argument(
@@ -43,24 +71,228 @@ from lattifai.bin.cli_base import cli
     type=click.Path(allow_dash=True),
 )
 def align(
-    input_audio_path: Pathlike,
+    input_media_path: Pathlike,
     input_subtitle_path: Pathlike,
     output_subtitle_path: Pathlike,
     input_format: str = 'auto',
+    split_sentence: bool = False,
+    word_level: bool = False,
     device: str = 'cpu',
     model_name_or_path: str = 'Lattifai/Lattice-1-Alpha',
+    api_key: str = None,
+):
+    """
+    Command used to align media(audio/video) with subtitles
+    """
+    try:
+        client = LattifAI(model_name_or_path=model_name_or_path, device=device, api_key=api_key)
+        client.alignment(
+            input_media_path,
+            input_subtitle_path,
+            format=input_format.lower(),
+            split_sentence=split_sentence,
+            return_details=word_level,
+            output_subtitle_path=output_subtitle_path,
+        )
+        click.echo(colorful.green(f'✅ Alignment completed successfully: {output_subtitle_path}'))
+    except Exception as e:
+        from lattifai.errors import LattifAIError
+
+        # Display error message
+        if isinstance(e, LattifAIError):
+            click.echo(colorful.red('❌ Alignment failed:'))
+            click.echo(e.get_message())
+            # Show support info
+            click.echo(e.get_support_info())
+        else:
+            click.echo(colorful.red(f'❌ Alignment failed: {str(e)}'))
+
+        raise click.ClickException('Alignment failed')
+
+
+@cli.command()
+@click.option(
+    '-M',
+    '--media-format',
+    '--media_format',
+    type=click.Choice(
+        [
+            # Audio formats
+            'mp3',
+            'wav',
+            'm4a',
+            'aac',
+            'flac',
+            'ogg',
+            'opus',
+            'aiff',
+            # Video formats
+            'mp4',
+            'webm',
+            'mkv',
+            'avi',
+            'mov',
+        ],
+        case_sensitive=False,
+    ),
+    default='mp3',
+    help='Media format for YouTube download (audio or video).',
+)
+@click.option(
+    '-S',
+    '--split-sentence',
+    '--split_sentence',
+    is_flag=True,
+    default=False,
+    help='Re-segment subtitles by semantics.',
+)
+@click.option(
+    '-W',
+    '--word-level',
+    '--word_level',
+    is_flag=True,
+    default=False,
+    help='Include word-level alignment timestamps in output (for JSON, TextGrid, and subtitle formats).',
+)
+@click.option(
+    '-O',
+    '--output-dir',
+    '--output_dir',
+    type=click.Path(file_okay=False, dir_okay=True, writable=True),
+    default='.',
+    help='Output directory (default: current directory).',
+)
+@click.option(
+    '-D',
+    '--device',
+    type=click.Choice(['cpu', 'cuda', 'mps'], case_sensitive=False),
+    default='cpu',
+    help='Device to use for inference.',
+)
+@click.option(
+    '-M',
+    '--model-name-or-path',
+    '--model_name_or_path',
+    type=str,
+    default='Lattifai/Lattice-1-Alpha',
+    help='Model name or path for alignment.',
+)
+@click.option(
+    '--api-key',
+    '--api_key',
+    type=str,
+    default=None,
+    help='API key for LattifAI.',
+)
+@click.option(
+    '--gemini-api-key',
+    '--gemini_api_key',
+    type=str,
+    default=None,
+    help='Gemini API key for transcription fallback when subtitles are unavailable.',
+)
+@click.option(
+    '-F',
+    '--output-format',
+    '--output_format',
+    type=click.Choice(OUTPUT_SUBTITLE_FORMATS, case_sensitive=False),
+    default='vtt',
+    help='Subtitle output format.',
+)
+@click.argument(
+    'yt_url',
+    type=str,
+)
+def youtube(
+    yt_url: str,
+    media_format: str = 'mp3',
     split_sentence: bool = False,
+    word_level: bool = False,
+    output_dir: str = '.',
+    device: str = 'cpu',
+    model_name_or_path: str = 'Lattifai/Lattice-1-Alpha',
+    api_key: str = None,
+    gemini_api_key: str = None,
+    output_format: str = 'vtt',
 ):
     """
-    Command used to align audio with subtitles
+    Download media and subtitles from YouTube for further alignment.
     """
-    from lattifai import LattifAI
-
-    client = LattifAI(model_name_or_path=model_name_or_path, device=device)
-    client.alignment(
-        input_audio_path,
-        input_subtitle_path,
-        format=input_format.lower(),
-        split_sentence=split_sentence,
-        output_subtitle_path=output_subtitle_path,
-    )
+    from lattifai.workflows.gemini import GeminiTranscriber
+    from lattifai.workflows.youtube import YouTubeDownloader, YouTubeSubtitleAgent
+
+    # 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)
+        downloader = YouTubeDownloader()
+        transcriber = GeminiTranscriber(api_key=gemini_key)
+        aligner = AsyncLattifAI(api_key=api_key, model_name_or_path=model_name_or_path, device=device)
+
+        # Create agent with initialized components
+        agent = YouTubeSubtitleAgent(
+            downloader=downloader,
+            transcriber=transcriber,
+            aligner=aligner,
+            max_retries=0,
+        )
+
+        result = await agent.process_youtube_url(
+            url=yt_url,
+            output_dir=output_dir,
+            media_format=media_format,
+            force_overwrite=False,
+            output_format=output_format,
+            split_sentence=split_sentence,
+            word_level=word_level,
+        )
+        return result
+
+    try:
+        result = asyncio.run(_process())
+
+        # Display results
+        click.echo(colorful.green('✅ Processing completed!'))
+        click.echo()
+
+        # Show metadata
+        metadata = result.get('metadata', {})
+        if metadata:
+            click.echo(f'🎬    Title: {metadata.get("title", "Unknown")}')
+            click.echo(f'⏱️  Duration: {metadata.get("duration", 0)} seconds')
+            click.echo()
+
+        # Show exported files
+        exported_files = result.get('exported_files', {})
+        if exported_files:
+            click.echo(colorful.green('📄 Generated subtitle files:'))
+            for format_name, file_path in exported_files.items():
+                click.echo(f'  {format_name}: {file_path}')
+            click.echo()
+
+        # Show subtitle count
+        subtitle_count = result.get('subtitle_count', 0)
+        click.echo(f'📝 Generated {subtitle_count} subtitle segments')
+
+    except Exception as e:
+        from lattifai.errors import LattifAIError
+
+        # Extract error message without support info (to avoid duplication)
+        if isinstance(e, LattifAIError):
+            # Use the get_message() method which includes proper formatting
+            click.echo(colorful.red('❌ Failed to process YouTube URL:'))
+            click.echo(e.get_message())
+            # Show support info once at the end
+            click.echo(e.get_support_info())
+        else:
+            click.echo(colorful.red(f'❌ Failed to process YouTube URL: {str(e)}'))
+
+        raise click.ClickException('Processing failed')

lattifai/bin/cli_base.py

@@ -17,3 +17,8 @@ def cli():
         format='%(asctime)s %(levelname)s [%(filename)s:%(lineno)d] %(message)s',
         level=logging.INFO,
     )
+
+    import os
+
+    os.environ['KMP_DUPLICATE_LIB_OK'] = 'TRUE'
+    os.environ['TOKENIZERS_PARALLELISM'] = 'FALSE'