tree-sitter-analyzer 1.8.4__py3-none-any.whl → 1.9.1__py3-none-any.whl

tree_sitter_analyzer/formatters/python_formatter.py

@@ -20,21 +20,21 @@ class PythonTableFormatter(BaseTableFormatter):
         # Handle None data - raise exception for edge case tests
         if data is None:
             raise TypeError("Cannot format None data")
-        
+
         # Ensure data is a dictionary - raise exception for edge case tests
         if not isinstance(data, dict):
             raise TypeError(f"Expected dict, got {type(data)}")
-        
+
         return self.format_structure(data)
 
     def _format_full_table(self, data: dict[str, Any]) -> str:
         """Full table format for Python"""
         if data is None:
             return "# No data available\n"
-        
+
         if not isinstance(data, dict):
             return f"# Invalid data type: {type(data)}\n"
-        
+
         lines = []
 
         # Header - Python (module/package based)
@@ -42,17 +42,22 @@ class PythonTableFormatter(BaseTableFormatter):
         if file_path is None:
             file_path = "Unknown"
         file_name = str(file_path).split("/")[-1].split("\\")[-1]
-        module_name = file_name.replace(".py", "").replace(".pyw", "").replace(".pyi", "")
+        module_name = (
+            file_name.replace(".py", "").replace(".pyw", "").replace(".pyi", "")
+        )
 
         # Check if this is a package module
         classes = data.get("classes", [])
         functions = data.get("functions", [])
         imports = data.get("imports", [])
-        
+
         # Determine module type
         is_package = "__init__.py" in file_name
-        is_script = any("if __name__ == '__main__'" in func.get("raw_text", "") for func in functions)
-        
+        is_script = any(
+            "if __name__ == '__main__'" in func.get("raw_text", "")
+            for func in functions
+        )
+
         if is_package:
             lines.append(f"# Package: {module_name}")
         elif is_script:
@@ -96,7 +101,7 @@ class PythonTableFormatter(BaseTableFormatter):
                 # Handle None class_info
                 if class_info is None:
                     continue
-                    
+
                 name = str(class_info.get("name", "Unknown"))
                 class_type = str(class_info.get("type", "class"))
                 visibility = str(class_info.get("visibility", "public"))
@@ -136,14 +141,16 @@ class PythonTableFormatter(BaseTableFormatter):
             stats = data.get("statistics") or {}
 
             lines.append("| Package | (default) |")
-            lines.append(f"| Type | {str(class_info.get('type', 'class') if class_info else 'class')} |")
+            lines.append(
+                f"| Type | {str(class_info.get('type', 'class') if class_info else 'class')} |"
+            )
             lines.append(
                 f"| Visibility | {str(class_info.get('visibility', 'public') if class_info else 'public')} |"
             )
-            
+
             # Handle None class_info for line range
-            if class_info and class_info.get('line_range'):
-                line_range = class_info.get('line_range', {})
+            if class_info and class_info.get("line_range"):
+                line_range = class_info.get("line_range", {})
                 lines.append(
                     f"| Lines | {line_range.get('start', 0)}-{line_range.get('end', 0)} |"
                 )
@@ -176,11 +183,17 @@ class PythonTableFormatter(BaseTableFormatter):
             lines.append("")
 
         # Methods - Python (with decorators and async support)
-        methods = data.get("methods", []) or functions  # Use functions if methods not available
+        methods = (
+            data.get("methods", []) or functions
+        )  # Use functions if methods not available
         if methods:
             lines.append("## Methods")
-            lines.append("| Method | Signature | Vis | Lines | Cols | Cx | Decorators | Doc |")
-            lines.append("|--------|-----------|-----|-------|------|----|-----------|----|")
+            lines.append(
+                "| Method | Signature | Vis | Lines | Cols | Cx | Decorators | Doc |"
+            )
+            lines.append(
+                "|--------|-----------|-----|-------|------|----|-----------|----|"
+            )
 
             for method in methods:
                 lines.append(self._format_method_row(method))
@@ -249,16 +262,16 @@ class PythonTableFormatter(BaseTableFormatter):
         """Format a method table row for Python"""
         name = str(method.get("name", ""))
         signature = self._format_python_signature(method)
