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

lattifai/__init__.py

@@ -2,7 +2,21 @@ import os
 import sys
 import warnings
 
-from .base_client import LattifAIError
+from .errors import (
+    AlignmentError,
+    APIError,
+    AudioFormatError,
+    AudioLoadError,
+    AudioProcessingError,
+    ConfigurationError,
+    DependencyError,
+    LatticeDecodingError,
+    LatticeEncodingError,
+    LattifAIError,
+    ModelLoadError,
+    SubtitleParseError,
+    SubtitleProcessingError,
+)
 from .io import SubtitleIO
 
 try:
@@ -53,6 +67,18 @@ def __getattr__(name):
 __all__ = [
     'LattifAI',  # noqa: F822
     'LattifAIError',
+    'AudioProcessingError',
+    'AudioLoadError',
+    'AudioFormatError',
+    'SubtitleProcessingError',
+    'SubtitleParseError',
+    'AlignmentError',
+    'LatticeEncodingError',
+    'LatticeDecodingError',
+    'ModelLoadError',
+    'DependencyError',
+    'APIError',
+    'ConfigurationError',
     'SubtitleIO',
     '__version__',
 ]

lattifai/base_client.py

@@ -6,11 +6,8 @@ from typing import Any, Awaitable, Callable, Dict, Optional, Union  # noqa: F401
 
 import httpx
 
-
-class LattifAIError(Exception):
-    """Base exception for LattifAI errors."""
-
-    pass
+# Import from errors module for consistency
+from .errors import APIError, ConfigurationError, LattifAIError
 
 
 class BaseAPIClient(ABC):
@@ -28,7 +25,7 @@ class BaseAPIClient(ABC):
         if api_key is None:
             api_key = os.environ.get('LATTIFAI_API_KEY')
         if api_key is None:
-            raise LattifAIError(
+            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'
             )

lattifai/client.py

@@ -9,7 +9,17 @@ import colorful
 from dotenv import load_dotenv
 from lhotse.utils import Pathlike
 
-from lattifai.base_client import AsyncAPIClient, LattifAIError, SyncAPIClient
+from lattifai.base_client import AsyncAPIClient, SyncAPIClient
+from lattifai.errors import (
+    AlignmentError,
+    ConfigurationError,
+    LatticeDecodingError,
+    LatticeEncodingError,
+    LattifAIError,
+    ModelLoadError,
+    SubtitleProcessingError,
+    handle_exception,
+)
 from lattifai.io import SubtitleFormat, SubtitleIO
 from lattifai.tokenizer import LatticeTokenizer
 from lattifai.workers import Lattice1AlphaWorker
@@ -34,7 +44,7 @@ class LattifAI(SyncAPIClient):
         if api_key is None:
             api_key = os.environ.get('LATTIFAI_API_KEY')
         if api_key is None:
-            raise LattifAIError(
+            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'
             )
@@ -60,8 +70,13 @@ class LattifAI(SyncAPIClient):
             try:
                 model_path = snapshot_download(repo_id=model_name_or_path, repo_type='model')
             except LocalEntryNotFoundError:
-                os.environ['HF_ENDPOINT'] = 'https://hf-mirror.com'
-                model_path = snapshot_download(repo_id=model_name_or_path, repo_type='model')
+                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
 
@@ -75,12 +90,19 @@ class LattifAI(SyncAPIClient):
             elif torch.cuda.is_available():
                 device = 'cuda'
 
