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

lattifai/bin/subtitle.py

@@ -1,12 +1,16 @@
+import asyncio
+from pathlib import Path
+
 import click
 from lhotse.utils import Pathlike
 
 from lattifai.bin.cli_base import cli
+from lattifai.io import SUBTITLE_FORMATS
 
 
 @cli.group()
 def subtitle():
-    """Group of commands used to convert subtitle format."""
+    """Commands for subtitle format conversion and management."""
     pass
 
 
@@ -26,7 +30,181 @@ def convert(
     """
     Convert subtitle file to another format.
     """
-    import pysubs2
+    if str(output_subtitle_path).lower().endswith('.TextGrid'.lower()):
+        from lattifai.io import SubtitleIO
+
+        alignments = SubtitleIO.read(input_subtitle_path)
+        SubtitleIO.write(alignments, output_subtitle_path)
+    else:
+        import pysubs2
+
+        subtitle = pysubs2.load(input_subtitle_path)
+
+        subtitle.save(output_subtitle_path)
+
+
+@subtitle.command()
+@click.argument('url', type=str, required=True)
+@click.option(
+    '--output-dir',
+    '--output_dir',
+    '-o',
+    type=click.Path(file_okay=False, dir_okay=True),
+    default='.',
+    help='Output directory for downloaded subtitle files (default: current directory).',
+)
+@click.option(
+    '--output-format',
+    '--output_format',
+    '-f',
+    type=click.Choice(SUBTITLE_FORMATS + ['best'], case_sensitive=False),
+    default='best',
+    help='Preferred subtitle format to download (default: best available).',
+)
+@click.option('--force-overwrite', '-F', is_flag=True, help='Overwrite existing files without prompting.')
+@click.option(
+    '--lang',
+    '-l',
+    '-L',
+    '--subtitle-lang',
+    '--subtitle_lang',
+    type=str,
+    help='Specific subtitle language/track to download (e.g., "en").',
+)
+def download(
+    url: str,
+    output_dir: str,
+    output_format: str,
+    force_overwrite: bool,
+    lang: str,
+):
+    """
+    Download subtitles from YouTube URL using yt-dlp.
+
+    URL should be a valid YouTube URL (e.g., https://www.youtube.com/watch?v=VIDEO_ID).
+    """
+    # Import here to avoid circular imports and keep startup fast
+    from lattifai.workflows.youtube import YouTubeDownloader
+
+    # Validate URL format
+    if not _is_valid_youtube_url(url):
+        click.echo(f'Error: Invalid YouTube URL format: {url}', err=True)
+        click.echo('Please provide a valid YouTube URL (e.g., https://www.youtube.com/watch?v=VIDEO_ID)', err=True)
+        raise click.Abort()
+
+    # Convert relative path to absolute
+    output_path = Path(output_dir).resolve()
+
+    # Create output directory if it doesn't exist
+    output_path.mkdir(parents=True, exist_ok=True)
+
+    click.echo(f'Downloading subtitles from: {url}')
+    click.echo(f'          Output directory: {output_path}')
+    click.echo(f'         Preferred format: {output_format}')
+    if lang:
+        click.echo(f'       Subtitle language: {lang}')
+    else:
+        click.echo('       Subtitle language: All available')
+
+    # Initialize downloader and download
+    downloader = YouTubeDownloader()
+
+    async def download_subtitles():
+        try:
+            result = await downloader.download_subtitles(
+                url=url,
+                output_dir=str(output_path),
+                force_overwrite=force_overwrite,
+                subtitle_lang=lang,
+            )
+
+            if result:
+                click.echo('✅ Subtitles downloaded successfully!')
+                return result
+            else:
+                click.echo('⚠️  No subtitles available for this video')
+                return None
+
+        except Exception as e:
+            click.echo(f'❌ Error downloading subtitles: {str(e)}', err=True)
+            raise click.Abort()
+
+    # Run the async function
+    result = asyncio.run(download_subtitles())
+
+    if result:
+        if result == 'gemini':
+            click.echo('✨ Gemini transcription selected (use the agent command to transcribe)')
+        else:
+            click.echo(f'📄 Subtitle file saved to: {result}')
+
+
+@subtitle.command()
+@click.argument('url', type=str, required=True)
+def list_subs(url: str):
+    """
+    List available subtitle tracks for a YouTube video.
+
+    URL should be a valid YouTube URL (e.g., https://www.youtube.com/watch?v=VIDEO_ID)
+    """
+    # Import here to avoid circular imports and keep startup fast
+    from lattifai.workflows.youtube import YouTubeDownloader
+
+    # Validate URL format
+    if not _is_valid_youtube_url(url):
+        click.echo(f'Error: Invalid YouTube URL format: {url}', err=True)
+        click.echo('Please provide a valid YouTube URL (e.g., https://www.youtube.com/watch?v=VIDEO_ID)', err=True)
+        raise click.Abort()
+
+    click.echo(f'Listing available subtitles for: {url}')
+
+    # Initialize downloader
+    downloader = YouTubeDownloader()
+
+    async def list_available_subtitles():
+        try:
+            result = await downloader.list_available_subtitles(url)
+
+            if result:
+                click.echo('📋 Available subtitle tracks:')
+                for subtitle_info in result:
+                    click.echo(f'  🎬 Language: {subtitle_info["language"]} - {subtitle_info["name"]}')
+                    click.echo(f'     📄 Formats: {", ".join(subtitle_info["formats"])}')
+                    click.echo()
+
+                click.echo('💡 To download a specific track, use:')
+                click.echo(f'   lattifai subtitle download "{url}" --lang <language_code>')
+                click.echo('   Example: lattifai subtitle download "{}" --lang en-JkeT_87f4cc'.format(url))
+            else:
+                click.echo('⚠️  No subtitles available for this video')
+
+        except Exception as e:
+            click.echo(f'❌ Error listing subtitles: {str(e)}', err=True)
+            raise click.Abort()
+
+    # Run the async function
+    asyncio.run(list_available_subtitles())
+
+
+def _is_valid_youtube_url(url: str) -> bool:
+    """
+    Validate if the URL is a valid YouTube URL format.
+
+    Supports various YouTube URL formats:
+    - https://www.youtube.com/watch?v=VIDEO_ID
+    - https://youtu.be/VIDEO_ID
+    - https://www.youtube.com/shorts/VIDEO_ID
+    - https://m.youtube.com/watch?v=VIDEO_ID
+    """
+    import re
+
+    patterns = [
+        r'(?:youtube\.com/watch\?v=|youtu\.be/|youtube\.com/shorts/)([a-zA-Z0-9_-]{11})',
+        r'youtube\.com/embed/([a-zA-Z0-9_-]{11})',
+        r'youtube\.com/v/([a-zA-Z0-9_-]{11})',
+    ]
 
-    subtitle = pysubs2.load(input_subtitle_path)
-    subtitle.save(output_subtitle_path)
+    for pattern in patterns:
+        if re.search(pattern, url):
+            return True
+    return False

lattifai/client.py

@@ -1,9 +1,8 @@
 """LattifAI client implementation."""
 
-import logging
+import asyncio
 import os
-from pathlib import Path
-from typing import Any, Awaitable, BinaryIO, Callable, Dict, Optional, Union
+from typing import Dict, List, Optional, Tuple, Union
 
 import colorful
 from dotenv import load_dotenv
@@ -16,13 +15,12 @@ from lattifai.errors import (
     LatticeDecodingError,
     LatticeEncodingError,
     LattifAIError,
-    ModelLoadError,
     SubtitleProcessingError,
     handle_exception,
 )
-from lattifai.io import SubtitleFormat, SubtitleIO
-from lattifai.tokenizer import LatticeTokenizer
-from lattifai.workers import Lattice1AlphaWorker
+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()
 
@@ -62,47 +60,12 @@ class LattifAI(SyncAPIClient):
             default_headers=default_headers,
         )
 