-        
+
         # Python-specific visibility handling
         visibility = method.get("visibility", "public")
         if name.startswith("__") and name.endswith("__"):
             visibility = "magic"
         elif name.startswith("_"):
             visibility = "private"
-        
+
         vis_symbol = self._get_python_visibility_symbol(visibility)
-        
+
         line_range = method.get("line_range", {})
         if not line_range or not isinstance(line_range, dict):
             start_line = method.get("start_line", 0)
@@ -266,29 +279,29 @@ class PythonTableFormatter(BaseTableFormatter):
             lines_str = f"{start_line}-{end_line}"
         else:
             lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
-        
+
         cols_str = "5-6"  # default placeholder
         complexity = method.get("complexity_score", 0)
-        
+
         # Use docstring instead of javadoc
         doc = self._clean_csv_text(
             self._extract_doc_summary(str(method.get("docstring", "")))
         )
-        
+
         # Add decorators info
         decorators = method.get("modifiers", []) or method.get("decorators", [])
         decorator_str = self._format_decorators(decorators)
-        
+
         # Add async indicator
         async_indicator = "🔄" if method.get("is_async", False) else ""
-        
+
         return f"| {name}{async_indicator} | {signature} | {vis_symbol} | {lines_str} | {cols_str} | {complexity} | {decorator_str} | {doc} |"
 
     def _create_compact_signature(self, method: dict[str, Any]) -> str:
         """Create compact method signature for Python"""
         if method is None or not isinstance(method, dict):
             return "(Any,Any):A"
-        
+
         params = method.get("parameters", [])
         param_types = []
 
@@ -347,7 +360,11 @@ class PythonTableFormatter(BaseTableFormatter):
 
         # Optional[float] -> O[f], Optional[str] -> O[s]
         if "Optional[" in type_name:
