code2llm 0.3.7__py3-none-any.whl

code2flow/core/config.py

@@ -0,0 +1,177 @@
+"""Configuration and constants for code2flow."""
+
+from dataclasses import dataclass, field
+from typing import List, Set
+from enum import Enum
+
+
+class AnalysisMode(str, Enum):
+    """Available analysis modes."""
+    STATIC = "static"
+    DYNAMIC = "dynamic"
+    HYBRID = "hybrid"
+    BEHAVIORAL = "behavioral"
+    REVERSE = "reverse"
+
+
+@dataclass
+class PerformanceConfig:
+    """Performance optimization settings."""
+    enable_cache: bool = True
+    cache_dir: str = ".code2flow_cache"
+    cache_ttl_hours: int = 24
+    parallel_workers: int = 4
+    parallel_enabled: bool = True
+    max_memory_mb: int = 2048
+    max_nodes_per_file: int = 1000
+    max_total_nodes: int = 10000
+    max_edges: int = 50000
+    fast_mode: bool = False
+    skip_data_flow: bool = False
+    skip_pattern_detection: bool = False
+
+
+@dataclass
+class FilterConfig:
+    """Filtering options to reduce analysis scope."""
+    exclude_tests: bool = True
+    exclude_patterns: List[str] = field(default_factory=lambda: [
+        "*test*", "*__pycache__*", "*.pyc", "*venv*", "*.venv*",
+        "*node_modules*", "*.git*", "*build*", "*dist*",
+        "*_test.py", "test_*.py", "conftest.py"
+    ])
+    include_patterns: List[str] = field(default_factory=list)
+    min_function_lines: int = 1
+    skip_private: bool = False
+    skip_properties: bool = True
+    skip_accessors: bool = True
+
+
+@dataclass
+class DepthConfig:
+    """Depth limiting for control flow analysis."""
+    max_cfg_depth: int = 5
+    max_call_depth: int = 3
+    max_data_flow_depth: int = 2
+    max_interprocedural_depth: int = 2
+
+
+@dataclass
+class OutputConfig:
+    """Output formatting options."""
+    compact: bool = True
+    include_source: bool = False
+    max_label_length: int = 50
+    group_by_module: bool = True
+
+
+@dataclass
+class Config:
+    """Analysis configuration with performance optimizations."""
+    
+    # Analysis mode
+    mode: str = "hybrid"
+    
+    # Sub-configs for performance
+    performance: PerformanceConfig = field(default_factory=PerformanceConfig)
+    filters: FilterConfig = field(default_factory=FilterConfig)
+    depth: DepthConfig = field(default_factory=DepthConfig)
+    output: OutputConfig = field(default_factory=OutputConfig)
+    
+    # Legacy path limits (for compatibility)
+    max_paths_per_function: int = 20
+    max_depth_enumeration: int = 10
+    max_depth_interprocedural: int = 3
+    max_total_paths: int = 1000
+    
+    # Output settings
+    output_formats: List[str] = field(default_factory=lambda: ["yaml", "mermaid", "png"])
+    output_dir: str = "output"
+    
+    # Visualization
+    fig_size: tuple = (16, 12)
+    dpi: int = 300
+    layout: str = "sfdp"  # dot, neato, fdp, sfdp, circo, twopi
+    
+    # Pattern detection
+    detect_state_machines: bool = True
+    detect_recursion: bool = True
+    detect_loops: bool = True
+    
+    # Dynamic analysis
+    trace_runtime: bool = False
+    skip_packages: Set[str] = field(default_factory=lambda: {
+        'site-packages', 'dist-packages', 'venv', '.venv'
+    })
+    
+    # Logging
+    verbose: bool = False
+    quiet: bool = False
+
+
+# Predefined fast configuration
+FAST_CONFIG = Config(
+    mode="static",
+    performance=PerformanceConfig(
+        fast_mode=True,
+        skip_data_flow=True,
+        skip_pattern_detection=True,
+        parallel_enabled=True,
+        parallel_workers=8,
+        max_nodes_per_file=500,
+        max_total_nodes=5000,
+    ),
+    filters=FilterConfig(
+        exclude_tests=True,
+        skip_private=True,
+        skip_properties=True,
+        skip_accessors=True,
+        min_function_lines=1,
+    ),
+    depth=DepthConfig(
+        max_cfg_depth=3,
+        max_call_depth=2,
+        max_data_flow_depth=1,
+        max_interprocedural_depth=1,
+    ),
+    output=OutputConfig(compact=True, include_source=False),
+    layout="dot",
+)
+
+
+# Analysis modes descriptions
+ANALYSIS_MODES = {
+    'static': 'AST-based control and data flow analysis',
+    'dynamic': 'Runtime execution tracing',
+    'hybrid': 'Combined static + dynamic analysis',
+    'behavioral': 'Behavioral pattern extraction',
+    'reverse': 'Reverse engineering ready output'
+}
+
+
+# Node types
+NODE_TYPES = {
+    'FUNC': 'Function definition',
+    'CALL': 'Function call',
+    'IF': 'Conditional branch',
+    'FOR': 'For loop',
+    'WHILE': 'While loop',
+    'ASSIGN': 'Variable assignment',
+    'RETURN': 'Return statement',
+    'ENTRY': 'Entry point',
+    'EXIT': 'Exit point',
+}
+
+
+# Colors for visualization
+NODE_COLORS = {
+    'FUNC': '#4CAF50',
+    'CALL': '#2196F3',
+    'IF': '#FF9800',
+    'FOR': '#9C27B0',
+    'WHILE': '#9C27B0',
+    'ASSIGN': '#607D8B',
+    'RETURN': '#E91E63',
+    'ENTRY': '#00BCD4',
+    'EXIT': '#F44336',
+}