-        self.tokenizer = LatticeTokenizer.from_pretrained(
-            client_wrapper=self,
-            model_path=model_path,
-            device=device,
-        )
-        self.worker = Lattice1AlphaWorker(model_path, device=device, num_threads=8)
+        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)
 
     def alignment(
         self,
@@ -95,37 +117,88 @@ class LattifAI(SyncAPIClient):
         Args:
             audio: Audio file path
             subtitle: Subtitle/Text to align with audio
-            export_format: Output format (srt, vtt, ass, txt)
+            format: Output format (srt, vtt, ass, txt)
+            split_sentence: Whether to split sentences during processing
+            output_subtitle_path: Path to save output file
 
         Returns:
             Aligned subtitles in specified format
+
+        Raises:
+            SubtitleProcessingError: If subtitle file cannot be parsed
+            LatticeEncodingError: If lattice graph generation fails
+            AlignmentError: If audio alignment fails
+            LatticeDecodingError: If lattice decoding fails
         """
-        # step1: parse text or subtitles
-        print(colorful.cyan(f'📖 Step 1: Reading subtitle file from {subtitle}'))
-        supervisions = SubtitleIO.read(subtitle, format=format)
-        print(colorful.green(f'         ✓ Parsed {len(supervisions)} subtitle segments'))
-
-        # step2: make lattice by call Lattifai API
-        print(colorful.cyan('🔗 Step 2: Creating lattice graph from text'))
-        lattice_id, lattice_graph = self.tokenizer.tokenize(supervisions, split_sentence=split_sentence)
-        print(colorful.green(f'         ✓ Generated lattice graph with ID: {lattice_id}'))
-
-        # step3: align audio with text
-        print(colorful.cyan(f'🎵 Step 3: Performing alignment on audio file: {audio}'))
-        lattice_results = self.worker.alignment(audio, lattice_graph)
-        print(colorful.green('         ✓ Alignment completed successfully'))
-
-        # step4: decode the lattice paths
-        print(colorful.cyan('🔍 Step 4: Decoding lattice paths to final alignments'))
-        alignments = self.tokenizer.detokenize(lattice_id, lattice_results)
-        print(colorful.green(f'         ✓ Decoded {len(alignments)} aligned segments'))
-
-        # step5: export alignments to target format
-        if output_subtitle_path:
-            SubtitleIO.write(alignments, output_path=output_subtitle_path)
-            print(colorful.green(f'🎉🎉🎉🎉🎉 Subtitle file written to: {output_subtitle_path}'))
-
-        return output_subtitle_path or alignments
+        try:
+            # step1: parse text or subtitles
+            print(colorful.cyan(f'📖 Step 1: Reading subtitle file from {subtitle}'))
+            try:
+                supervisions = 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)},
+                )
+
+            # step2: make lattice by call Lattifai API
+            print(colorful.cyan('🔗 Step 2: Creating lattice graph from text'))
+            try:
+                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}'))
+            try:
+                lattice_results = self.worker.alignment(audio, lattice_graph)
+                print(colorful.green('         ✓ Alignment completed successfully'))
+            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)},
+                )
+
+            # step4: decode the lattice paths
+            print(colorful.cyan('🔍 Step 4: Decoding lattice paths to final alignments'))
+            try:
+                alignments = self.tokenizer.detokenize(lattice_id, lattice_results)
+                print(colorful.green(f'         ✓ Decoded {len(alignments)} aligned segments'))
+            except Exception as e:
+                print(colorful.red('         x Failed to decode lattice alignment results'))
+                raise LatticeDecodingError(lattice_id, original_error=e)
+
+            # step5: export alignments to target format
+            if output_subtitle_path:
+                try:
+                    SubtitleIO.write(alignments, output_path=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 output_subtitle_path or alignments
+
+        except (SubtitleProcessingError, LatticeEncodingError, AlignmentError, LatticeDecodingError):
+            # Re-raise our specific errors as-is
+            raise
+        except Exception as e:
+            # Catch any unexpected errors and wrap them
+            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__':

lattifai/errors.py

@@ -0,0 +1,219 @@
+"""Error handling and exception classes for LattifAI SDK."""
+
+import sys
+import traceback
+from typing import Any, Dict, Optional
+
+import colorful
+
+
+class LattifAIError(Exception):
+    """Base exception for LattifAI errors."""
+
+    def __init__(self, message: str, error_code: Optional[str] = None, context: Optional[Dict[str, Any]] = None):
+        """Initialize LattifAI error.
+
+        Args:
+            message: Error message
+            error_code: Optional error code for categorization
+            context: Optional context information about the error
+        """
+        super().__init__(message)
+        self.message = message
+        self.error_code = error_code or self.__class__.__name__
+        self.context = context or {}
+
+    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'   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'
+            "      - The text/subtitle content you're trying to align\n"
+            '      - This error message and stack trace\n'
+            f'   2. 💬 Join our Discord community: {colorful.green("https://discord.gg/vzmTzzZgNu")}\n'
+            '      Our team and community can help you troubleshoot\n'
+        )
+
+    def __str__(self) -> str:
+        """Return formatted error message with 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()
+
+
+class AudioProcessingError(LattifAIError):
+    """Error during audio processing operations."""
+
+    def __init__(self, message: str, audio_path: Optional[str] = None, **kwargs):
+        context = kwargs.get('context', {})
+        if audio_path:
+            context['audio_path'] = audio_path
+        kwargs['context'] = context
+        super().__init__(message, **kwargs)
+
+
+class AudioLoadError(AudioProcessingError):
+    """Error loading or reading audio file."""
+
+    def __init__(self, audio_path: str, original_error: Optional[Exception] = None, **kwargs):
+        message = f'Failed to load audio file: {colorful.red(audio_path)}'
+        if original_error:
+            message += f' - {colorful.red(str(original_error))}'
+
+        context = kwargs.get('context', {})
+        context.update({'audio_path': audio_path, 'original_error': str(original_error) if original_error else None})
+        kwargs['context'] = context
+
+        super().__init__(message, audio_path=audio_path, **kwargs)
+
+
+class AudioFormatError(AudioProcessingError):
+    """Error with audio format or codec."""
+
+    def __init__(self, audio_path: str, format_issue: str, **kwargs):
+        message = f'Audio format error for {colorful.red(audio_path)}: {colorful.red(format_issue)}'
+        context = kwargs.get('context', {})
+        context.update({'audio_path': audio_path, 'format_issue': format_issue})
+        kwargs['context'] = context
+        super().__init__(message, audio_path=audio_path, **kwargs)
+
+
+class SubtitleProcessingError(LattifAIError):
+    """Error during subtitle/text processing operations."""
+
+    def __init__(self, message: str, subtitle_path: Optional[str] = None, **kwargs):
+        context = kwargs.get('context', {})
+        if subtitle_path:
+            context['subtitle_path'] = subtitle_path
+        kwargs['context'] = context
+        super().__init__(message, **kwargs)
+
+
+class SubtitleParseError(SubtitleProcessingError):
+    """Error parsing subtitle or text file."""
+
+    def __init__(self, subtitle_path: str, parse_issue: str, **kwargs):
+        message = f'Failed to parse subtitle file {subtitle_path}: {parse_issue}'
+        context = kwargs.get('context', {})
+        context.update({'subtitle_path': subtitle_path, 'parse_issue': parse_issue})
+        kwargs['context'] = context
+        super().__init__(message, subtitle_path=subtitle_path, **kwargs)
+
+
+class AlignmentError(LattifAIError):
+    """Error during audio-text alignment process."""
+
+    def __init__(self, message: str, audio_path: Optional[str] = None, subtitle_path: Optional[str] = None, **kwargs):
+        context = kwargs.get('context', {})
+        if audio_path:
+            context['audio_path'] = audio_path
+        if subtitle_path:
+            context['subtitle_path'] = subtitle_path
+        kwargs['context'] = context
+        super().__init__(message, **kwargs)
+
+
+class LatticeEncodingError(AlignmentError):
+    """Error generating lattice graph from text."""
+
+    def __init__(self, text_content: str, original_error: Optional[Exception] = None, **kwargs):
+        message = 'Failed to generate lattice graph from text'
+        if original_error:
+            message += f': {colorful.red(str(original_error))}'
+
+        context = kwargs.get('context', {})
+        context.update(
+            {
+                'text_content_length': len(text_content),
+                'text_preview': text_content[:100] + '...' if len(text_content) > 100 else text_content,
+                'original_error': str(original_error) if original_error else None,
+            }
+        )
+        kwargs['context'] = context
+        super().__init__(message, **kwargs)
+
+
+class LatticeDecodingError(AlignmentError):
+    """Error decoding lattice alignment results."""
+
+    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:
+            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})
+        kwargs['context'] = context
+        super().__init__(message, **kwargs)
+
+
+class ModelLoadError(LattifAIError):
+    """Error loading AI model."""
+
+    def __init__(self, model_name: str, original_error: Optional[Exception] = None, **kwargs):
+        message = f'Failed to load model: {colorful.red(model_name)}'
+        if original_error:
+            message += f' - {colorful.red(str(original_error))}'
+
+        context = kwargs.get('context', {})
+        context.update({'model_name': model_name, 'original_error': str(original_error) if original_error else None})
+        kwargs['context'] = context
+        super().__init__(message, **kwargs)
+
+
+class DependencyError(LattifAIError):
+    """Error with required dependencies."""
+
+    def __init__(self, dependency_name: str, install_command: Optional[str] = None, **kwargs):
+        message = f'Missing required dependency: {colorful.red(dependency_name)}'
+        if install_command:
+            message += f'\nPlease install it using: {colorful.yellow(install_command)}'
+
+        context = kwargs.get('context', {})
+        context.update({'dependency_name': dependency_name, 'install_command': install_command})
+        kwargs['context'] = context
+        super().__init__(message, **kwargs)
+
+
+class APIError(LattifAIError):
+    """Error communicating with LattifAI API."""
+
+    def __init__(self, message: str, status_code: Optional[int] = None, response_text: Optional[str] = None, **kwargs):
+        context = kwargs.get('context', {})
+        context.update({'status_code': status_code, 'response_text': response_text})
+        kwargs['context'] = context
+        super().__init__(message, **kwargs)
+
+
+class ConfigurationError(LattifAIError):
+    """Error with client configuration."""
+
+    def __init__(self, config_issue: str, **kwargs):
+        message = f'Configuration error: {config_issue}'
+        super().__init__(message, **kwargs)
+
+
+def handle_exception(func):
+    """Decorator to handle exceptions and convert them to LattifAI errors."""
+
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except LattifAIError:
+            # Re-raise LattifAI errors as-is
+            raise
+        except Exception as e:
+            # Convert other exceptions to LattifAI errors
+            error_msg = f'Unexpected error in {func.__name__}: {str(e)}'
+            context = {
+                'function': func.__name__,
+                'original_exception': e.__class__.__name__,
+                'traceback': traceback.format_exc(),
+            }
+            raise LattifAIError(error_msg, context=context) from e
+
+    return wrapper

