tree-sitter-analyzer 0.3.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

tree_sitter_analyzer/encoding_utils.py

@@ -151,17 +151,18 @@ class EncodingManager:
     FALLBACK_ENCODINGS = ["utf-8", "cp1252", "iso-8859-1", "shift_jis", "gbk"]
 
     @classmethod
-    def safe_encode(cls, text: str, encoding: str | None = None) -> bytes:
+    def safe_encode(cls, text: str | None, encoding: str | None = None) -> bytes:
         """
         Safely encode text to bytes with fallback handling
 
         Args:
-            text: Text to encode
+            text: Text to encode (can be None)
             encoding: Target encoding (defaults to UTF-8)
 
         Returns:
             Encoded bytes
         """
+        # Handle None input
         if text is None:
             return b""
 

tree_sitter_analyzer/exceptions.py

@@ -42,7 +42,7 @@ class AnalysisError(TreeSitterAnalyzerError):
         message: str,
         file_path: str | Path | None = None,
         language: str | None = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> None:
         context = kwargs.get("context", {})
         if file_path:
@@ -60,7 +60,7 @@ class ParseError(TreeSitterAnalyzerError):
         message: str,
         language: str | None = None,
         source_info: dict[str, Any] | None = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> None:
         context = kwargs.get("context", {})
         if language:
@@ -74,7 +74,7 @@ class LanguageNotSupportedError(TreeSitterAnalyzerError):
     """Raised when a language is not supported."""
 
     def __init__(
-        self, language: str, supported_languages: list | None = None, **kwargs
+        self, language: str, supported_languages: list[str] | None = None, **kwargs: Any
     ) -> None:
         message = f"Language '{language}' is not supported"
         context = kwargs.get("context", {})
@@ -93,7 +93,7 @@ class PluginError(TreeSitterAnalyzerError):
         message: str,
         plugin_name: str | None = None,
         operation: str | None = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> None:
         context = kwargs.get("context", {})
         if plugin_name:
@@ -112,7 +112,7 @@ class QueryError(TreeSitterAnalyzerError):
         query_name: str | None = None,
         query_string: str | None = None,
         language: str | None = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> None:
         context = kwargs.get("context", {})
         if query_name:
@@ -132,7 +132,7 @@ class FileHandlingError(TreeSitterAnalyzerError):
         message: str,
         file_path: str | Path | None = None,
         operation: str | None = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> None:
         context = kwargs.get("context", {})
         if file_path:
@@ -150,7 +150,7 @@ class ConfigurationError(TreeSitterAnalyzerError):
         message: str,
         config_key: str | None = None,
         config_value: Any | None = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> None:
         context = kwargs.get("context", {})
         if config_key:
@@ -168,7 +168,7 @@ class ValidationError(TreeSitterAnalyzerError):
         message: str,
         validation_type: str | None = None,
         invalid_value: Any | None = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> None:
         context = kwargs.get("context", {})
         if validation_type:
@@ -186,7 +186,7 @@ class MCPError(TreeSitterAnalyzerError):
         message: str,
         tool_name: str | None = None,
         resource_uri: str | None = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> None:
         context = kwargs.get("context", {})
         if tool_name:
@@ -200,7 +200,7 @@ class MCPError(TreeSitterAnalyzerError):
 def handle_exception(
     exception: Exception,
     context: dict[str, Any] | None = None,
-    reraise_as: type | None = None,
+    reraise_as: type[Exception] | None = None,
 ) -> None:
     """
     Handle exceptions with optional context and re-raising.
@@ -231,13 +231,13 @@ def handle_exception(
 
 
 def safe_execute(
-    func,
-    *args,
-    default_return=None,
-    exception_types: tuple = (Exception,),
+    func: Any,
+    *args: Any,
+    default_return: Any = None,
+    exception_types: tuple[type[Exception], ...] = (Exception,),
     log_errors: bool = True,
-    **kwargs,
-):
+    **kwargs: Any,
+) -> Any:
     """
     Safely execute a function with exception handling.
 