code2flow/core/models.py

@@ -0,0 +1,194 @@
+from dataclasses import dataclass, field, asdict
+from typing import List, Dict, Set, Optional, Any
+from pathlib import Path
+
+
+class BaseModel:
+    """Base class for models with automated serialization."""
+    def to_dict(self, compact: bool = True) -> dict:
+        """Convert to dictionary using dataclasses.asdict with filtering."""
+        data = asdict(self)
+        if compact:
+            return self._filter_compact(data)
+        return data
+
+    def _filter_compact(self, data: Any) -> Any:
+        """Recursively filter out None and empty collections if compact."""
+        if isinstance(data, dict):
+            return {
+                k: self._filter_compact(v) 
+                for k, v in data.items() 
+                if v is not None and (not isinstance(v, (list, dict, set)) or len(v) > 0)
+            }
+        elif isinstance(data, (list, tuple, set)):
+            return [self._filter_compact(v) for v in data]
+        return data
+
+
+@dataclass
+class FlowNode(BaseModel):
+    """Represents a node in the control flow graph."""
+    id: str
+    type: str  # FUNC, CALL, IF, FOR, WHILE, ASSIGN, RETURN, ENTRY, EXIT
+    label: str
+    function: Optional[str] = None
+    file: Optional[str] = None
+    line: Optional[int] = None
+    column: Optional[int] = None
+    conditions: List[str] = field(default_factory=list)
+    data_flow: List[str] = field(default_factory=list)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class FlowEdge(BaseModel):
+    """Represents an edge in the control flow graph."""
+    source: str
+    target: str
+    edge_type: str = "control"  # control, data, call
+    label: Optional[str] = None
+    conditions: List[str] = field(default_factory=list)
+
+
+@dataclass
+class FunctionInfo(BaseModel):
+    """Information about a function/method."""
+    name: str
+    qualified_name: str
+    file: str
+    line: int
+    column: int = 0
+    module: str = ""
+    class_name: Optional[str] = None
+    is_method: bool = False
+    is_private: bool = False
+    is_property: bool = False
+    docstring: Optional[str] = None
+    args: List[str] = field(default_factory=list)
+    returns: Optional[str] = None
+    decorators: List[str] = field(default_factory=list)
+    
+    # CFG info
+    cfg_entry: Optional[str] = None
+    cfg_exit: Optional[str] = None
+    cfg_nodes: List[str] = field(default_factory=list)
+    calls: List[str] = field(default_factory=list)
+    called_by: List[str] = field(default_factory=list)
+    
+    # Advanced metrics (Sprint 3)
+    complexity: Dict[str, Any] = field(default_factory=dict) # Cyclomatic, Cognitive
+    centrality: float = 0.0 # Betweenness Centrality
+    reachability: str = "unknown" # reachable, unreachable, unknown
+
+
+@dataclass
+class ClassInfo(BaseModel):
+    """Information about a class."""
+    name: str
+    qualified_name: str
+    file: str
+    line: int
+    module: str = ""
+    bases: List[str] = field(default_factory=list)
+    methods: List[str] = field(default_factory=list)
+    docstring: Optional[str] = None
+    is_state_machine: bool = False
+
+
+@dataclass
+class ModuleInfo(BaseModel):
+    """Information about a module/package."""
+    name: str
+    file: str
+    is_package: bool = False
+    imports: List[str] = field(default_factory=list)
+    functions: List[str] = field(default_factory=list)
+    classes: List[str] = field(default_factory=list)
+
+
+@dataclass
+class Pattern(BaseModel):
+    """Detected behavioral pattern."""
+    name: str
+    type: str  # recursion, state_machine, factory, singleton, strategy, loop
+    confidence: float  # 0.0 to 1.0
+    functions: List[str] = field(default_factory=list)
+    entry_points: List[str] = field(default_factory=list)
+    exit_points: List[str] = field(default_factory=list)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class CodeSmell(BaseModel):
+    """Represents a detected code smell."""
+    name: str
+    type: str  # god_function, feature_envy, etc.
+    file: str
+    line: int
+    severity: float  # 0.0 to 1.0
+    description: str
+    context: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class Mutation(BaseModel):
+    """Represents a mutation of a variable/object."""
+    variable: str
+    file: str
+    line: int
+    type: str  # assign, aug_assign, method_call
+    scope: str
+    context: str
+
+
+@dataclass
+class DataFlow(BaseModel):
+    """Represents data flow for a variable."""
+    variable: str
+    dependencies: Set[str] = field(default_factory=set)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class AnalysisResult(BaseModel):
+    """Complete analysis result for a project."""
+    project_path: str = ""
+    analysis_mode: str = "static"
+    stats: Dict[str, int] = field(default_factory=dict)
+    
+    # Graph data
+    nodes: Dict[str, FlowNode] = field(default_factory=dict)
+    edges: List[FlowEdge] = field(default_factory=list)
+    
+    # Code structure
+    modules: Dict[str, ModuleInfo] = field(default_factory=dict)
+    classes: Dict[str, ClassInfo] = field(default_factory=dict)
+    functions: Dict[str, FunctionInfo] = field(default_factory=dict)
+    
+    # Analysis results
+    patterns: List[Pattern] = field(default_factory=list)
+    call_graph: Dict[str, List[str]] = field(default_factory=list)
+    entry_points: List[str] = field(default_factory=list)
+    data_flows: Dict[str, DataFlow] = field(default_factory=dict)
+    
+    # Refactoring data
+    metrics: Dict[str, Dict[str, Any]] = field(default_factory=dict)
+    smells: List[CodeSmell] = field(default_factory=list)
+    coupling: Dict[str, Any] = field(default_factory=dict)
+    mutations: List[Mutation] = field(default_factory=list)
+    
+    def get_function_count(self) -> int:
+        """Get total function count."""
+        return len(self.functions)
+    
+    def get_class_count(self) -> int:
+        """Get total class count."""
+        return len(self.classes)
+    
+    def get_node_count(self) -> int:
+        """Get total CFG node count."""
+        return len(self.nodes)
+    
+    def get_edge_count(self) -> int:
+        """Get total edge count."""
+        return len(self.edges)