lattifai/tokenizer/tokenizer.py

@@ -271,6 +271,8 @@ class LatticeTokenizer:
         if response.status_code != 200:
             raise Exception(f'Failed to detokenize lattice: {response.text}')
         result = response.json()
+        if not result.get('success'):
+            return Exception('Failed to detokenize the alignment results.')
         # if return_details:
         #     raise NotImplementedError("return_details is not implemented yet")
         return [Supervision.from_dict(s) for s in result['supervisions']]

lattifai/workers/lattice1_alpha.py

@@ -13,12 +13,23 @@ from lhotse.audio import read_audio
 from lhotse.features.kaldi.layers import Wav2LogFilterBank
 from lhotse.utils import Pathlike
 
+from lattifai.errors import (
+    AlignmentError,
+    AudioFormatError,
+    AudioLoadError,
+    DependencyError,
+    ModelLoadError,
+)
+
 
 class Lattice1AlphaWorker:
     """Worker for processing audio with LatticeGraph."""
 
     def __init__(self, model_path: Pathlike, device: str = 'cpu', num_threads: int = 8) -> None:
-        self.config = json.load(open(f'{model_path}/config.json'))
+        try:
+            self.config = json.load(open(f'{model_path}/config.json'))
+        except Exception as e:
+            raise ModelLoadError(f'config from {model_path}', original_error=e)
 
         # SessionOptions
         sess_options = ort.SessionOptions()
