srcly 0.1.16__tar.gz → 0.1.18__tar.gz

{srcly-0.1.16 → srcly-0.1.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: srcly
-Version: 0.1.16
+Version: 0.1.18
 Summary: Interactive codebase treemap and metrics viewer.
 Requires-Python: >=3.13
 Requires-Dist: fastapi>=0.121.3
@@ -11,6 +11,7 @@ Requires-Dist: pydantic>=2.12.4
 Requires-Dist: pytest>=9.0.1
 Requires-Dist: tree-sitter-css==0.25.0
 Requires-Dist: tree-sitter-markdown<0.6.0,>=0.5.1
+Requires-Dist: tree-sitter-python==0.25.0
 Requires-Dist: tree-sitter-scss==1.0.0
 Requires-Dist: tree-sitter-typescript>=0.23.2
 Requires-Dist: tree-sitter>=0.25.2

{srcly-0.1.16 → srcly-0.1.18}/app/models.py

@@ -34,6 +34,10 @@ class Metrics(BaseModel):
     tsx_duplicated_string_count: int = 0
     ts_type_interface_count: int = 0
     ts_export_count: int = 0
+    
+    # Python-specific metrics
+    python_import_count: int = 0
+
     # Markdown-specific metrics
     md_data_url_count: int = 0
 

{srcly-0.1.16 → srcly-0.1.18}/app/routers/analysis.py

@@ -5,7 +5,8 @@ import os
 from typing import Dict, List, Optional, Tuple
 
 from app.models import Node, DependencyGraph, DependencyNode, DependencyEdge
-from app.services import analysis, cache, tree_sitter_analysis
+from app.services import analysis, cache
+from app.services.typescript import typescript_analysis
 from app.config import IGNORE_DIRS
 
 router = APIRouter(prefix="/api/analysis", tags=["analysis"])
@@ -333,7 +334,7 @@ async def get_dependencies(path: str = None):
     if not target_path.exists():
         raise HTTPException(status_code=404, detail="Path not found")
 
-    analyzer = tree_sitter_analysis.TreeSitterAnalyzer()
+    analyzer = typescript_analysis.TreeSitterAnalyzer()
     nodes = []
     edges = []
     

{srcly-0.1.16 → srcly-0.1.18}/app/routers/files.py

@@ -2,6 +2,8 @@ from fastapi import APIRouter, HTTPException, Query
 from pathlib import Path
 from fastapi.responses import PlainTextResponse
 
+from app.services.analysis import get_ipynb_analyzer
+
 router = APIRouter(prefix="/api/files", tags=["files"])
 
 @router.get("/content", response_class=PlainTextResponse)
@@ -21,6 +23,8 @@ async def get_file_content(path: str = Query(..., description="Absolute path to
     # For this local tool, we'll allow reading any file as requested, but maybe warn?
     
     try:
+        if file_path.suffix == ".ipynb":
+            return get_ipynb_analyzer().get_virtual_content(str(file_path))
         return file_path.read_text(encoding="utf-8")
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Failed to read file: {str(e)}")

{srcly-0.1.16 → srcly-0.1.18}/app/services/analysis.py

@@ -5,10 +5,10 @@ from pathlib import Path
 
 from app.models import Node, Metrics
 from app.config import IGNORE_DIRS, IGNORE_FILES, IGNORE_EXTENSIONS
-from app.services.tree_sitter_analysis import TreeSitterAnalyzer
-from app.services.markdown_analysis import MarkdownTreeSitterAnalyzer
-from app.services.ipynb_analysis import NotebookAnalyzer
-from app.services.css_analysis import CssTreeSitterAnalyzer
+from app.services.typescript.typescript_analysis import TreeSitterAnalyzer
+from app.services.markdown.markdown_analysis import MarkdownTreeSitterAnalyzer
+from app.services.ipynb.ipynb_analysis import NotebookAnalyzer
+from app.services.css.css_analysis import CssTreeSitterAnalyzer
 from pathspec import PathSpec
 
 # Maximum time allowed for analyzing a single file in a worker process.
@@ -47,6 +47,14 @@ def get_css_analyzer():
         _css_analyzer = CssTreeSitterAnalyzer()
     return _css_analyzer
 
+_python_analyzer = None
+def get_python_analyzer():
+    global _python_analyzer
+    if _python_analyzer is None:
+        from app.services.python.python_analysis import PythonTreeSitterAnalyzer
+        _python_analyzer = PythonTreeSitterAnalyzer()
+    return _python_analyzer
+
 def find_repo_root(start_path: Path) -> Path:
     current = start_path.resolve()
     for parent in [current, *current.parents]:
@@ -99,6 +107,9 @@ def attach_file_metrics(node: Node, file_info) -> None:
         node.metrics.todo_count = file_info.todo_count
         node.metrics.classes_count = file_info.classes_count
     
+    if hasattr(file_info, 'python_import_count'):
+        node.metrics.python_import_count = file_info.python_import_count
+    
     # Set start/end line for the file (approximate, 1 to total lines)
     # We don't strictly have this from lizard always, but we can infer or leave 0.
     # For now, let's leave file start/end as 0 unless we want to read the file.
@@ -368,6 +379,12 @@ def aggregate_metrics(node: Node) -> Metrics:
         total_type_interface_count += child_metrics.ts_type_interface_count
         total_export_count += child_metrics.ts_export_count
         total_md_data_url_count += child_metrics.md_data_url_count
+        if hasattr(child_metrics, 'python_import_count'):
+             # Metric model has it, but child_metrics is a Metrics object so it should have it
+             total_python_import_count = getattr(child_metrics, 'python_import_count', 0)
+             # Should we add a local var for this? Yes
+             pass
+        
         
         # Reconstruct total function loc from average * count
         total_function_loc += (child_metrics.average_function_length * child_metrics.function_count)
@@ -393,8 +410,10 @@ def aggregate_metrics(node: Node) -> Metrics:
         node.metrics.classes_count = total_classes_count
         node.metrics.average_function_length = total_function_loc / total_funcs if total_funcs > 0 else 0.0
         node.metrics.ts_type_interface_count = total_type_interface_count
+        node.metrics.ts_type_interface_count = total_type_interface_count
         node.metrics.ts_export_count = total_export_count
         node.metrics.md_data_url_count = total_md_data_url_count
+        node.metrics.python_import_count = total_python_import_count
     
     return node.metrics
 
@@ -416,6 +435,12 @@ def analyze_single_file(file_path: str):
         if file_path.endswith(".ipynb"):
             analyzer = get_ipynb_analyzer()
             return analyzer.analyze_file(file_path)
+        if file_path.endswith(".py"):
+             # We can cache it similarly if we want, or just instantiate. 
+             # For consistency let's add a getter or just instantiate for now to avoid circular imports / global clutter
+             # actually lets follow pattern
+             return get_python_analyzer().analyze_file(file_path)
+            
         return lizard.analyze_file(file_path)
     except Exception as e:
         # Return error info instead of crashing

srcly-0.1.18/app/services/analysis_types.py

@@ -0,0 +1,61 @@
+from dataclasses import dataclass, field
+from typing import List
+
+@dataclass
+class FunctionMetrics:
+    name: str
+    cyclomatic_complexity: int
+    nloc: int
+    start_line: int
+    end_line: int
+    parameter_count: int = 0
+    max_nesting_depth: int = 0
+    comment_lines: int = 0
+    todo_count: int = 0
+    # TS/TSX Specific Metrics (per-function)
+    ts_type_interface_count: int = 0
+    # Markdown-specific metrics
+    md_data_url_count: int = 0
+    # TSX structure helpers
+    contains_tsx: bool = False
+    tsx_start_line: int = 0
+    tsx_end_line: int = 0
+    tsx_root_name: str = ""
+    tsx_root_is_fragment: bool = False
+    origin_type: str = ""
+    is_jsx_container: bool = False
+    children: List["FunctionMetrics"] = field(default_factory=list)
+    # We store children to represent nested functions.
+
+@dataclass
+class FileMetrics:
+    nloc: int
+    average_cyclomatic_complexity: float
+    function_list: List[FunctionMetrics] = field(default_factory=list)
+    filename: str = ""
+    comment_lines: int = 0
+    comment_density: float = 0.0
+    max_nesting_depth: int = 0
+    average_function_length: float = 0.0
+    parameter_count: int = 0
+    todo_count: int = 0
+    classes_count: int = 0
+    
+    # TS/TSX Specific Metrics
+    tsx_nesting_depth: int = 0
+    tsx_render_branching_count: int = 0
+    tsx_react_use_effect_count: int = 0
+    tsx_anonymous_handler_count: int = 0
+    tsx_prop_count: int = 0
+    ts_any_usage_count: int = 0
+    ts_ignore_count: int = 0
+    ts_import_coupling_count: int = 0
+    tsx_hardcoded_string_volume: int = 0
+    tsx_duplicated_string_count: int = 0
+    ts_type_interface_count: int = 0
+    ts_type_interface_count: int = 0
+    ts_export_count: int = 0
+    # Python-specific metrics
+    python_import_count: int = 0
+    # Markdown-specific metrics (per-file)
+    md_data_url_count: int = 0

{srcly-0.1.16/app/services → srcly-0.1.18/app/services/css}/css_analysis.py

@@ -5,7 +5,7 @@ import tree_sitter_css as tscss
 import tree_sitter_scss as tsscss
 from tree_sitter import Language, Node, Parser
 
-from app.services.tree_sitter_analysis import FileMetrics, FunctionMetrics
+from app.services.analysis_types import FileMetrics, FunctionMetrics
 
 
 CSS_LANGUAGE = Language(tscss.language())

{srcly-0.1.16 → srcly-0.1.18}/app/services/data_flow_analysis.py

@@ -4,7 +4,7 @@ from dataclasses import dataclass, field
 from typing import List, Dict, Optional, Any
 import uuid
 
-from app.services.tree_sitter_analysis import TreeSitterAnalyzer
+from app.services.typescript.typescript_analysis import TreeSitterAnalyzer
 
 # Load TypeScript and TSX grammars
 TYPESCRIPT_LANGUAGE = Language(tstypescript.language_typescript())

{srcly-0.1.16/app/services → srcly-0.1.18/app/services/ipynb}/ipynb_analysis.py

@@ -1,7 +1,7 @@
 import json
 from typing import List
 
-from app.services.tree_sitter_analysis import FileMetrics, FunctionMetrics
+from app.services.analysis_types import FileMetrics, FunctionMetrics
 
 
 class NotebookAnalyzer:
@@ -86,4 +86,44 @@ class NotebookAnalyzer:
             # TS/TSX-specific metrics remain at their defaults (all zeros) for notebooks.
         )
 
+    def _get_non_empty_lines(self, cells: list) -> list[str]:
+        """
+        Helper to extract all non-empty lines from valid cells, exactly as
+        analyze_file does for counting LOC.
+        """
+        all_lines = []
+        for cell in cells:
+            source = cell.get("source", "")
+            if isinstance(source, list):
+                text = "".join(source)
+            else:
+                text = str(source)
+            
+            lines = text.splitlines()
+            non_empty = [ln for ln in lines if ln.strip()]
+            
+            # analyze_file skips cells with 0 LOC entirely
+            if not non_empty:
+                continue
+                
+            all_lines.extend(non_empty)
+            
+        return all_lines
+
+    def get_virtual_content(self, file_path: str) -> str:
+        """
+        Returns the "virtual" file content that corresponds to the
+        analysis metrics (line numbers, etc).
+        
+        For notebooks, this is the concatenation of all non-empty
+        lines from all cells, joined by newlines.
+        """
+        with open(file_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+
+        cells = data.get("cells") or []
+        lines = self._get_non_empty_lines(cells)
+        return "\n".join(lines)
+
+
 

{srcly-0.1.16/app/services → srcly-0.1.18/app/services/markdown}/markdown_analysis.py

@@ -4,7 +4,7 @@ from typing import List
 import tree_sitter_markdown as tsmarkdown
 from tree_sitter import Language, Node, Parser
 
-from app.services.tree_sitter_analysis import FileMetrics, FunctionMetrics
+from app.services.analysis_types import FileMetrics, FunctionMetrics
 
 
 MARKDOWN_LANGUAGE = Language(tsmarkdown.language())

srcly-0.1.18/app/services/python/python_analysis.py

@@ -0,0 +1,249 @@
+import tree_sitter_python as tspython
+from tree_sitter import Language, Parser, Node
+from typing import List, Tuple
+
+from app.services.analysis_types import FileMetrics, FunctionMetrics
+
+# Load Python grammar
+PYTHON_LANGUAGE = Language(tspython.language())
+
+class PythonTreeSitterAnalyzer:
+    def __init__(self):
+        self.parser = Parser(PYTHON_LANGUAGE)
+
+    def analyze_file(self, file_path: str) -> FileMetrics: # dictionary or FileMetrics? based on other analyzers it returns FileMetrics
+        with open(file_path, 'rb') as f:
+            content = f.read()
+
+        tree = self.parser.parse(content)
+        
+        lines = content.splitlines()
+        nloc = len([l for l in lines if l.strip()])
+
+        # Extract functions, classes, and other scopes
+        functions = self._extract_scopes(tree.root_node)
+
+        avg_complexity = 0.0
+        if functions:
+            avg_complexity = sum(f.cyclomatic_complexity for f in functions) / len(functions)
+
+        # Calculate file-level metrics
+        comment_lines, todo_count = self._count_comments_and_todos(tree.root_node)
+        comment_density = comment_lines / nloc if nloc > 0 else 0.0
+        
+        max_nesting_depth = self._calculate_max_nesting_depth(tree.root_node)
+        classes_count = self._count_classes(tree.root_node)
+        
+        # New metrics specific to Python or general
+        # Replicating TS metrics where applicable
+        
+        # Aggregate function metrics
+        total_function_length = sum(f.nloc for f in functions)
+        average_function_length = total_function_length / len(functions) if functions else 0.0
+        parameter_count = sum(f.parameter_count for f in functions)
+
+        return FileMetrics(
+            nloc=nloc,
+            average_cyclomatic_complexity=avg_complexity,
+            function_list=functions,
+            filename=file_path,
+            comment_lines=comment_lines,
+            comment_density=comment_density,
+            max_nesting_depth=max_nesting_depth,
+            average_function_length=average_function_length,
+            parameter_count=parameter_count,
+            todo_count=todo_count,
+            classes_count=classes_count,
+            # Initialize other fields to valid defaults
+            tsx_nesting_depth=0,
+            tsx_render_branching_count=0,
+            tsx_react_use_effect_count=0,
+            tsx_anonymous_handler_count=0,
+            tsx_prop_count=0,
+            ts_any_usage_count=0,
+            ts_ignore_count=0,
+            ts_import_coupling_count=0,
+            python_import_count=self._count_imports(tree.root_node),
+            tsx_hardcoded_string_volume=0,
+            tsx_duplicated_string_count=0,
+            ts_type_interface_count=0,
+            ts_export_count=0,
+            md_data_url_count=0
+        )
+
+    def _extract_scopes(self, root_node: Node) -> List[FunctionMetrics]:
+        # We want to capture:
+        # - Functions (def)
+        # - Classes (class)
+        # - Lambdas (lambda)
+        
+        scope_types = {
+            'function_definition',
+            'class_definition',
+            'lambda',
+            'async_function_definition'
+        }
+
+        def process_node(node: Node) -> List[FunctionMetrics]:
+            results = []
+            for child in node.children:
+                if child.type in scope_types:
+                    metrics = self._calculate_scope_metrics(child)
+                    metrics.children = process_node(child)
+                    results.append(metrics)
+                else:
+                    # Recurse but don't create scope
+                    results.extend(process_node(child))
+            return results
+
+        return process_node(root_node)
+
+    def _calculate_scope_metrics(self, node: Node) -> FunctionMetrics:
+        name = self._get_scope_name(node)
+        start_line = node.start_point.row + 1
+        end_line = node.end_point.row + 1
+        nloc = end_line - start_line + 1
+        
+        complexity = self._calculate_complexity(node)
+        parameter_count = self._count_parameters(node)
+        max_nesting_depth = self._calculate_max_nesting_depth(node)
+        comment_lines, todo_count = self._count_comments_and_todos(node)
+
+        return FunctionMetrics(
+            name=name,
+            cyclomatic_complexity=complexity,
+            nloc=nloc,
+            start_line=start_line,
+            end_line=end_line,
+            parameter_count=parameter_count,
+            max_nesting_depth=max_nesting_depth,
+            comment_lines=comment_lines,
+            todo_count=todo_count,
+            origin_type=node.type
+        )
+
+    def _get_scope_name(self, node: Node) -> str:
+        if node.type in {'function_definition', 'class_definition', 'async_function_definition'}:
+            name_node = node.child_by_field_name('name')
+            if name_node:
+                prefix = ""
+                if node.type == 'class_definition': prefix = "(class) "
+                if node.type == 'async_function_definition': prefix = "(async) "
+                return f"{prefix}{name_node.text.decode('utf-8')}"
+        
+        elif node.type == 'lambda':
+            return "(lambda)"
+            
+        return "(anonymous)"
+
+    def _calculate_complexity(self, node: Node) -> int:
+        complexity = 1
+        complexity_node_types = {
+            'if_statement',
+            'for_statement',
+            'while_statement',
+            'except_clause',
+            'with_statement', 
+            'match_statement',
+            'case_pattern'
+            # try_statement itself is not usually a branch, except_clauses are
+        }
+        
+        scope_boundary_types = {
+            'function_definition',
+            'class_definition',
+            'lambda',
+            'async_function_definition'
+        }
+
+        def traverse(n: Node):
+            nonlocal complexity
+            # Stop if we hit a nested function/class scope (metrics are calculated separately for them)
+            if n != node and n.type in scope_boundary_types:
+                return
+            
+            if n.type in complexity_node_types:
+                complexity += 1
+            
+            # Check for boolean operators
+            if n.type == 'boolean_operator':
+                text = n.text.decode('utf-8')
+                if 'and' in text or 'or' in text:
+                    complexity += 1
+            
+            for child in n.children:
+                traverse(child)
+
+        traverse(node)
+        return complexity
+
+    def _count_comments_and_todos(self, node: Node) -> Tuple[int, int]:
+        comment_lines = 0
+        todo_count = 0
+        
+        def traverse(n: Node):
+            nonlocal comment_lines, todo_count
+            if n.type == 'comment':
+                comment_lines += (n.end_point.row - n.start_point.row + 1)
+                text = n.text.decode('utf-8', errors='ignore')
+                if 'TODO' in text or 'FIXME' in text:
+                    todo_count += 1
+            for child in n.children:
+                traverse(child)
+        
+        traverse(node)
+        return comment_lines, todo_count
+
+    def _calculate_max_nesting_depth(self, node: Node) -> int:
+        max_depth = 0
+        nesting_types = {
+            'if_statement', 'for_statement', 'while_statement', 'try_statement', 'with_statement', 'match_statement'
+            # function/class are also nesting, but we treat them as scopes usually
+        }
+        
+        def traverse(n: Node, current_depth: int):
+            nonlocal max_depth
+            max_depth = max(max_depth, current_depth)
+            for child in n.children:
+                next_depth = current_depth
+                if child.type in nesting_types:
+                    next_depth += 1
+                traverse(child, next_depth)
+                
+        traverse(node, 0)
+        return max_depth
+
+    def _count_classes(self, node: Node) -> int:
+        count = 0
+        def traverse(n: Node):
+            nonlocal count
+            if n.type == 'class_definition':
+                count += 1
+            for child in n.children:
+                traverse(child)
+        traverse(node)
+        return count
+
+    def _count_parameters(self, node: Node) -> int:
+        # Check for 'parameters' field
+        params_node = node.child_by_field_name('parameters') 
+
+        if params_node:
+            count = 0
+            for child in params_node.children:
+                # Filter punctuation
+                if child.type in {'identifier', 'typed_parameter', 'default_parameter', 'typed_default_parameter', 'list_splat_pattern', 'dictionary_splat_pattern'}:
+                     count += 1
+            return count
+        return 0
+
+    def _count_imports(self, node: Node) -> int:
+        count = 0
+        def traverse(n: Node):
+            nonlocal count
+            if n.type == 'import_statement' or n.type == 'import_from_statement':
+                count += 1
+            for child in n.children:
+                traverse(child)
+        traverse(node)
+        return count

srcly-0.1.16/app/services/tree_sitter_analysis.py → srcly-0.1.18/app/services/typescript/typescript_analysis.py

@@ -1,68 +1,12 @@
 import tree_sitter_typescript as tstypescript
 from tree_sitter import Language, Parser, Node
-from dataclasses import dataclass, field
 from typing import List
-import re
 
 # Load TypeScript and TSX grammars
 TYPESCRIPT_LANGUAGE = Language(tstypescript.language_typescript())
 TSX_LANGUAGE = Language(tstypescript.language_tsx())
 
-@dataclass
-class FunctionMetrics:
-    name: str
-    cyclomatic_complexity: int
-    nloc: int
-    start_line: int
-    end_line: int
-    parameter_count: int = 0
-    max_nesting_depth: int = 0
-    comment_lines: int = 0
-    todo_count: int = 0
-    # TS/TSX Specific Metrics (per-function)
-    ts_type_interface_count: int = 0
-    # Markdown-specific metrics
-    md_data_url_count: int = 0
-    # TSX structure helpers
-    contains_tsx: bool = False
-    tsx_start_line: int = 0
-    tsx_end_line: int = 0
-    tsx_root_name: str = ""
-    tsx_root_is_fragment: bool = False
-    origin_type: str = ""
-    is_jsx_container: bool = False
-    children: List["FunctionMetrics"] = field(default_factory=list)
-    # We store children to represent nested functions.
-
-@dataclass
-class FileMetrics:
-    nloc: int
-    average_cyclomatic_complexity: float
-    function_list: List[FunctionMetrics] = field(default_factory=list)
-    filename: str = ""
-    comment_lines: int = 0
-    comment_density: float = 0.0
-    max_nesting_depth: int = 0
-    average_function_length: float = 0.0
-    parameter_count: int = 0
-    todo_count: int = 0
-    classes_count: int = 0
-    
-    # TS/TSX Specific Metrics
-    tsx_nesting_depth: int = 0
-    tsx_render_branching_count: int = 0
-    tsx_react_use_effect_count: int = 0
-    tsx_anonymous_handler_count: int = 0
-    tsx_prop_count: int = 0
-    ts_any_usage_count: int = 0
-    ts_ignore_count: int = 0
-    ts_import_coupling_count: int = 0
-    tsx_hardcoded_string_volume: int = 0
-    tsx_duplicated_string_count: int = 0
-    ts_type_interface_count: int = 0
-    ts_export_count: int = 0
-    # Markdown-specific metrics (per-file)
-    md_data_url_count: int = 0
+from app.services.analysis_types import FileMetrics, FunctionMetrics
 
 class TreeSitterAnalyzer:
     def __init__(self):