-        # Initialize components
-        if not Path(model_name_or_path).exists():
-            from huggingface_hub import snapshot_download
-            from huggingface_hub.errors import LocalEntryNotFoundError
+        model_path = _resolve_model_path(model_name_or_path)
+        device = _select_device(device)
 
-            try:
-                model_path = snapshot_download(repo_id=model_name_or_path, repo_type='model')
-            except LocalEntryNotFoundError:
-                try:
-                    os.environ['HF_ENDPOINT'] = 'https://hf-mirror.com'
-                    model_path = snapshot_download(repo_id=model_name_or_path, repo_type='model')
-                except Exception as e:
-                    raise ModelLoadError(model_name_or_path, original_error=e)
-            except Exception as e:
-                raise ModelLoadError(model_name_or_path, original_error=e)
-        else:
-            model_path = model_name_or_path
-
-        # device setup
-        if device is None:
-            import torch
-
-            device = 'cpu'
-            if torch.backends.mps.is_available():
-                device = 'mps'
-            elif torch.cuda.is_available():
-                device = 'cuda'
-
-        try:
-            self.tokenizer = LatticeTokenizer.from_pretrained(
-                client_wrapper=self,
-                model_path=model_path,
-                device=device,
-            )
-        except Exception as e:
-            raise ModelLoadError(f'tokenizer from {model_path}', original_error=e)
-
-        try:
-            self.worker = Lattice1AlphaWorker(model_path, device=device, num_threads=8)
-        except Exception as e:
-            raise ModelLoadError(f'worker from {model_path}', original_error=e)
+        self.tokenizer = _load_tokenizer(self, model_path, device)
+        self.worker = _load_worker(model_path, device)
+        self.device = device
 
     def alignment(
         self,
@@ -110,19 +73,23 @@ class LattifAI(SyncAPIClient):
         subtitle: Pathlike,
         format: Optional[SubtitleFormat] = None,
         split_sentence: bool = False,
+        return_details: bool = False,
         output_subtitle_path: Optional[Pathlike] = None,
-    ) -> str:
+    ) -> Tuple[List[Supervision], Optional[Pathlike]]:
         """Perform alignment on audio and subtitle/text.
 
         Args:
             audio: Audio file path
             subtitle: Subtitle/Text to align with audio
-            format: Output format (srt, vtt, ass, txt)
-            split_sentence: Whether to split sentences during processing
-            output_subtitle_path: Path to save output file
+            format: Input subtitle format (srt, vtt, ass, txt). Auto-detected if None
+            split_sentence: Enable intelligent sentence re-splitting based on punctuation semantics
+            return_details: Return word-level alignment details in Supervision.alignment field
+            output_subtitle_path: Output path for aligned subtitle (optional)
 
         Returns:
-            Aligned subtitles in specified format
+            Tuple containing:
+                - List of aligned Supervision objects with timing information
+                - Output subtitle path (if output_subtitle_path was provided)
 
         Raises:
             SubtitleProcessingError: If subtitle file cannot be parsed
@@ -144,19 +111,21 @@ class LattifAI(SyncAPIClient):
                 )
 
             # step2: make lattice by call Lattifai API
-            print(colorful.cyan('🔗 Step 2: Creating lattice graph from text'))
+            print(colorful.cyan('🔗 Step 2: Creating lattice graph from segments'))
             try:
-                lattice_id, lattice_graph = self.tokenizer.tokenize(supervisions, split_sentence=split_sentence)
+                supervisions, lattice_id, lattice_graph = self.tokenizer.tokenize(
+                    supervisions, split_sentence=split_sentence
+                )
                 print(colorful.green(f'         ✓ Generated lattice graph with ID: {lattice_id}'))
             except Exception as e:
                 text_content = ' '.join([sup.text for sup in supervisions]) if supervisions else ''
                 raise LatticeEncodingError(text_content, original_error=e)
 
-            # step3: align audio with text
-            print(colorful.cyan(f'🎵 Step 3: Performing alignment on audio file: {audio}'))
+            # step3: search lattice graph with audio
+            print(colorful.cyan(f'🔍 Step 3: Searching lattice graph with audio: {audio}'))
             try:
                 lattice_results = self.worker.alignment(audio, lattice_graph)
-                print(colorful.green('         ✓ Alignment completed successfully'))
+                print(colorful.green('         ✓ Lattice search completed'))
             except Exception as e:
                 raise AlignmentError(
                     f'Audio alignment failed for {audio}',
@@ -165,11 +134,16 @@ class LattifAI(SyncAPIClient):
                     context={'original_error': str(e)},
                 )
 
-            # step4: decode the lattice paths
-            print(colorful.cyan('🔍 Step 4: Decoding lattice paths to final alignments'))
+            # step4: decode lattice results to aligned segments
+            print(colorful.cyan('🎯 Step 4: Decoding lattice results to aligned segments'))
             try:
-                alignments = self.tokenizer.detokenize(lattice_id, lattice_results)
-                print(colorful.green(f'         ✓ Decoded {len(alignments)} aligned segments'))
+                alignments = self.tokenizer.detokenize(
+                    lattice_id, lattice_results, supervisions=supervisions, return_details=return_details
+                )
+                print(colorful.green(f'         ✓ Successfully aligned {len(alignments)} segments'))
+            except LatticeDecodingError as e:
+                print(colorful.red('         x Failed to decode lattice alignment results'))
+                raise e
             except Exception as e:
                 print(colorful.red('         x Failed to decode lattice alignment results'))
                 raise LatticeDecodingError(lattice_id, original_error=e)
@@ -185,8 +159,7 @@ class LattifAI(SyncAPIClient):
                         subtitle_path=str(output_subtitle_path),
                         context={'original_error': str(e)},
                     )
-
-            return output_subtitle_path or alignments
+            return (alignments, output_subtitle_path)
 
         except (SubtitleProcessingError, LatticeEncodingError, AlignmentError, LatticeDecodingError):
             # Re-raise our specific errors as-is
@@ -201,15 +174,142 @@ class LattifAI(SyncAPIClient):
             )
 
 
+class AsyncLattifAI(AsyncAPIClient):
+    """Asynchronous LattifAI client."""
+
+    def __init__(
+        self,
+        *,
+        api_key: Optional[str] = None,
+        model_name_or_path: str = 'Lattifai/Lattice-1-Alpha',
+        device: Optional[str] = None,
+        base_url: Optional[str] = None,
+        timeout: Union[float, int] = 120.0,
+        max_retries: int = 2,
+        default_headers: Optional[Dict[str, str]] = None,
+    ) -> None:
+        if api_key is None:
+            api_key = os.environ.get('LATTIFAI_API_KEY')
+        if api_key is None:
+            raise ConfigurationError(
+                'The api_key client option must be set either by passing api_key to the client '
+                'or by setting the LATTIFAI_API_KEY environment variable'
+            )
+
+        if base_url is None:
+            base_url = os.environ.get('LATTIFAI_BASE_URL')
+        if not base_url:
+            base_url = 'https://api.lattifai.com/v1'
+
+        super().__init__(
+            api_key=api_key,
+            base_url=base_url,
+            timeout=timeout,
+            max_retries=max_retries,
+            default_headers=default_headers,
+        )
+
+        model_path = _resolve_model_path(model_name_or_path)
+        device = _select_device(device)
+
+        self.tokenizer = _load_tokenizer(self, model_path, device, tokenizer_cls=AsyncLatticeTokenizer)
+        self.worker = _load_worker(model_path, device)
+        self.device = device
+
+    async def alignment(
+        self,
+        audio: Pathlike,
+        subtitle: Pathlike,
+        format: Optional[SubtitleFormat] = None,
+        split_sentence: bool = False,
+        return_details: bool = False,
+        output_subtitle_path: Optional[Pathlike] = None,
+    ) -> Tuple[List[Supervision], Optional[Pathlike]]:
+        try:
+            print(colorful.cyan(f'📖 Step 1: Reading subtitle file from {subtitle}'))
+            try:
+                supervisions = await asyncio.to_thread(SubtitleIO.read, subtitle, format=format)
+                print(colorful.green(f'         ✓ Parsed {len(supervisions)} subtitle segments'))
+            except Exception as e:
+                raise SubtitleProcessingError(
+                    f'Failed to parse subtitle file: {subtitle}',
+                    subtitle_path=str(subtitle),
+                    context={'original_error': str(e)},
+                )
+
+            print(colorful.cyan('🔗 Step 2: Creating lattice graph from segments'))
+            try:
+                supervisions, lattice_id, lattice_graph = await self.tokenizer.tokenize(
+                    supervisions,
+                    split_sentence=split_sentence,
+                )
+                print(colorful.green(f'         ✓ Generated lattice graph with ID: {lattice_id}'))
+            except Exception as e:
+                text_content = ' '.join([sup.text for sup in supervisions]) if supervisions else ''
+                raise LatticeEncodingError(text_content, original_error=e)
+
+            print(colorful.cyan(f'🔍 Step 3: Searching lattice graph with audio: {audio}'))
+            try:
+                lattice_results = await asyncio.to_thread(self.worker.alignment, audio, lattice_graph)
+                print(colorful.green('         ✓ Lattice search completed'))
+            except Exception as e:
+                raise AlignmentError(
+                    f'Audio alignment failed for {audio}',
+                    audio_path=str(audio),
+                    subtitle_path=str(subtitle),
+                    context={'original_error': str(e)},
+                )
+
+            print(colorful.cyan('🎯 Step 4: Decoding lattice results to aligned segments'))
+            try:
+                alignments = await self.tokenizer.detokenize(
+                    lattice_id, lattice_results, supervisions=supervisions, return_details=return_details
+                )
+                print(colorful.green(f'         ✓ Successfully aligned {len(alignments)} segments'))
+            except LatticeDecodingError as e:
+                print(colorful.red('         x Failed to decode lattice alignment results'))
+                raise e
+            except Exception as e:
+                print(colorful.red('         x Failed to decode lattice alignment results'))
+                raise LatticeDecodingError(lattice_id, original_error=e)
+
+            if output_subtitle_path:
+                try:
+                    await asyncio.to_thread(SubtitleIO.write, alignments, output_subtitle_path)
+                    print(colorful.green(f'🎉🎉🎉🎉🎉 Subtitle file written to: {output_subtitle_path}'))
+                except Exception as e:
+                    raise SubtitleProcessingError(
+                        f'Failed to write output file: {output_subtitle_path}',
+                        subtitle_path=str(output_subtitle_path),
+                        context={'original_error': str(e)},
+                    )
+
+            return (alignments, output_subtitle_path)
+
+        except (SubtitleProcessingError, LatticeEncodingError, AlignmentError, LatticeDecodingError):
+            raise
+        except Exception as e:
+            raise AlignmentError(
+                'Unexpected error during alignment process',
+                audio_path=str(audio),
+                subtitle_path=str(subtitle),
+                context={'original_error': str(e), 'error_type': e.__class__.__name__},
+            )
+
+
 if __name__ == '__main__':
     client = LattifAI()
     import sys
 
-    if len(sys.argv) == 4:
-        audio, subtitle, output = sys.argv[1:]
+    if len(sys.argv) == 5:
+        audio, subtitle, output, split_sentence = sys.argv[1:]
+        split_sentence = split_sentence.lower() in ('true', '1', 'yes')
     else:
         audio = 'tests/data/SA1.wav'
         subtitle = 'tests/data/SA1.TXT'
         output = None
+        split_sentence = False
 
-    alignments = client.alignment(audio, subtitle, output_subtitle_path=output, split_sentence=True)
+    (alignments, output_subtitle_path) = client.alignment(
+        audio, subtitle, output_subtitle_path=output, split_sentence=split_sentence, return_details=True
+    )

lattifai/errors.py

@@ -1,11 +1,26 @@
 """Error handling and exception classes for LattifAI SDK."""
 
-import sys
 import traceback
 from typing import Any, Dict, Optional
 
 import colorful
 
+# Error help messages
+LATTICE_DECODING_FAILURE_HELP = (
+    'Failed to decode lattice alignment. Possible reasons:\n\n'
+    '1) Audio and text content mismatch:\n'
+    '   - The transcript/subtitle does not accurately match the audio content\n'
+    '   - Text may be from a different version or section of the audio\n'
+    '   ⚠️  Note: Gemini transcription may occasionally skip large segments of audio, causing alignment failures.\n'
+    '       We will detect and fix this issue in the next version.\n\n'
+    '2) Unsupported audio type:\n'
+    '   - Singing is not yet supported, this will be optimized in future versions\n\n'
+    '💡 Troubleshooting tips:\n'
+    '   • Verify the transcript matches the audio by listening to a few segments\n'
+    '   • For YouTube videos, manually check if auto-generated transcript are accurate\n'
+    '       • Consider using a different transcription source if Gemini results are incomplete'
+)
+
 
 class LattifAIError(Exception):
     """Base exception for LattifAI errors."""
@@ -26,7 +41,7 @@ class LattifAIError(Exception):
     def get_support_info(self) -> str:
         """Get support information for users."""
         return (
-            f'\n\n{colorful.green("🔧 Need help? Here are two ways to get support:")}\n'
+            f'\n{colorful.green("🔧 Need help? Here are two ways to get support:")}\n'
             f'   1. 📝 Create a GitHub issue: {colorful.green("https://github.com/lattifai/lattifai-python/issues")}\n'
             '      Please include:\n'
             '      - Your audio file format and duration\n'
@@ -36,13 +51,21 @@ class LattifAIError(Exception):
             '      Our team and community can help you troubleshoot\n'
         )
 
-    def __str__(self) -> str:
-        """Return formatted error message with support information."""
+    def get_message(self) -> str:
+        """Return formatted error message without support information."""
         base_message = f'{colorful.red(f"[{self.error_code}] {self.message}")}'
         if self.context:
             context_str = f'\n{colorful.yellow("Context:")} ' + ', '.join(f'{k}={v}' for k, v in self.context.items())
             base_message += context_str
-        return base_message + self.get_support_info()
+        return base_message
+
+    def __str__(self) -> str:
+        """Return formatted error message without support information.
+
+        Note: Support info should be displayed explicitly at the CLI level,
+        not automatically appended to avoid duplication when errors are re-raised.
+        """
+        return self.get_message()
 
 
 class AudioProcessingError(LattifAIError):
@@ -142,14 +165,29 @@ class LatticeDecodingError(AlignmentError):
 
     def __init__(self, lattice_id: str, original_error: Optional[Exception] = None, **kwargs):
         message = f'Failed to decode lattice alignment results for lattice ID: {colorful.red(lattice_id)}'
-        if original_error:
+
+        # Don't duplicate the help message if it's already in original_error
+        if original_error and str(original_error) != LATTICE_DECODING_FAILURE_HELP:
             message += f' - {colorful.red(str(original_error))}'
 
         context = kwargs.get('context', {})
-        context.update({'lattice_id': lattice_id, 'original_error': str(original_error) if original_error else None})
+        # Don't store the entire help message in context to avoid duplication
+        if original_error and str(original_error) != LATTICE_DECODING_FAILURE_HELP:
+            context['original_error'] = str(original_error)
+        context['lattice_id'] = lattice_id
         kwargs['context'] = context
         super().__init__(message, **kwargs)
 
+    def get_message(self) -> str:
+        """Return formatted error message with help text."""
+        base_message = f'{colorful.red(f"[{self.error_code}]")} {self.message}'
+        if self.context and self.context.get('lattice_id'):
+            # Only show essential context (lattice_id), not the duplicated help message
+            base_message += f'\n{colorful.yellow("Lattice ID:")} {self.context["lattice_id"]}'
+        # Append help message once at the end
+        base_message += f'\n\n{colorful.yellow(LATTICE_DECODING_FAILURE_HELP)}'
+        return base_message
+
 
 class ModelLoadError(LattifAIError):
     """Error loading AI model."""

lattifai/io/__init__.py

@@ -2,11 +2,31 @@ from typing import List, Optional
 
 from lhotse.utils import Pathlike
 
+from .gemini_reader import GeminiReader, GeminiSegment
+from .gemini_writer import GeminiWriter
 from .reader import SubtitleFormat, SubtitleReader
 from .supervision import Supervision
+from .utils import (
+    ALL_SUBTITLE_FORMATS,
+    INPUT_SUBTITLE_FORMATS,
+    OUTPUT_SUBTITLE_FORMATS,
+    SUBTITLE_FORMATS,
+)
 from .writer import SubtitleWriter
 
-__all__ = ['SubtitleReader', 'SubtitleWriter', 'SubtitleIO', 'Supervision']
+__all__ = [
+    'SubtitleReader',
+    'SubtitleWriter',
+    'SubtitleIO',
+    'Supervision',
+    'GeminiReader',
+    'GeminiWriter',
+    'GeminiSegment',
+    'SUBTITLE_FORMATS',
+    'INPUT_SUBTITLE_FORMATS',
+    'OUTPUT_SUBTITLE_FORMATS',
+    'ALL_SUBTITLE_FORMATS',
+]
 
 
 class SubtitleIO: