code2llm 0.5.29__tar.gz → 0.5.30__tar.gz

{code2llm-0.5.29 → code2llm-0.5.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2llm
-Version: 0.5.29
+Version: 0.5.30
 Summary: High-performance Python code flow analysis with optimized TOON format - CFG, DFG, call graphs, and intelligent code queries
 Home-page: https://github.com/wronai/stts
 Author: STTS Project

{code2llm-0.5.29 → code2llm-0.5.30}/code2llm/__init__.py

@@ -8,25 +8,13 @@ Includes NLP Processing Pipeline for query normalization, intent matching,
 and entity resolution with multilingual support.
 """
 
-__version__ = "0.5.29"
+__version__ = "0.5.30"
 __author__ = "STTS Project"
 
-# Core analysis components
-from .core.analyzer import ProjectAnalyzer
+# Core analysis components (lightweight, always needed)
 from .core.config import Config, FAST_CONFIG
 from .core.models import AnalysisResult, FunctionInfo, ClassInfo, Pattern
 
-# NLP Processing Pipeline
-from .nlp import (
-    NLPPipeline,
-    QueryNormalizer,
-    IntentMatcher,
-    EntityResolver,
-    NLPConfig,
-    FAST_NLP_CONFIG,
-    PRECISE_NLP_CONFIG,
-)
-
 __all__ = [
     # Core
     "ProjectAnalyzer",
@@ -45,3 +33,20 @@ __all__ = [
     "FAST_NLP_CONFIG",
     "PRECISE_NLP_CONFIG",
 ]
+
+
+def __getattr__(name):
+    """Lazy import heavy modules on first access."""
+    if name == "ProjectAnalyzer":
+        from .core.analyzer import ProjectAnalyzer
+        return ProjectAnalyzer
+    
+    _nlp_names = {
+        "NLPPipeline", "QueryNormalizer", "IntentMatcher",
+        "EntityResolver", "NLPConfig", "FAST_NLP_CONFIG", "PRECISE_NLP_CONFIG",
+    }
+    if name in _nlp_names:
+        from . import nlp
+        return getattr(nlp, name)
+    
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

code2llm-0.5.30/code2llm/analysis/__init__.py

@@ -0,0 +1,33 @@
+"""Analysis package for code2llm."""
+
+__all__ = [
+    'CFGExtractor',
+    'DFGExtractor',
+    'CallGraphExtractor',
+    'CouplingAnalyzer',
+    'SmellDetector',
+    'DataAnalyzer',
+    'TypeInferenceEngine',
+    'SideEffectDetector',
+    'PipelineDetector',
+]
+
+
+def __getattr__(name):
+    """Lazy import analysis modules on first access."""
+    _imports = {
+        'CFGExtractor': '.cfg',
+        'DFGExtractor': '.dfg',
+        'CallGraphExtractor': '.call_graph',
+        'CouplingAnalyzer': '.coupling',
+        'SmellDetector': '.smells',
+        'DataAnalyzer': '.data_analysis',
+        'TypeInferenceEngine': '.type_inference',
+        'SideEffectDetector': '.side_effects',
+        'PipelineDetector': '.pipeline_detector',
+    }
+    if name in _imports:
+        import importlib
+        module = importlib.import_module(_imports[name], __package__)
+        return getattr(module, name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

{code2llm-0.5.29 → code2llm-0.5.30}/code2llm/analysis/call_graph.py

@@ -2,7 +2,6 @@
 
 import ast
 from typing import Optional, Set, List, Dict
-import astroid
 
 from ..core.config import Config
 from ..core.models import AnalysisResult, FlowEdge
@@ -32,9 +31,10 @@ class CallGraphExtractor(ast.NodeVisitor):
         self.class_stack = []
         self.imports = {}
         
-        # Try to get astroid tree for better resolution
+        # Try to get astroid tree for better resolution (lazy import - heavy module)
         try:
-            self.astroid_tree = astroid.MANAGER.ast_from_file(file_path)
+            import astroid as _astroid
+            self.astroid_tree = _astroid.MANAGER.ast_from_file(file_path)
         except Exception:
             self.astroid_tree = None
             
@@ -188,7 +188,8 @@ class CallGraphExtractor(ast.NodeVisitor):
         try:
             # Find the corresponding astroid node by line/col
             # This is a bit slow but robust
-            for astroid_node in self.astroid_tree.nodes_of_class(astroid.Call):
+            import astroid as _astroid
+            for astroid_node in self.astroid_tree.nodes_of_class(_astroid.Call):
                 if astroid_node.lineno == node.lineno and astroid_node.col_offset == node.col_offset:
                     # Infer the targets
                     inferred = astroid_node.func.infer()

code2llm-0.5.30/code2llm/core/__init__.py

@@ -0,0 +1,44 @@
+"""Core analysis components for code2llm."""
+
+from .config import Config, FAST_CONFIG, PerformanceConfig, FilterConfig
+from .models import (
+    AnalysisResult, FlowNode, FlowEdge, 
+    FunctionInfo, ClassInfo, ModuleInfo, Pattern
+)
+
+__all__ = [
+    'ProjectAnalyzer',
+    'StreamingAnalyzer',
+    'IncrementalAnalyzer',
+    'ScanStrategy',
+    'SmartPrioritizer',
+    'STRATEGY_QUICK',
+    'STRATEGY_STANDARD',
+    'STRATEGY_DEEP',
+    'FileCache',
+    'FastFileFilter',
+    'Config',
+    'FAST_CONFIG',
+    'AnalysisResult',
+    'FunctionInfo',
+    'ClassInfo',
+    'ModuleInfo',
+]
+
+
+def __getattr__(name):
+    """Lazy import heavy modules on first access."""
+    _analyzer_names = {'ProjectAnalyzer', 'FileCache', 'FastFileFilter'}
+    if name in _analyzer_names:
+        from . import analyzer as _mod
+        return getattr(_mod, name)
+    
+    _streaming_names = {
+        'StreamingAnalyzer', 'IncrementalAnalyzer', 'ScanStrategy',
+        'SmartPrioritizer', 'STRATEGY_QUICK', 'STRATEGY_STANDARD', 'STRATEGY_DEEP',
+    }
+    if name in _streaming_names:
+        from . import streaming_analyzer as _mod
+        return getattr(_mod, name)
+    
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

{code2llm-0.5.29 → code2llm-0.5.30}/code2llm/core/core/file_analyzer.py

@@ -22,6 +22,7 @@ class FileAnalyzer:
     def __init__(self, config: Config, cache=None):
         self.config = config
         self.cache = cache
+        self._file_filter = FastFileFilter(config.filters)
         self.stats = {
             'files_processed': 0,
             'functions_found': 0,
@@ -180,8 +181,7 @@ class FileAnalyzer:
             for d in node.decorator_list
         )
         
-        filter_obj = FastFileFilter(self.config.filters)
-        if filter_obj.should_skip_function(line_count, is_private, is_property):
+        if self._file_filter.should_skip_function(line_count, is_private, is_property):
             return
         
         # Create function info

{code2llm-0.5.29 → code2llm-0.5.30}/code2llm/core/core/refactoring.py

@@ -1,15 +1,10 @@
 """Refactoring analysis for code2llm."""
 
-import networkx as nx
-import vulture
 from pathlib import Path
 from typing import Optional
 
 from ..config import Config
 from ..models import AnalysisResult
-from ...analysis.call_graph import CallGraphExtractor
-from ...analysis.coupling import CouplingAnalyzer
-from ...analysis.smells import SmellDetector
 from .file_filter import FastFileFilter
 
 
@@ -26,6 +21,7 @@ class RefactoringAnalyzer:
             print("Performing refactoring analysis...")
             
         # 1. Calculate metrics (fan-in/fan-out)
+        from ...analysis.call_graph import CallGraphExtractor
         cg_ext = CallGraphExtractor(self.config)
         cg_ext.result = result
         cg_ext._calculate_metrics()
@@ -54,8 +50,9 @@ class RefactoringAnalyzer:
         if self.config.verbose:
             print(f"  Detected {len(result.smells)} code smells")
 
-    def _build_call_graph(self, result: AnalysisResult) -> nx.DiGraph:
+    def _build_call_graph(self, result: AnalysisResult):
         """Build networkx call graph."""
+        import networkx as nx
         G = nx.DiGraph()
         for func_name, func_info in result.functions.items():
             G.add_node(func_name)
@@ -63,7 +60,7 @@ class RefactoringAnalyzer:
                 G.add_edge(func_name, callee)
         return G
 
-    def _calculate_centrality(self, call_graph: nx.DiGraph, result: AnalysisResult) -> None:
+    def _calculate_centrality(self, call_graph, result: AnalysisResult) -> None:
         """Calculate betweenness centrality for bottleneck detection."""
         if len(call_graph) > 0:
             try:
@@ -74,8 +71,10 @@ class RefactoringAnalyzer:
                         print(f"  Large graph ({node_count} nodes), using sampled centrality...")
                     # Sample 20% of nodes, max 500
                     k = min(int(node_count * 0.2), 500)
+                    import networkx as nx
                     centrality = nx.betweenness_centrality(call_graph, k=k)
                 else:
+                    import networkx as nx
                     centrality = nx.betweenness_centrality(call_graph)
                 for func_name, score in centrality.items():
                     if func_name in result.functions:
@@ -84,7 +83,7 @@ class RefactoringAnalyzer:
                 if self.config.verbose:
                     print(f"Error calculating centrality: {e}")
 
-    def _detect_cycles(self, call_graph: nx.DiGraph, result: AnalysisResult) -> None:
+    def _detect_cycles(self, call_graph, result: AnalysisResult) -> None:
         """Detect circular dependencies."""
         try:
             # Limit cycle detection for large graphs
@@ -92,6 +91,7 @@ class RefactoringAnalyzer:
                 if self.config.verbose:
                     print(f"  Skipping cycle detection for large graph ({len(call_graph)} nodes)")
                 return
+            import networkx as nx
             cycles = list(nx.simple_cycles(call_graph))
             if cycles:
                 result.metrics["project"] = result.metrics.get("project", {})
@@ -100,7 +100,7 @@ class RefactoringAnalyzer:
             if self.config.verbose:
                 print(f"Error detecting cycles: {e}")
 
-    def _detect_communities(self, call_graph: nx.DiGraph, result: AnalysisResult) -> None:
+    def _detect_communities(self, call_graph, result: AnalysisResult) -> None:
         """Detect communities (module groups)."""
         try:
             # Limit community detection for large graphs
@@ -122,11 +122,13 @@ class RefactoringAnalyzer:
 
     def _analyze_coupling(self, result: AnalysisResult) -> None:
         """Analyze coupling between modules."""
+        from ...analysis.coupling import CouplingAnalyzer
         coupling_analyzer = CouplingAnalyzer(result)
         coupling_analyzer.analyze()
 
     def _detect_smells(self, result: AnalysisResult) -> None:
         """Detect code smells."""
+        from ...analysis.smells import SmellDetector
         smell_detector = SmellDetector(result)
         smell_detector.detect()
 
@@ -136,6 +138,7 @@ class RefactoringAnalyzer:
             print("Detecting dead code with vulture...")
             
         try:
+            import vulture
             v = vulture.Vulture(verbose=False)
             
             # vulture.scan takes the code content as a string

{code2llm-0.5.29 → code2llm-0.5.30}/code2llm/nlp/__init__.py

@@ -4,7 +4,7 @@ Provides query normalization, intent matching, and entity resolution
 with multilingual support and fuzzy matching.
 """
 
-__version__ = "0.5.29"
+__version__ = "0.5.30"
 
 from .pipeline import NLPPipeline
 from .normalization import QueryNormalizer

{code2llm-0.5.29 → code2llm-0.5.30}/code2llm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2llm
-Version: 0.5.29
+Version: 0.5.30
 Summary: High-performance Python code flow analysis with optimized TOON format - CFG, DFG, call graphs, and intelligent code queries
 Home-page: https://github.com/wronai/stts
 Author: STTS Project

{code2llm-0.5.29 → code2llm-0.5.30}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code2llm"
-version = "0.5.29"
+version = "0.5.30"
 description = "High-performance Python code flow analysis with optimized TOON format - CFG, DFG, call graphs, and intelligent code queries"
 readme = "README.md"
 requires-python = ">=3.8"

code2llm-0.5.29/code2llm/analysis/__init__.py

@@ -1,23 +0,0 @@
-"""Analysis package for code2llm."""
-
-from .cfg import CFGExtractor
-from .dfg import DFGExtractor
-from .call_graph import CallGraphExtractor
-from .coupling import CouplingAnalyzer
-from .smells import SmellDetector
-from .data_analysis import DataAnalyzer
-from .type_inference import TypeInferenceEngine
-from .side_effects import SideEffectDetector
-from .pipeline_detector import PipelineDetector
-
-__all__ = [
-    'CFGExtractor',
-    'DFGExtractor',
-    'CallGraphExtractor',
-    'CouplingAnalyzer',
-    'SmellDetector',
-    'DataAnalyzer',
-    'TypeInferenceEngine',
-    'SideEffectDetector',
-    'PipelineDetector',
-]

code2llm-0.5.29/code2llm/core/__init__.py

@@ -1,36 +0,0 @@
-"""Core analysis components for code2llm."""
-
-from .analyzer import ProjectAnalyzer, FileCache, FastFileFilter
-from .streaming_analyzer import (
-    StreamingAnalyzer, 
-    IncrementalAnalyzer,
-    ScanStrategy,
-    SmartPrioritizer,
-    STRATEGY_QUICK,
-    STRATEGY_STANDARD,
-    STRATEGY_DEEP
-)
-from .config import Config, FAST_CONFIG, PerformanceConfig, FilterConfig
-from .models import (
-    AnalysisResult, FlowNode, FlowEdge, 
-    FunctionInfo, ClassInfo, ModuleInfo, Pattern
-)
-
-__all__ = [
-    'ProjectAnalyzer',
-    'StreamingAnalyzer',
-    'IncrementalAnalyzer',
-    'ScanStrategy',
-    'SmartPrioritizer',
-    'STRATEGY_QUICK',
-    'STRATEGY_STANDARD',
-    'STRATEGY_DEEP',
-    'FileCache',
-    'FastFileFilter',
-    'Config',
-    'FAST_CONFIG',
-    'AnalysisResult',
-    'FunctionInfo',
-    'ClassInfo',
-    'ModuleInfo',
-]