lattifai 0.4.5__py3-none-any.whl → 0.4.6__py3-none-any.whl

lattifai/client.py

@@ -29,7 +29,7 @@ class LattifAI(SyncAPIClient):
         self,
         *,
         api_key: Optional[str] = None,
-        model_name_or_path: str = 'Lattifai/Lattice-1-Alpha',
+        model_name_or_path: str = "Lattifai/Lattice-1-Alpha",
         device: Optional[str] = None,
         base_url: Optional[str] = None,
         timeout: Union[float, int] = 120.0,
@@ -37,17 +37,17 @@ class LattifAI(SyncAPIClient):
         default_headers: Optional[Dict[str, str]] = None,
     ) -> None:
         if api_key is None:
-            api_key = os.environ.get('LATTIFAI_API_KEY')
+            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'
+                "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')
+            base_url = os.environ.get("LATTIFAI_BASE_URL")
         if not base_url:
-            base_url = 'https://api.lattifai.com/v1'
+            base_url = "https://api.lattifai.com/v1"
 
         super().__init__(
             api_key=api_key,
@@ -96,65 +96,65 @@ class LattifAI(SyncAPIClient):
         """
         try:
             # step1: parse text or subtitles
-            print(colorful.cyan(f'📖 Step 1: Reading subtitle file from {subtitle}'))
+            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'))
+                print(colorful.green(f"         ✓ Parsed {len(supervisions)} subtitle segments"))
             except Exception as e:
                 raise SubtitleProcessingError(
-                    f'Failed to parse subtitle file: {subtitle}',
+                    f"Failed to parse subtitle file: {subtitle}",
                     subtitle_path=str(subtitle),
-                    context={'original_error': str(e)},
+                    context={"original_error": str(e)},
                 )
 
             # step2: make lattice by call Lattifai API
-            print(colorful.cyan('🔗 Step 2: Creating lattice graph from segments'))
+            print(colorful.cyan("🔗 Step 2: Creating lattice graph from segments"))
             try:
                 supervisions, lattice_id, lattice_graph = self.tokenizer.tokenize(
                     supervisions, split_sentence=split_sentence
                 )
-                print(colorful.green(f'         ✓ Generated lattice graph with ID: {lattice_id}'))
+                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 ''
+                text_content = " ".join([sup.text for sup in supervisions]) if supervisions else ""
                 raise LatticeEncodingError(text_content, original_error=e)
 
             # step3: search lattice graph with audio
-            print(colorful.cyan(f'🔍 Step 3: Searching lattice graph with audio: {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('         ✓ Lattice search completed'))
+                print(colorful.green("         ✓ Lattice search completed"))
             except Exception as e:
                 raise AlignmentError(
-                    f'Audio alignment failed for {audio}',
+                    f"Audio alignment failed for {audio}",
                     audio_path=str(audio),
                     subtitle_path=str(subtitle),
-                    context={'original_error': str(e)},
+                    context={"original_error": str(e)},
                 )
 
             # step4: decode lattice results to aligned segments
-            print(colorful.cyan('🎯 Step 4: Decoding 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, supervisions=supervisions, return_details=return_details
                 )
-                print(colorful.green(f'         ✓ Successfully aligned {len(alignments)} segments'))
+                print(colorful.green(f"         ✓ Successfully aligned {len(alignments)} segments"))
             except LatticeDecodingError as e:
-                print(colorful.red('         x Failed to decode lattice alignment results'))
+                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'))
+                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}'))
+                    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}',
+                        f"Failed to write output file: {output_subtitle_path}",
                         subtitle_path=str(output_subtitle_path),
-                        context={'original_error': str(e)},
+                        context={"original_error": str(e)},
                     )
             return (alignments, output_subtitle_path)
 
@@ -164,10 +164,10 @@ class LattifAI(SyncAPIClient):
         except Exception as e:
             # Catch any unexpected errors and wrap them
             raise AlignmentError(
-                'Unexpected error during alignment process',
+                "Unexpected error during alignment process",
                 audio_path=str(audio),
                 subtitle_path=str(subtitle),
-                context={'original_error': str(e), 'error_type': e.__class__.__name__},
+                context={"original_error": str(e), "error_type": e.__class__.__name__},
             )
 
 
@@ -178,7 +178,7 @@ class AsyncLattifAI(AsyncAPIClient):
         self,
         *,
         api_key: Optional[str] = None,
-        model_name_or_path: str = 'Lattifai/Lattice-1-Alpha',
+        model_name_or_path: str = "Lattifai/Lattice-1-Alpha",
         device: Optional[str] = None,
         base_url: Optional[str] = None,
         timeout: Union[float, int] = 120.0,
@@ -186,17 +186,17 @@ class AsyncLattifAI(AsyncAPIClient):
         default_headers: Optional[Dict[str, str]] = None,
     ) -> None:
         if api_key is None:
-            api_key = os.environ.get('LATTIFAI_API_KEY')
+            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'
+                "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')
+            base_url = os.environ.get("LATTIFAI_BASE_URL")
         if not base_url:
-            base_url = 'https://api.lattifai.com/v1'
+            base_url = "https://api.lattifai.com/v1"
 
         super().__init__(
             api_key=api_key,
@@ -223,62 +223,62 @@ class AsyncLattifAI(AsyncAPIClient):
         output_subtitle_path: Optional[Pathlike] = None,
     ) -> Tuple[List[Supervision], Optional[Pathlike]]:
         try:
-            print(colorful.cyan(f'📖 Step 1: Reading subtitle file from {subtitle}'))
+            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'))
+                print(colorful.green(f"         ✓ Parsed {len(supervisions)} subtitle segments"))
             except Exception as e:
                 raise SubtitleProcessingError(
-                    f'Failed to parse subtitle file: {subtitle}',
+                    f"Failed to parse subtitle file: {subtitle}",
                     subtitle_path=str(subtitle),
-                    context={'original_error': str(e)},
+                    context={"original_error": str(e)},
                 )
 
-            print(colorful.cyan('🔗 Step 2: Creating lattice graph from segments'))
+            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}'))
+                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 ''
+                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}'))
+            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'))
+                print(colorful.green("         ✓ Lattice search completed"))
             except Exception as e:
                 raise AlignmentError(
-                    f'Audio alignment failed for {audio}',
+                    f"Audio alignment failed for {audio}",
                     audio_path=str(audio),
                     subtitle_path=str(subtitle),
-                    context={'original_error': str(e)},
+                    context={"original_error": str(e)},
                 )
 
-            print(colorful.cyan('🎯 Step 4: Decoding lattice results to aligned segments'))
+            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'))
+                print(colorful.green(f"         ✓ Successfully aligned {len(alignments)} segments"))
             except LatticeDecodingError as e:
-                print(colorful.red('         x Failed to decode lattice alignment results'))
+                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'))
+                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}'))
+                    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}',
+                        f"Failed to write output file: {output_subtitle_path}",
                         subtitle_path=str(output_subtitle_path),
-                        context={'original_error': str(e)},
+                        context={"original_error": str(e)},
                     )
 
             return (alignments, output_subtitle_path)
@@ -287,23 +287,23 @@ class AsyncLattifAI(AsyncAPIClient):
             raise
         except Exception as e:
             raise AlignmentError(
-                'Unexpected error during alignment process',
+                "Unexpected error during alignment process",
                 audio_path=str(audio),
                 subtitle_path=str(subtitle),
-                context={'original_error': str(e), 'error_type': e.__class__.__name__},
+                context={"original_error": str(e), "error_type": e.__class__.__name__},
             )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     client = LattifAI()
     import sys
 
     if len(sys.argv) == 5:
         audio, subtitle, output, split_sentence = sys.argv[1:]
-        split_sentence = split_sentence.lower() in ('true', '1', 'yes')
+        split_sentence = split_sentence.lower() in ("true", "1", "yes")
     else:
-        audio = 'tests/data/SA1.wav'
-        subtitle = 'tests/data/SA1.TXT'
+        audio = "tests/data/SA1.wav"
+        subtitle = "tests/data/SA1.TXT"
         output = None
         split_sentence = False
 

lattifai/errors.py

@@ -7,18 +7,18 @@ 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'
+    "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"
 )
 
 
@@ -43,19 +43,19 @@ class LattifAIError(Exception):
         return (
             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'
+            "      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'
+            "      - 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'
+            "      Our team and community can help you troubleshoot\n"
         )
 
     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())
+            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
 
@@ -72,10 +72,10 @@ class AudioProcessingError(LattifAIError):
     """Error during audio processing operations."""
 
     def __init__(self, message: str, audio_path: Optional[str] = None, **kwargs):
-        context = kwargs.get('context', {})
+        context = kwargs.get("context", {})
         if audio_path:
-            context['audio_path'] = audio_path
-        kwargs['context'] = context
+            context["audio_path"] = audio_path
+        kwargs["context"] = context
         super().__init__(message, **kwargs)
 
 
@@ -83,13 +83,13 @@ 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)}'
+        message = f"Failed to load audio file: {colorful.red(audio_path)}"
         if original_error:
-            message += f' - {colorful.red(str(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
+        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)
 
@@ -98,10 +98,10 @@ 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
+        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)
 
 
@@ -109,10 +109,10 @@ class SubtitleProcessingError(LattifAIError):
     """Error during subtitle/text processing operations."""
 
     def __init__(self, message: str, subtitle_path: Optional[str] = None, **kwargs):
-        context = kwargs.get('context', {})
+        context = kwargs.get("context", {})
         if subtitle_path:
-            context['subtitle_path'] = subtitle_path
-        kwargs['context'] = context
+            context["subtitle_path"] = subtitle_path
+        kwargs["context"] = context
         super().__init__(message, **kwargs)
 
 
@@ -120,10 +120,10 @@ 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
+        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)
 
 
@@ -131,12 +131,12 @@ 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', {})
+        context = kwargs.get("context", {})
         if audio_path:
-            context['audio_path'] = audio_path
+            context["audio_path"] = audio_path
         if subtitle_path:
-            context['subtitle_path'] = subtitle_path
-        kwargs['context'] = context
+            context["subtitle_path"] = subtitle_path
+        kwargs["context"] = context
         super().__init__(message, **kwargs)
 
 
@@ -144,19 +144,19 @@ 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'
+        message = "Failed to generate lattice graph from text"
         if original_error:
-            message += f': {colorful.red(str(original_error))}'
+            message += f": {colorful.red(str(original_error))}"
 
-        context = kwargs.get('context', {})
+        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,
+                "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
+        kwargs["context"] = context
         super().__init__(message, **kwargs)
 
 
@@ -164,28 +164,28 @@ 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)}'
+        message = f"Failed to decode lattice alignment results for lattice ID: {colorful.red(lattice_id)}"
 
         # 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))}'
+            message += f" - {colorful.red(str(original_error))}"
 
-        context = kwargs.get('context', {})
+        context = kwargs.get("context", {})
         # 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
+            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'):
+        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)}'
+        base_message += f"\n\n{colorful.yellow(LATTICE_DECODING_FAILURE_HELP)}"
         return base_message
 
 
@@ -193,13 +193,13 @@ 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)}'
+        message = f"Failed to load model: {colorful.red(model_name)}"
         if original_error:
-            message += f' - {colorful.red(str(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
+        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)
 
 
@@ -207,13 +207,13 @@ 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)}'
+        message = f"Missing required dependency: {colorful.red(dependency_name)}"
         if install_command:
-            message += f'\nPlease install it using: {colorful.yellow(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
+        context = kwargs.get("context", {})
+        context.update({"dependency_name": dependency_name, "install_command": install_command})
+        kwargs["context"] = context
         super().__init__(message, **kwargs)
 
 
@@ -221,9 +221,9 @@ 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
+        context = kwargs.get("context", {})
+        context.update({"status_code": status_code, "response_text": response_text})
+        kwargs["context"] = context
         super().__init__(message, **kwargs)
 
 
@@ -231,7 +231,7 @@ class ConfigurationError(LattifAIError):
     """Error with client configuration."""
 
     def __init__(self, config_issue: str, **kwargs):
-        message = f'Configuration error: {config_issue}'
+        message = f"Configuration error: {config_issue}"
         super().__init__(message, **kwargs)
 
 
@@ -246,11 +246,11 @@ def handle_exception(func):
             raise
         except Exception as e:
             # Convert other exceptions to LattifAI errors
-            error_msg = f'Unexpected error in {func.__name__}: {str(e)}'
+            error_msg = f"Unexpected error in {func.__name__}: {str(e)}"
             context = {
-                'function': func.__name__,
-                'original_exception': e.__class__.__name__,
-                'traceback': traceback.format_exc(),
+                "function": func.__name__,
+                "original_exception": e.__class__.__name__,
+                "traceback": traceback.format_exc(),
             }
             raise LattifAIError(error_msg, context=context) from e
 

lattifai/io/__init__.py

@@ -6,6 +6,7 @@ from .gemini_reader import GeminiReader, GeminiSegment
 from .gemini_writer import GeminiWriter
 from .reader import SubtitleFormat, SubtitleReader
 from .supervision import Supervision
+from .text_parser import normalize_html_text
 from .utils import (
     ALL_SUBTITLE_FORMATS,
     INPUT_SUBTITLE_FORMATS,
@@ -15,17 +16,17 @@ from .utils import (
 from .writer import SubtitleWriter
 
 __all__ = [
-    'SubtitleReader',
-    'SubtitleWriter',
-    'SubtitleIO',
-    'Supervision',
-    'GeminiReader',
-    'GeminiWriter',
-    'GeminiSegment',
-    'SUBTITLE_FORMATS',
-    'INPUT_SUBTITLE_FORMATS',
-    'OUTPUT_SUBTITLE_FORMATS',
-    'ALL_SUBTITLE_FORMATS',
+    "SubtitleReader",
+    "SubtitleWriter",
+    "SubtitleIO",
+    "Supervision",
+    "GeminiReader",
+    "GeminiWriter",
+    "GeminiSegment",
+    "SUBTITLE_FORMATS",
+    "INPUT_SUBTITLE_FORMATS",
+    "OUTPUT_SUBTITLE_FORMATS",
+    "ALL_SUBTITLE_FORMATS",
 ]