tree-sitter-analyzer 1.5.0__py3-none-any.whl → 1.6.1__py3-none-any.whl

tree_sitter_analyzer/__init__.py

@@ -11,7 +11,7 @@ Architecture:
 - Data Models: Generic and language-specific code element representations
 """
 
-__version__ = "1.5.0"
+__version__ = "1.6.1"
 __author__ = "aisheng.yu"
 __email__ = "aimasteracc@gmail.com"
 

tree_sitter_analyzer/cli_main.py

@@ -152,7 +152,9 @@ def create_argument_parser() -> argparse.ArgumentParser:
         help="Specify output format",
     )
     parser.add_argument(
-        "--table", choices=["full", "compact", "csv"], help="Output in table format"
+        "--table",
+        choices=["full", "compact", "csv", "json"],
+        help="Output in table format",
     )
     parser.add_argument(
         "--include-javadoc",

tree_sitter_analyzer/formatters/python_formatter.py

@@ -1,6 +1,10 @@
 #!/usr/bin/env python3
 """
 Python-specific table formatter.
+
+Provides specialized formatting for Python code analysis results,
+handling modern Python features like async/await, type hints, decorators,
+context managers, and framework-specific patterns.
 """
 
 from typing import Any
@@ -11,29 +15,58 @@ from .base_formatter import BaseTableFormatter
 class PythonTableFormatter(BaseTableFormatter):
     """Table formatter specialized for Python"""
 
+    def format(self, data: dict[str, Any]) -> str:
+        """Format data using the configured format type"""
+        return self.format_structure(data)
+
     def _format_full_table(self, data: dict[str, Any]) -> str:
         """Full table format for Python"""
         lines = []
 
-        # Header - Python (multi-class supported)
+        # Header - Python (module/package based)
+        file_path = data.get("file_path", "Unknown")
+        file_name = file_path.split("/")[-1].split("\\")[-1]
+        module_name = file_name.replace(".py", "").replace(".pyw", "").replace(".pyi", "")
+
+        # Check if this is a package module
         classes = data.get("classes", [])
-        if len(classes) > 1:
-            # If multiple classes exist, use filename
-            file_name = data.get("file_path", "Unknown").split("/")[-1].split("\\")[-1]
-            lines.append(f"# {file_name}")
+        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)
+        
+        if is_package:
+            lines.append(f"# Package: {module_name}")
+        elif is_script:
+            lines.append(f"# Script: {module_name}")
         else:
-            # Single class: use class name
-            class_name = classes[0].get("name", "Unknown") if classes else "Unknown"
-            lines.append(f"# {class_name}")
+            lines.append(f"# Module: {module_name}")
         lines.append("")
 
+        # Module docstring
+        module_docstring = self._extract_module_docstring(data)
+        if module_docstring:
+            lines.append("## Description")
+            lines.append(f'"{module_docstring}"')
+            lines.append("")
+
         # Imports
-        imports = data.get("imports", [])
         if imports:
             lines.append("## Imports")
             lines.append("```python")
             for imp in imports:
-                lines.append(str(imp.get("statement", "")))
+                import_statement = imp.get("raw_text", "")
+                if not import_statement:
+                    # Fallback construction
+                    module_name = imp.get("module_name", "")
+                    name = imp.get("name", "")
+                    if module_name:
+                        import_statement = f"from {module_name} import {name}"
+                    else:
+                        import_statement = f"import {name}"
+                lines.append(import_statement)
             lines.append("```")
             lines.append("")
 
@@ -112,12 +145,12 @@ class PythonTableFormatter(BaseTableFormatter):
                 )
             lines.append("")
 
-        # Methods - Python (no constructor separation)
-        methods = data.get("methods", [])
+        # Methods - Python (with decorators and async support)
+        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 | 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))
@@ -185,17 +218,41 @@ class PythonTableFormatter(BaseTableFormatter):
     def _format_method_row(self, method: dict[str, Any]) -> str:
         """Format a method table row for Python"""
         name = str(method.get("name", ""))
-        signature = self._create_full_signature(method)
-        visibility = self._convert_visibility(str(method.get("visibility", "")))
+        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", {})
-        lines_str = f"{line_range.get('start', 0)}-{line_range.get('end', 0)}"
+        if not line_range:
+            start_line = method.get("start_line", 0)
+            end_line = method.get("end_line", 0)
+            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("javadoc", "")))
+            self._extract_doc_summary(str(method.get("docstring", "")))
         )
-
-        return f"| {name} | {signature} | {visibility} | {lines_str} | {cols_str} | {complexity} | {doc} |"
+        
+        # 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"""
@@ -257,3 +314,87 @@ class PythonTableFormatter(BaseTableFormatter):
             type_name, type_name[:3] if len(type_name) > 3 else type_name
         )
         return str(result)
+
+    def _extract_module_docstring(self, data: dict[str, Any]) -> str | None:
+        """Extract module-level docstring"""
+        # Look for module docstring in the first few lines
+        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)):
+                    next_line = lines[j]
+                    if quote_type in next_line:
+                        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:
+        """Create Python method signature"""
+        params = method.get("parameters", [])
+        param_strs = []
+
+        for p in params:
+            if isinstance(p, dict):
+                param_name = p.get("name", "")
+                param_type = p.get("type", "")
+                if param_type:
+                    param_strs.append(f"{param_name}: {param_type}")
+                else:
+                    param_strs.append(param_name)
+            else:
+                param_strs.append(str(p))
+
+        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:
+            return f"({params_str})"
+
+    def _get_python_visibility_symbol(self, visibility: str) -> str:
+        """Get Python visibility symbol"""
+        visibility_map = {
+            "public": "🔓",
+            "private": "🔒", 
+            "protected": "🔐",
+            "magic": "✨",
+        }
+        return visibility_map.get(visibility, "🔓")
+
+    def _format_decorators(self, decorators: list[str]) -> str:
+        """Format Python decorators"""
+        if not decorators:
+            return "-"
+        
+        # Show important decorators
+        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})"