-            result = type_name.replace("Optional[", "O[").replace("str", "s").replace("float", "f")
+            result = (
+                type_name.replace("Optional[", "O[")
+                .replace("str", "s")
+                .replace("float", "f")
+            )
             return str(result)
 
         result = type_mapping.get(
@@ -361,17 +378,17 @@ class PythonTableFormatter(BaseTableFormatter):
         source_code = data.get("source_code", "")
         if not source_code:
             return None
-            
+
         lines = source_code.split("\n")
         for i, line in enumerate(lines[:10]):  # Check first 10 lines
             stripped = line.strip()
             if stripped.startswith('"""') or stripped.startswith("'''"):
                 quote_type = '"""' if stripped.startswith('"""') else "'''"
-                
+
                 # Single line docstring
                 if stripped.count(quote_type) >= 2:
                     return stripped.replace(quote_type, "").strip()
-                
+
                 # Multi-line docstring
                 docstring_lines = [stripped.replace(quote_type, "")]
                 for j in range(i + 1, len(lines)):
@@ -380,9 +397,9 @@ class PythonTableFormatter(BaseTableFormatter):
                         docstring_lines.append(next_line.replace(quote_type, ""))
                         break
                     docstring_lines.append(next_line)
-                
+
                 return "\n".join(docstring_lines).strip()
-        
+
         return None
 
     def _format_python_signature(self, method: dict[str, Any]) -> str:
@@ -405,7 +422,7 @@ class PythonTableFormatter(BaseTableFormatter):
 
         params_str = ", ".join(param_strs)
         return_type = method.get("return_type", "")
-        
+
         if return_type and return_type != "Any":
             return f"({params_str}) -> {return_type}"
         else:
@@ -415,7 +432,7 @@ class PythonTableFormatter(BaseTableFormatter):
         """Get Python visibility symbol"""
         visibility_map = {
             "public": "🔓",
-            "private": "🔒", 
+            "private": "🔒",
             "protected": "🔐",
             "magic": "✨",
         }
@@ -425,18 +442,24 @@ class PythonTableFormatter(BaseTableFormatter):
         """Format Python decorators"""
         if not decorators:
             return "-"
-        
+
         # Show important decorators
-        important = ["property", "staticmethod", "classmethod", "dataclass", "abstractmethod"]
+        important = [
+            "property",
+            "staticmethod",
+            "classmethod",
+            "dataclass",
+            "abstractmethod",
+        ]
         shown_decorators = []
-        
+
         for dec in decorators:
             if any(imp in dec for imp in important):
                 shown_decorators.append(f"@{dec}")
-        
+
         if shown_decorators:
             return ", ".join(shown_decorators)
         elif len(decorators) == 1:
             return f"@{decorators[0]}"
         else:
-            return f"@{decorators[0]} (+{len(decorators)-1})"
+            return f"@{decorators[0]} (+{len(decorators) - 1})"

tree_sitter_analyzer/formatters/typescript_formatter.py

@@ -35,7 +35,12 @@ class TypeScriptTableFormatter(BaseTableFormatter):
         classes = data.get("classes", [])
         interfaces = data.get("interfaces", [])
         functions = data.get("functions", [])
-        is_module = len(exports) > 0 or len(classes) > 0 or len(interfaces) > 0 or len(functions) > 0
+        is_module = (
+            len(exports) > 0
+            or len(classes) > 0
+            or len(interfaces) > 0
+            or len(functions) > 0
+        )
         is_declaration_file = file_name.endswith(".d.ts")
         is_tsx = file_name.endswith(".tsx")
 
@@ -74,13 +79,17 @@ class TypeScriptTableFormatter(BaseTableFormatter):
         interfaces = [c for c in classes if c.get("class_type") == "interface"]
         type_aliases = [c for c in classes if c.get("class_type") == "type"]
         enums = [c for c in classes if c.get("class_type") == "enum"]
-        actual_classes = [c for c in classes if c.get("class_type") in ["class", "abstract_class"]]
+        actual_classes = [
+            c for c in classes if c.get("class_type") in ["class", "abstract_class"]
+        ]
 
         lines.append("## Module Info")
         lines.append("| Property | Value |")
         lines.append("|----------|-------|")
         lines.append(f"| File | {file_name} |")
-        lines.append(f"| Type | {'Declaration File' if is_declaration_file else 'TSX Module' if is_tsx else 'TypeScript Module' if is_module else 'TypeScript Script'} |")
+        lines.append(
+            f"| Type | {'Declaration File' if is_declaration_file else 'TSX Module' if is_tsx else 'TypeScript Module' if is_module else 'TypeScript Script'} |"
+        )
         lines.append(f"| Functions | {stats.get('function_count', 0)} |")
         lines.append(f"| Classes | {len(actual_classes)} |")
         lines.append(f"| Interfaces | {len(interfaces)} |")
@@ -93,31 +102,43 @@ class TypeScriptTableFormatter(BaseTableFormatter):
         # Interfaces (TypeScript specific)
         if interfaces:
             lines.append("## Interfaces")
-            lines.append("| Interface | Extends | Lines | Properties | Methods | Generics |")
-            lines.append("|-----------|---------|-------|------------|---------|----------|")
+            lines.append(
+                "| Interface | Extends | Lines | Properties | Methods | Generics |"
+            )
+            lines.append(
+                "|-----------|---------|-------|------------|---------|----------|"
+            )
 
             for interface in interfaces:
                 name = str(interface.get("name", "Unknown"))
                 extends = ", ".join(interface.get("interfaces", [])) or "-"
                 line_range = interface.get("line_range", {})
                 lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
-                
+
                 # Count properties and methods within the interface
                 interface_properties = [
-                    v for v in data.get("variables", [])
-                    if line_range.get("start", 0) <= v.get("line_range", {}).get("start", 0) <= line_range.get("end", 0)
+                    v
+                    for v in data.get("variables", [])
+                    if line_range.get("start", 0)
+                    <= v.get("line_range", {}).get("start", 0)
+                    <= line_range.get("end", 0)
                     and v.get("declaration_kind") == "property_signature"
                 ]
-                
+
                 interface_methods = [
-                    m for m in data.get("methods", [])
-                    if line_range.get("start", 0) <= m.get("line_range", {}).get("start", 0) <= line_range.get("end", 0)
+                    m
+                    for m in data.get("methods", [])
+                    if line_range.get("start", 0)
+                    <= m.get("line_range", {}).get("start", 0)
+                    <= line_range.get("end", 0)
                     and m.get("is_signature", False)
                 ]
-                
+
                 generics = ", ".join(interface.get("generics", [])) or "-"
 
-                lines.append(f"| {name} | {extends} | {lines_str} | {len(interface_properties)} | {len(interface_methods)} | {generics} |")
+                lines.append(
+                    f"| {name} | {extends} | {lines_str} | {len(interface_properties)} | {len(interface_methods)} | {generics} |"
+                )
             lines.append("")
 
         # Type Aliases (TypeScript specific)
@@ -131,7 +152,7 @@ class TypeScriptTableFormatter(BaseTableFormatter):
                 line_range = type_alias.get("line_range", {})
                 lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
                 generics = ", ".join(type_alias.get("generics", [])) or "-"
-                
+
                 # Extract type definition from raw text
                 raw_text = type_alias.get("raw_text", "")
                 if "=" in raw_text:
@@ -154,7 +175,7 @@ class TypeScriptTableFormatter(BaseTableFormatter):
                 name = str(enum.get("name", "Unknown"))
                 line_range = enum.get("line_range", {})
                 lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
-                
+
                 # Count enum values (simplified)
                 raw_text = enum.get("raw_text", "")
                 value_count = raw_text.count(",") + 1 if raw_text.count("{") > 0 else 0
@@ -165,8 +186,12 @@ class TypeScriptTableFormatter(BaseTableFormatter):
         # Classes
         if actual_classes:
             lines.append("## Classes")
-            lines.append("| Class | Type | Extends | Implements | Lines | Methods | Properties | Generics |")
-            lines.append("|-------|------|---------|------------|-------|---------|------------|----------|")
+            lines.append(
+                "| Class | Type | Extends | Implements | Lines | Methods | Properties | Generics |"
+            )
+            lines.append(
+                "|-------|------|---------|------------|-------|---------|------------|----------|"
+            )
 
             for class_info in actual_classes:
                 name = str(class_info.get("name", "Unknown"))
@@ -179,32 +204,52 @@ class TypeScriptTableFormatter(BaseTableFormatter):
 
                 # Count methods within the class
                 class_methods = [
-                    m for m in data.get("functions", [])
-                    if (line_range.get("start", 0) <= m.get("line_range", {}).get("start", 0) <= line_range.get("end", 0)
+                    m
+                    for m in data.get("functions", [])
+                    if (
+                        line_range.get("start", 0)
+                        <= m.get("line_range", {}).get("start", 0)
+                        <= line_range.get("end", 0)
                         and m.get("is_method", False)
-                        and not m.get("is_signature", False))
+                        and not m.get("is_signature", False)
+                    )
                 ]
 
                 # Count properties (class fields)
                 class_properties = [
-                    v for v in data.get("variables", [])
-                    if line_range.get("start", 0) <= v.get("line_range", {}).get("start", 0) <= line_range.get("end", 0)
+                    v
+                    for v in data.get("variables", [])
+                    if line_range.get("start", 0)
+                    <= v.get("line_range", {}).get("start", 0)
+                    <= line_range.get("end", 0)
                     and v.get("declaration_kind") == "property"
                 ]
 
-                lines.append(f"| {name} | {class_type} | {extends} | {implements} | {lines_str} | {len(class_methods)} | {len(class_properties)} | {generics} |")
+                lines.append(
+                    f"| {name} | {class_type} | {extends} | {implements} | {lines_str} | {len(class_methods)} | {len(class_properties)} | {generics} |"
+                )
             lines.append("")
 
         # Functions
         functions = data.get("functions", [])
         if functions:
             lines.append("## Functions")
-            lines.append("| Function | Type | Return Type | Parameters | Async | Generic | Lines | Complexity |")
-            lines.append("|----------|------|-------------|------------|-------|---------|-------|------------|")
+            lines.append(
+                "| Function | Type | Return Type | Parameters | Async | Generic | Lines | Complexity |"
+            )
+            lines.append(
+                "|----------|------|-------------|------------|-------|---------|-------|------------|"
+            )
 
             for func in functions:
                 name = str(func.get("name", "Unknown"))
-                func_type = "arrow" if func.get("is_arrow") else "method" if func.get("is_method") else "function"
+                func_type = (
+                    "arrow"
+                    if func.get("is_arrow")
+                    else "method"
+                    if func.get("is_method")
+                    else "function"
+                )
                 return_type = str(func.get("return_type", "any"))
                 params = func.get("parameters", [])
                 param_count = len(params)
@@ -214,15 +259,21 @@ class TypeScriptTableFormatter(BaseTableFormatter):
                 lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
                 complexity = func.get("complexity_score", 1)
 
-                lines.append(f"| {name} | {func_type} | {return_type} | {param_count} | {is_async} | {has_generics} | {lines_str} | {complexity} |")
+                lines.append(
+                    f"| {name} | {func_type} | {return_type} | {param_count} | {is_async} | {has_generics} | {lines_str} | {complexity} |"
+                )
             lines.append("")
 
         # Variables/Properties
         variables = data.get("variables", [])
         if variables:
             lines.append("## Variables & Properties")
-            lines.append("| Name | Type | Kind | Visibility | Static | Optional | Lines |")
-            lines.append("|------|------|------|------------|--------|----------|-------|")
+            lines.append(
+                "| Name | Type | Kind | Visibility | Static | Optional | Lines |"
+            )
+            lines.append(
+                "|------|------|------|------------|--------|----------|-------|"
+            )
 
             for var in variables:
                 name = str(var.get("name", "Unknown"))
@@ -234,7 +285,9 @@ class TypeScriptTableFormatter(BaseTableFormatter):
                 line_range = var.get("line_range", {})
                 lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
 
-                lines.append(f"| {name} | {var_type} | {kind} | {visibility} | {is_static} | {is_optional} | {lines_str} |")
+                lines.append(
+                    f"| {name} | {var_type} | {kind} | {visibility} | {is_static} | {is_optional} | {lines_str} |"
+                )
             lines.append("")
 
         # Exports
@@ -265,7 +318,6 @@ class TypeScriptTableFormatter(BaseTableFormatter):
         lines.append("")
 
         # Summary
-        stats = data.get("statistics", {})
         classes = data.get("classes", [])
         functions = data.get("functions", [])
         variables = data.get("variables", [])
@@ -273,7 +325,9 @@ class TypeScriptTableFormatter(BaseTableFormatter):
         interfaces = len([c for c in classes if c.get("class_type") == "interface"])
         type_aliases = len([c for c in classes if c.get("class_type") == "type"])
         enums = len([c for c in classes if c.get("class_type") == "enum"])
-        actual_classes = len([c for c in classes if c.get("class_type") in ["class", "abstract_class"]])
+        actual_classes = len(
+            [c for c in classes if c.get("class_type") in ["class", "abstract_class"]]
+        )
 
         lines.append("## Summary")
         lines.append(f"- **Classes**: {actual_classes}")
@@ -303,7 +357,9 @@ class TypeScriptTableFormatter(BaseTableFormatter):
                 line_range = func.get("line_range", {})
                 lines_str = f"L{line_range.get('start', 0)}-{line_range.get('end', 0)}"
                 async_marker = " (async)" if func.get("is_async") else ""
-                lines.append(f"- **{name}**(): {return_type}{async_marker} - {lines_str}")
+                lines.append(
+                    f"- **{name}**(): {return_type}{async_marker} - {lines_str}"
+                )
             lines.append("")
 
         return "\n".join(lines)
@@ -326,13 +382,21 @@ class TypeScriptTableFormatter(BaseTableFormatter):
             is_static = "true" if class_info.get("is_static") else "false"
             has_generics = "true" if class_info.get("generics") else "false"
 
-            lines.append(f"Class,{name},{class_type},,{lines_str},{visibility},{is_static},,{has_generics}")
+            lines.append(
+                f"Class,{name},{class_type},,{lines_str},{visibility},{is_static},,{has_generics}"
+            )
 
         # Functions
         functions = data.get("functions", [])
         for func in functions:
             name = func.get("name", "")
-            func_type = "arrow" if func.get("is_arrow") else "method" if func.get("is_method") else "function"
+            func_type = (
+                "arrow"
+                if func.get("is_arrow")
+                else "method"
+                if func.get("is_method")
+                else "function"
+            )
             return_type = func.get("return_type", "any")
             line_range = func.get("line_range", {})
             lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
@@ -341,7 +405,9 @@ class TypeScriptTableFormatter(BaseTableFormatter):
             is_async = "true" if func.get("is_async") else "false"
             has_generics = "true" if func.get("generics") else "false"
 
-            lines.append(f"Function,{name},{func_type},{return_type},{lines_str},{visibility},{is_static},{is_async},{has_generics}")
+            lines.append(
+                f"Function,{name},{func_type},{return_type},{lines_str},{visibility},{is_static},{is_async},{has_generics}"
+            )
 
         # Variables
         variables = data.get("variables", [])
@@ -354,14 +420,16 @@ class TypeScriptTableFormatter(BaseTableFormatter):
             visibility = var.get("visibility", "public")
             is_static = "true" if var.get("is_static") else "false"
 
-            lines.append(f"Variable,{name},{kind},{var_type},{lines_str},{visibility},{is_static},,")
+            lines.append(
+                f"Variable,{name},{kind},{var_type},{lines_str},{visibility},{is_static},,"
+            )
 
         return "\n".join(lines)
 
     def _get_element_type_name(self, element: dict[str, Any]) -> str:
         """Get human-readable type name for TypeScript elements"""
         element_type = element.get("element_type", "unknown")
-        
+
         if element_type == "class":
             class_type = element.get("class_type", "class")
             if class_type == "interface":
@@ -399,21 +467,21 @@ class TypeScriptTableFormatter(BaseTableFormatter):
     def _format_element_details(self, element: dict[str, Any]) -> str:
         """Format TypeScript-specific element details"""
         details = []
-        
+
         # Type annotations
         if element.get("has_type_annotations"):
             details.append("typed")
-        
+
         # Generics
         if element.get("generics"):
             generics = ", ".join(element.get("generics", []))
             details.append(f"<{generics}>")
-        
+
         # Visibility
         visibility = element.get("visibility")
         if visibility and visibility != "public":
             details.append(visibility)
-        
+
         # Modifiers
         if element.get("is_static"):
             details.append("static")
@@ -423,10 +491,10 @@ class TypeScriptTableFormatter(BaseTableFormatter):
             details.append("abstract")
         if element.get("is_optional"):
             details.append("optional")
-        
+
         # Framework specific
         framework = element.get("framework_type")
         if framework:
             details.append(f"{framework}")
-        
-        return " ".join(details) if details else ""
+
+        return " ".join(details) if details else ""

tree_sitter_analyzer/interfaces/mcp_server.py

@@ -29,7 +29,7 @@ except ImportError:
         pass
 
     class InitializationOptions:
-        def __init__(self, **kwargs):
+        def __init__(self, **kwargs: Any) -> None:
             pass
 
     class Tool:
@@ -41,7 +41,7 @@ except ImportError:
     class TextContent:
         pass
 
-    def stdio_server():
+    def stdio_server() -> None:
         pass
 
 

tree_sitter_analyzer/language_detector.py

@@ -266,14 +266,14 @@ class LanguageDetector:
         # Handle invalid input
         if not file_path or not isinstance(file_path, str):
             return "unknown", 0.0
-            
+
         path = Path(file_path)
         extension = path.suffix.lower()
 
         # Direct mapping by extension
         if extension in self.EXTENSION_MAPPING:
             language = self.EXTENSION_MAPPING[extension]
-            
+
             # Ensure language is valid
             if not language or language.strip() == "":
                 return "unknown", 0.0
@@ -313,7 +313,7 @@ class LanguageDetector:
         # Handle invalid input
         if not file_path or not isinstance(file_path, str):
             return "unknown"
-            
+
         result = self.detect_language(file_path)
         if isinstance(result, tuple):
             language, _ = result
@@ -487,15 +487,15 @@ def detect_language_from_file(file_path: str) -> str:
     # Handle invalid input
     if not file_path or not isinstance(file_path, str):
         return "unknown"
-        
+
     # Create a fresh instance to ensure latest configuration
     fresh_detector = LanguageDetector()
     result = fresh_detector.detect_from_extension(file_path)
-    
+
     # Ensure result is valid
     if not result or result.strip() == "":
         return "unknown"
-    
+
     return result
 
 

tree_sitter_analyzer/language_loader.py

@@ -176,7 +176,9 @@ class LanguageLoader:
                     except Exception as inner_e:  # noqa: F841
                         raise
                 else:
-                    raise RuntimeError("Unsupported Parser API: no way to set language") from None
+                    raise RuntimeError(
+                        "Unsupported Parser API: no way to set language"
+                    ) from None
 
             # Cache and return
             self._parser_cache[language] = parser