@@ -33,15 +44,22 @@ class Lattice1AlphaWorker:
         elif device.startswith('mps') and ort.get_all_providers().count('MPSExecutionProvider') > 0:
             providers.append('MPSExecutionProvider')
 
-        self.acoustic_ort = ort.InferenceSession(
-            f'{model_path}/acoustic_opt.onnx',
-            sess_options,
-            providers=providers + ['CoreMLExecutionProvider', 'CPUExecutionProvider'],
-        )
-        config = FbankConfig(num_mel_bins=80, device=device, snip_edges=False)
-        config_dict = config.to_dict()
-        config_dict.pop('device')
-        self.extractor = Wav2LogFilterBank(**config_dict).to(device).eval()
+        try:
+            self.acoustic_ort = ort.InferenceSession(
+                f'{model_path}/acoustic_opt.onnx',
+                sess_options,
+                providers=providers + ['CoreMLExecutionProvider', 'CPUExecutionProvider'],
+            )
+        except Exception as e:
+            raise ModelLoadError(f'acoustic model from {model_path}', original_error=e)
+
+        try:
+            config = FbankConfig(num_mel_bins=80, device=device, snip_edges=False)
+            config_dict = config.to_dict()
+            config_dict.pop('device')
+            self.extractor = Wav2LogFilterBank(**config_dict).to(device).eval()
+        except Exception as e:
+            raise ModelLoadError(f'feature extractor for device {device}', original_error=e)
 
         self.device = torch.device(device)
         self.timings = defaultdict(lambda: 0.0)