@@ -277,7 +277,7 @@ def create_error_response(
     """
     import traceback
 
-    response = {
+    response: dict[str, Any] = {
         "success": False,
         "error": {"type": exception.__class__.__name__, "message": str(exception)},
     }
@@ -299,11 +299,11 @@ def create_error_response(
 
 # Decorator for exception handling
 def handle_exceptions(
-    default_return=None,
-    exception_types: tuple = (Exception,),
-    reraise_as: type | None = None,
+    default_return: Any = None,
+    exception_types: tuple[type[Exception], ...] = (Exception,),
+    reraise_as: type[Exception] | None = None,
     log_errors: bool = True,
-):
+) -> Any:
     """
     Decorator for automatic exception handling.
 
@@ -314,8 +314,8 @@ def handle_exceptions(
         log_errors: Whether to log errors
     """
 
-    def decorator(func):
-        def wrapper(*args, **kwargs):
+    def decorator(func: Any) -> Any:
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
             try:
                 return func(*args, **kwargs)
             except exception_types as e:

tree_sitter_analyzer/file_handler.py

@@ -13,13 +13,13 @@ from .utils import log_error, log_info, log_warning
 
 def detect_language_from_extension(file_path: str) -> str:
     """
-    ファイル拡張子から言語を判定
+    Detect programming language from file extension
 
     Args:
-        file_path: ファイルパス
+        file_path: File path to analyze
 
     Returns:
-        言語名または'unknown'
+        Language name or 'unknown' if not recognized
     """
     extension = os.path.splitext(file_path)[1].lower()
 
@@ -62,14 +62,10 @@ def read_file_with_fallback(file_path: str) -> bytes | None:
 
     try:
         content, detected_encoding = read_file_safe(file_path)
-        if content is not None:  # 空文字列も有効なコンテンツ
-            log_info(
-                f"Successfully read file {file_path} with encoding: {detected_encoding}"
-            )
-            return content.encode("utf-8")
-        else:
-            log_warning(f"File {file_path} is empty or could not be read")
-            return b""
+        log_info(
+            f"Successfully read file {file_path} with encoding: {detected_encoding}"
+        )
+        return content.encode("utf-8")
 
     except Exception as e:
         log_error(f"Failed to read file {file_path}: {e}")
@@ -113,9 +109,6 @@ def read_file_partial(
     try:
         # ファイル全体を安全に読み込み
         content, detected_encoding = read_file_safe(file_path)
-        if content is None:
-            log_error(f"Failed to read file: {file_path}")
-            return None
 
         # 行に分割
         lines = content.splitlines(keepends=True)

tree_sitter_analyzer/formatters/base_formatter.py

@@ -17,17 +17,17 @@ class BaseTableFormatter(ABC):
         self.format_type = format_type
 
     def _get_platform_newline(self) -> str:
-        """プラットフォーム固有の改行コードを取得"""
+        """Get platform-specific newline code"""
         return os.linesep
 
     def _convert_to_platform_newlines(self, text: str) -> str:
-        """通常の\nをプラットフォーム固有の改行コードに変換"""
+        """Convert regular \n to platform-specific newline code"""
         if os.linesep != "\n":
             return text.replace("\n", os.linesep)
         return text
 
     def format_structure(self, structure_data: dict[str, Any]) -> str:
-        """構造データをテーブル形式でフォーマット"""
+        """Format structure data in table format"""
         if self.format_type == "full":
             result = self._format_full_table(structure_data)
         elif self.format_type == "compact":
@@ -37,7 +37,7 @@ class BaseTableFormatter(ABC):
         else:
             raise ValueError(f"Unsupported format type: {self.format_type}")
 
-        # 最終的にプラットフォーム固有の改行コードに変換
+        # Finally convert to platform-specific newline code
         if self.format_type == "csv":
             return result
 
@@ -45,25 +45,25 @@ class BaseTableFormatter(ABC):
 
     @abstractmethod
     def _format_full_table(self, data: dict[str, Any]) -> str:
-        """完全版テーブル形式（言語固有実装）"""
+        """Full table format (language-specific implementation)"""
         pass
 
     @abstractmethod
     def _format_compact_table(self, data: dict[str, Any]) -> str:
-        """コンパクト版テーブル形式（言語固有実装）"""
+        """Compact table format (language-specific implementation)"""
         pass
 
     def _format_csv(self, data: dict[str, Any]) -> str:
-        """CSV形式（共通実装）"""
+        """CSV format (common implementation)"""
         output = io.StringIO()
         writer = csv.writer(output, lineterminator="\n")
 
-        # ヘッダー
+        # Header
         writer.writerow(
             ["Type", "Name", "Signature", "Visibility", "Lines", "Complexity", "Doc"]
         )
 
-        # フィールド
+        # Fields
         for field in data.get("fields", []):
             writer.writerow(
                 [
@@ -79,7 +79,7 @@ class BaseTableFormatter(ABC):
                 ]
             )
 
-        # メソッド
+        # Methods
         for method in data.get("methods", []):
             writer.writerow(
                 [
@@ -102,9 +102,9 @@ class BaseTableFormatter(ABC):
 
         return csv_content
 
-    # 共通ヘルパーメソッド
+    # Common helper methods
     def _create_full_signature(self, method: dict[str, Any]) -> str:
-        """完全なメソッドシグネチャを作成"""
+        """Create complete method signature"""
         params = method.get("parameters", [])
         param_strs = []
         for param in params:
@@ -131,32 +131,32 @@ class BaseTableFormatter(ABC):
         return signature
 
     def _convert_visibility(self, visibility: str) -> str:
-        """可視性を記号に変換"""
+        """Convert visibility to symbol"""
         mapping = {"public": "+", "private": "-", "protected": "#", "package": "~"}
         return mapping.get(visibility, visibility)
 
     def _extract_doc_summary(self, javadoc: str) -> str:
-        """ドキュメントから要約を抽出"""
+        """Extract summary from documentation"""
         if not javadoc:
             return "-"
 
-        # コメント記号を除去
+        # Remove comment symbols
         clean_doc = (
             javadoc.replace("/**", "").replace("*/", "").replace("*", "").strip()
         )
 
-        # 最初の行を取得
+        # Get first line
         lines = clean_doc.split("\n")
         first_line = lines[0].strip()
 
-        # 長すぎる場合は切り詰め
+        # Truncate if too long
         if len(first_line) > 50:
             first_line = first_line[:47] + "..."
 
         return first_line.replace("|", "\\|").replace("\n", " ")
 
     def _clean_csv_text(self, text: str) -> str:
-        """CSV形式用のテキストクリーニング"""
+        """Text cleaning for CSV format"""
         if not text:
             return ""
 

tree_sitter_analyzer/formatters/formatter_factory.py

@@ -9,7 +9,7 @@ from .python_formatter import PythonTableFormatter
 
 
 class TableFormatterFactory:
-    """言語固有のテーブルフォーマッターを作成するファクトリー"""
+    """Factory for creating language-specific table formatters"""
 
     _formatters: dict[str, type[BaseTableFormatter]] = {
         "java": JavaTableFormatter,
@@ -21,19 +21,19 @@ class TableFormatterFactory:
         cls, language: str, format_type: str = "full"
     ) -> BaseTableFormatter:
         """
-        指定された言語用のテーブルフォーマッターを作成
+        Create table formatter for specified language
 
         Args:
-            language: プログラミング言語名
-            format_type: フォーマットタイプ（full, compact, csv）
+            language: Programming language name
+            format_type: Format type (full, compact, csv)
 
         Returns:
-            言語固有のテーブルフォーマッター
+            Language-specific table formatter
         """
         formatter_class = cls._formatters.get(language.lower())
 
         if formatter_class is None:
-            # デフォルトとしてJavaフォーマッターを使用
+            # Use Java formatter as default
             formatter_class = JavaTableFormatter
 
         return formatter_class(format_type)
@@ -43,21 +43,21 @@ class TableFormatterFactory:
         cls, language: str, formatter_class: type[BaseTableFormatter]
     ) -> None:
         """
-        新しい言語フォーマッターを登録
+        Register new language formatter
 
         Args:
-            language: プログラミング言語名
-            formatter_class: フォーマッタークラス
+            language: Programming language name
+            formatter_class: Formatter class
         """
         cls._formatters[language.lower()] = formatter_class
 
     @classmethod
     def get_supported_languages(cls) -> list[str]:
         """
-        サポートされている言語一覧を取得
+        Get list of supported languages
 
         Returns:
-            サポートされている言語のリスト
+            List of supported languages
         """
         return list(cls._formatters.keys())
 
@@ -66,13 +66,13 @@ def create_table_formatter(
     format_type: str, language: str = "java"
 ) -> BaseTableFormatter:
     """
-    テーブルフォーマッターを作成（互換性のための関数）
+    Create table formatter (function for compatibility)
 
     Args:
-        format_type: フォーマットタイプ
-        language: プログラミング言語名
+        format_type: Format type
+        language: Programming language name
 
     Returns:
-        テーブルフォーマッター
+        Table formatter
     """
     return TableFormatterFactory.create_formatter(language, format_type)