@@ -86,45 +104,59 @@ class Lattice1AlphaWorker:
                     waveform = waveform.transpose(0, 1)
                 # average multiple channels
                 waveform = np.mean(waveform, axis=0, keepdims=True)  # (1, L)
-        except Exception:
+        except Exception as primary_error:
             # Fallback to PyAV for formats not supported by soundfile
-            import av
-
-            container = av.open(audio)
-            audio_stream = next((s for s in container.streams if s.type == 'audio'), None)
-
-            if audio_stream is None:
-                raise ValueError(f'No audio stream found in {audio}')
-
-            # Resample to target sample rate during decoding
-            audio_stream.codec_context.format = av.AudioFormat('flt')  # 32-bit float
-
-            frames = []
-            for frame in container.decode(audio_stream):
-                # Convert frame to numpy array
-                array = frame.to_ndarray()
-                # Ensure shape is (channels, samples)
-                if array.ndim == 1:
-                    array = array.reshape(1, -1)
-                elif array.ndim == 2 and array.shape[0] > array.shape[1]:
-                    array = array.T
-                frames.append(array)
-
-            container.close()
+            try:
+                import av
+            except ImportError:
+                raise DependencyError(
+                    'av (PyAV)', install_command='pip install av', context={'primary_error': str(primary_error)}
+                )
+
+            try:
+                container = av.open(audio)
+                audio_stream = next((s for s in container.streams if s.type == 'audio'), None)
+
+                if audio_stream is None:
+                    raise AudioFormatError(str(audio), 'No audio stream found in file')
+
+                # Resample to target sample rate during decoding
+                audio_stream.codec_context.format = av.AudioFormat('flt')  # 32-bit float
+
+                frames = []
+                for frame in container.decode(audio_stream):
+                    # Convert frame to numpy array
+                    array = frame.to_ndarray()
+                    # Ensure shape is (channels, samples)
+                    if array.ndim == 1:
+                        array = array.reshape(1, -1)
+                    elif array.ndim == 2 and array.shape[0] > array.shape[1]:
+                        array = array.T
+                    frames.append(array)
+
+                container.close()
+
+                if not frames:
+                    raise AudioFormatError(str(audio), 'No audio data found in file')
+
+                # Concatenate all frames
+                waveform = np.concatenate(frames, axis=1)
+                # Average multiple channels to mono
+                if waveform.shape[0] > 1:
+                    waveform = np.mean(waveform, axis=0, keepdims=True)
+
+                sample_rate = audio_stream.codec_context.sample_rate
+            except Exception as e:
+                raise AudioLoadError(str(audio), original_error=e)
 
-            if not frames:
-                raise ValueError(f'No audio data found in {audio}')
-
-            # Concatenate all frames
-            waveform = np.concatenate(frames, axis=1)
-            # Average multiple channels to mono
-            if waveform.shape[0] > 1:
-                waveform = np.mean(waveform, axis=0, keepdims=True)
-
-            sample_rate = audio_stream.codec_context.sample_rate
+        try:
+            if sample_rate != self.config['sample_rate']:
+                waveform = resampy.resample(waveform, sample_rate, self.config['sample_rate'], axis=1)
+        except Exception:
+            raise AudioFormatError(
+                str(audio), f'Failed to resample from {sample_rate}Hz to {self.config["sample_rate"]}Hz'
+            )
 
-        if sample_rate != self.config['sample_rate']:
-            waveform = resampy.resample(waveform, sample_rate, self.config['sample_rate'], axis=1)
         return torch.from_numpy(waveform).to(self.device)  # (1, L)
 
     def alignment(
@@ -138,6 +170,11 @@ class Lattice1AlphaWorker:
 
         Returns:
             Processed LatticeGraph
+
+        Raises:
+            AudioLoadError: If audio cannot be loaded
+            DependencyError: If required dependencies are missing
+            AlignmentError: If alignment process fails
         """
         # load audio
         if isinstance(audio, torch.Tensor):
@@ -146,21 +183,41 @@ class Lattice1AlphaWorker:
             waveform = self.load_audio(audio)  # (1, L)
 
         _start = time.time()
-        emission = self.emission(waveform.to(self.device))  # (1, T, vocab_size)
+        try:
+            emission = self.emission(waveform.to(self.device))  # (1, T, vocab_size)
+        except Exception as e:
+            raise AlignmentError(
+                'Failed to compute acoustic features from audio',
+                audio_path=str(audio) if not isinstance(audio, torch.Tensor) else 'tensor',
+                context={'original_error': str(e)},
+            )
         self.timings['emission'] += time.time() - _start
 
-        import k2
-        from lattifai_core.lattice.decode import align_segments
+        try:
+            import k2
+        except ImportError:
+            raise DependencyError('k2', install_command='pip install install-k2 && python -m install_k2')
+
+        try:
+            from lattifai_core.lattice.decode import align_segments
+        except ImportError:
+            raise DependencyError('lattifai_core', install_command='Contact support for lattifai_core installation')
 
         lattice_graph_str, final_state, acoustic_scale = lattice_graph
 
         _start = time.time()
-        # graph
-        decoding_graph = k2.Fsa.from_str(lattice_graph_str, acceptor=False)
-        decoding_graph.requires_grad_(False)
-        decoding_graph = k2.arc_sort(decoding_graph)
-        decoding_graph.skip_id = int(final_state)
-        decoding_graph.return_id = int(final_state + 1)
+        try:
+            # graph
+            decoding_graph = k2.Fsa.from_str(lattice_graph_str, acceptor=False)
+            decoding_graph.requires_grad_(False)
+            decoding_graph = k2.arc_sort(decoding_graph)
+            decoding_graph.skip_id = int(final_state)
+            decoding_graph.return_id = int(final_state + 1)
+        except Exception as e:
+            raise AlignmentError(
+                'Failed to create decoding graph from lattice',
+                context={'original_error': str(e), 'lattice_graph_length': len(lattice_graph_str)},
+            )
         self.timings['decoding_graph'] += time.time() - _start
 
         _start = time.time()
@@ -169,17 +226,24 @@ class Lattice1AlphaWorker:
         else:
             device = self.device
 
-        results, labels = align_segments(
-            emission.to(device) * acoustic_scale,
-            decoding_graph.to(device),
-            torch.tensor([emission.shape[1]], dtype=torch.int32),
-            search_beam=100,
-            output_beam=40,
-            min_active_states=200,
-            max_active_states=10000,
-            subsampling_factor=1,
-            reject_low_confidence=False,
-        )
+        try:
+            results, labels = align_segments(
+                emission.to(device) * acoustic_scale,
+                decoding_graph.to(device),
+                torch.tensor([emission.shape[1]], dtype=torch.int32),
+                search_beam=100,
+                output_beam=40,
+                min_active_states=200,
+                max_active_states=10000,
+                subsampling_factor=1,
+                reject_low_confidence=False,
+            )
+        except Exception as e:
+            raise AlignmentError(
+                'Failed to perform forced alignment',
+                audio_path=str(audio) if not isinstance(audio, torch.Tensor) else 'tensor',
+                context={'original_error': str(e), 'emission_shape': list(emission.shape), 'device': str(device)},
+            )
         self.timings['align_segments'] += time.time() - _start
 
         channel = 0

{lattifai-0.2.4.dist-info → lattifai-0.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lattifai
-Version: 0.2.4
+Version: 0.2.5
 Summary: Lattifai Python SDK: Seamless Integration with Lattifai's Speech and Video AI Services
 Author-email: Lattifai Technologies <tech@lattifai.com>
 Maintainer-email: Lattice <tech@lattifai.com>

{lattifai-0.2.4.dist-info → lattifai-0.2.5.dist-info}/RECORD

@@ -1,6 +1,7 @@
-lattifai/__init__.py,sha256=JXUg0dT74UyAtKOjewRs9ijr5sl9SYsc6oU_WItY314,1497
-lattifai/base_client.py,sha256=ktFtATjL9pLSJUD-VqeJKA1FHkrsGHX7Uq_x00H7gO8,3322
-lattifai/client.py,sha256=QXbdTuDA5Aap2udu4iig7CVxlgwOIrydpuLlVASs0aA,5145
+lattifai/__init__.py,sha256=moXL8kuk_Xmis2xK5JKpTx8hvcWb__JI75OI73Yf20I,2069
+lattifai/base_client.py,sha256=q0l-hiAQKTWQiRXiwaHsCpSpieK_PrWRk7kmDtEfTig,3346
+lattifai/client.py,sha256=XJAaNI02swLdiHG6lRAgh3SHso-FI_tJAPFENttzO10,8341
+lattifai/errors.py,sha256=BAN57q_PE6HTQJW4mM6X0k-CZOzemsIQBGo5xmJDSsE,8735
 lattifai/bin/__init__.py,sha256=7YhmtEM8kbxJtz2-KIskvpLKBZAvkMSceVx8z4fkgQ4,61
 lattifai/bin/align.py,sha256=nQs901SDYmxyH2AXBtjgZGzrpwLaxANQRYP49Bd1AWo,1669
 lattifai/bin/cli_base.py,sha256=y535WXDRX8StloFn9icpfw7nQt0JxuWBIuPMnRxAYy8,392
@@ -11,12 +12,12 @@ lattifai/io/supervision.py,sha256=5UfSsgBhXoDU3-6drDtoD7y8HIiA4xRKZnbOKgeejwM,35
 lattifai/io/writer.py,sha256=1eAEFLlL8kricxRDPFBtVmeC4IiFyFnjbWXvw0VU-q4,2036
 lattifai/tokenizer/__init__.py,sha256=aqv44PDtq6g3oFFKW_l4HSR5ywT5W8eP1dHHywIvBfs,72
 lattifai/tokenizer/phonemizer.py,sha256=SfRi1KIMpmaao6OVmR1h_I_3QU-vrE6D5bh72Afg5XM,1759
-lattifai/tokenizer/tokenizer.py,sha256=Yuo0pLPQnF2uX0Fm5g8i5vtcADn7GeLpSqdGpMJgTww,11492
+lattifai/tokenizer/tokenizer.py,sha256=0UxlEIkOq9u6e8RMtlYOTVRjUxExo5r8LXpkzedlJNE,11606
 lattifai/workers/__init__.py,sha256=s6YfkIq4FDIAzY9sPjRpXnJfszj2repqnMTqydRM5Zw,83
-lattifai/workers/lattice1_alpha.py,sha256=fnimZqhPQ1fBCUjcDVblnFGTWP0vbNLRM7E7lOdHJu8,7428
-lattifai-0.2.4.dist-info/licenses/LICENSE,sha256=LNuoH5jpXXNKgjQ3XLwztFq8D3O7kZI-LSg81o4ym2M,1065
-lattifai-0.2.4.dist-info/METADATA,sha256=7SNTA_Egpv3F5rd0F20-4MigC7muz5x6kyr_xxj4CIk,10989
-lattifai-0.2.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lattifai-0.2.4.dist-info/entry_points.txt,sha256=CwTI2NbJvF9msIHboAfTA99cmDr_HOWoODjS8R64JOw,131
-lattifai-0.2.4.dist-info/top_level.txt,sha256=-OVWZ68YYFcTN13ARkLasp2OUappe9wEVq-CKes7jM4,17
-lattifai-0.2.4.dist-info/RECORD,,
+lattifai/workers/lattice1_alpha.py,sha256=1lCq0-bgWMXvYslAbCTFgHC0p6UWPto1y0wkTw9WrmQ,10177
+lattifai-0.2.5.dist-info/licenses/LICENSE,sha256=LNuoH5jpXXNKgjQ3XLwztFq8D3O7kZI-LSg81o4ym2M,1065
+lattifai-0.2.5.dist-info/METADATA,sha256=-EEq4g932BbO1YlMKWc-rz4tpy-rr5cHb0GSGdKdfSI,10989
+lattifai-0.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lattifai-0.2.5.dist-info/entry_points.txt,sha256=CwTI2NbJvF9msIHboAfTA99cmDr_HOWoODjS8R64JOw,131
+lattifai-0.2.5.dist-info/top_level.txt,sha256=-OVWZ68YYFcTN13ARkLasp2OUappe9wEVq-CKes7jM4,17
+lattifai-0.2.5.dist-info/RECORD,,