algomath-extract 1.0.0

package/src/generation/review.py

@@ -0,0 +1,254 @@
+"""Code review interface.
+
+This module provides the CodeReviewInterface for reviewing
+and editing generated Python code.
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from src.extraction.schema import Algorithm
+from src.generation.code_generator import GeneratedCode
+from src.generation.validation import CodeValidator, ValidationResult
+
+
+@dataclass
+class ReviewState:
+    """
+    State of code review.
+    
+    Attributes:
+        original_code: Original generated code
+        current_code: Current (possibly edited) code
+        is_edited: Whether code has been edited
+        is_approved: Whether code is approved
+        validation_result: Last validation result
+        approved_at: Approval timestamp
+    """
+    original_code: str
+    current_code: str
+    is_edited: bool = False
+    is_approved: bool = False
+    validation_result: Optional[ValidationResult] = None
+    approved_at: Optional[datetime] = None
+
+
+class CodeReviewInterface:
+    """
+    Review and edit generated Python code.
+    
+    Provides side-by-side view of steps and code,
+    editing capability, and approval workflow.
+    """
+    
+    def __init__(self, validator: Optional[CodeValidator] = None):
+        """
+        Initialize review interface.
+        
+        Args:
+            validator: Optional custom validator
+        """
+        self.validator = validator or CodeValidator()
+        self.state: Optional[ReviewState] = None
+        self.algorithm: Optional[Algorithm] = None
+        self.generated: Optional[GeneratedCode] = None
+    
+    def load(self, algorithm: Algorithm, generated: GeneratedCode):
+        """
+        Load algorithm and generated code for review.
+        
+        Args:
+            algorithm: Algorithm that was generated from
+            generated: Generated code
+        """
+        self.algorithm = algorithm
+        self.generated = generated
+        self.state = ReviewState(
+            original_code=generated.source,
+            current_code=generated.source,
+            is_edited=False,
+            is_approved=False
+        )
+    
+    def display(self) -> str:
+        """
+        Display side-by-side view of steps and code.
+        
+        Returns:
+            Formatted display string
+        """
+        if not self.state:
+            return "No code loaded for review."
+        
+        lines = []
+        lines.append("╔════════════════════════════════════════════════════════════╗")
+        lines.append("║ Algorithm Steps          │ Generated Code                ║")
+        lines.append("╠════════════════════════════════════════════════════════════╣")
+        
+        # Format steps
+        steps_text = self._format_steps()
+        code_lines = self.state.current_code.split('\n')
+        
+        # Side-by-side display
+        step_lines = steps_text.split('\n')
+        max_lines = max(len(step_lines), len(code_lines))
+        
+        for i in range(max_lines):
+            step_part = step_lines[i] if i < len(step_lines) else ""
+            code_part = code_lines[i] if i < len(code_lines) else ""
+            
+            # Truncate to fit display
+            step_part = step_part[:30].ljust(30)
+            code_part = code_part[:40]
+            
+            lines.append(f"║ {step_part} │ {code_part} ║")
+        
+        lines.append("╚════════════════════════════════════════════════════════════╝")
+        
+        # Status line
+        status = []
+        if self.state.is_edited:
+            status.append("[EDITED]")
+        if self.state.is_approved:
+            status.append("[APPROVED]")
+        if self.state.validation_result and not self.state.validation_result.is_valid:
+            status.append(f"[{self.state.validation_result.error_count} ERRORS]")
+        
+        lines.append(f"Status: {' '.join(status) if status else 'Ready for review'}")
+        
+        return '\n'.join(lines)
+    
+    def _format_steps(self) -> str:
+        """Format algorithm steps for display."""
+        if not self.algorithm:
+            return "No algorithm loaded"
+        
+        lines = []
+        for i, step in enumerate(self.algorithm.steps, 1):
+            desc = step.description[:27] + "..." if len(step.description) > 30 else step.description
+            lines.append(f"{i}. {desc}")
+        return '\n'.join(lines)
+    
+    def edit_code(self, new_code: str) -> ValidationResult:
+        """
+        Update code with user edits.
+        
+        Args:
+            new_code: New code from user edits
+            
+        Returns:
+            ValidationResult for the edited code
+        """
+        if not self.state:
+            raise ValueError("No code loaded")
+        
+        self.state.current_code = new_code
+        self.state.is_edited = True
+        self.state.is_approved = False  # Reset approval on edit
+        
+        # Validate edited code
+        self.state.validation_result = self.validator.validate(new_code)
+        
+        return self.state.validation_result
+    
+    def validate_edit(self) -> ValidationResult:
+        """
+        Re-validate current code.
+        
+        Returns:
+            ValidationResult
+        """
+        if not self.state:
+            raise ValueError("No code loaded")
+        
+        self.state.validation_result = self.validator.validate(
+            self.state.current_code
+        )
+        return self.state.validation_result
+    
+    def approve(self) -> bool:
+        """
+        Mark code as approved.
+        
+        Returns:
+            True if approved successfully
+        """
+        if not self.state:
+            raise ValueError("No code loaded")
+        
+        # Must validate first
+        if not self.state.validation_result:
+            self.validate_edit()
+        
+        if self.state.validation_result and not self.state.validation_result.is_valid:
+            return False  # Cannot approve invalid code
+        
+        self.state.is_approved = True
+        self.state.approved_at = datetime.now()
+        return True
+    
+    def is_approved(self) -> bool:
+        """Check if code is approved."""
+        return self.state.is_approved if self.state else False
+    
+    def get_modified_code(self) -> str:
+        """Return user-edited code (or original if not edited)."""
+        return self.state.current_code if self.state else ""
+    
+    def get_original_code(self) -> str:
+        """Return original generated code."""
+        return self.state.original_code if self.state else ""
+    
+    def has_changes(self) -> bool:
+        """Check if code was edited."""
+        if not self.state:
+            return False
+        return self.state.current_code != self.state.original_code
+    
+    def get_review_summary(self) -> Dict[str, Any]:
+        """
+        Return summary of review state.
+        
+        Returns:
+            Dict with review state
+        """
+        if not self.state:
+            return {}
+        
+        return {
+            'is_edited': self.state.is_edited,
+            'is_approved': self.state.is_approved,
+            'has_validation_errors': (
+                self.state.validation_result and
+                not self.state.validation_result.is_valid
+            ) if self.state.validation_result else False,
+            'validation_errors': (
+                self.state.validation_result.errors
+            ) if self.state.validation_result else [],
+            'line_count': len(self.state.current_code.split('\n')),
+        }
+
+
+def create_review(algorithm: Algorithm,
+                  generated: GeneratedCode) -> CodeReviewInterface:
+    """
+    Factory function to create review interface.
+    
+    Args:
+        algorithm: Algorithm that was generated from
+        generated: Generated code
+        
+    Returns:
+        CodeReviewInterface instance
+    """
+    review = CodeReviewInterface()
+    review.load(algorithm, generated)
+    return review
+
+
+__all__ = [
+    'CodeReviewInterface',
+    'ReviewState',
+    'create_review',
+]

package/src/generation/templates.py

@@ -0,0 +1,208 @@
+"""Code templates for algorithm generation.
+
+This module provides templates for generating Python code
+from structured algorithm steps.
+"""
+
+import re
+from typing import Dict, Optional
+
+from src.extraction.schema import Step, StepType
+
+
+class CodeTemplates:
+    """Collection of code templates for mathematical operations."""
+    
+    # Mathematical operator templates
+    summation = "sum({expression} for {iter_var} in {iter_range})"
+    product = "math.prod([{expression} for {iter_var} in {iter_range}])"
+    sqrt = "math.sqrt({expression})"
+    abs = "abs({expression})"
+    
+    # Set operations
+    element_in = "{element} in {set_name}"
+    subset = "{set_a} <= {set_b}"
+    
+    # Matrix operations
+    matrix_mult = "{matrix_a} @ {matrix_b}"
+    matrix_transpose = "{matrix}.T"
+    
+    # Optimization
+    argmin = "np.argmin({array})"
+    argmax = "np.argmax({array})"
+    minimum = "min({expression})"
+    maximum = "max({expression})"
+
+
+class TemplateRegistry:
+    """
+    Registry mapping StepType to code templates.
+    
+    Provides templates for generating Python code from
+    structured algorithm steps.
+    """
+    
+    DEFAULT_TEMPLATES: Dict[StepType, str] = {
+        StepType.ASSIGNMENT: "{target} = {expression}",
+        StepType.LOOP_FOR: "for {iter_var} in {iter_range}:\n{body}",
+        StepType.LOOP_WHILE: "while {condition}:\n{body}",
+        StepType.CONDITIONAL: "if {condition}:\n{if_body}{else_clause}",
+        StepType.RETURN: "return {expression}",
+        StepType.CALL: "{call_target}({arguments})",
+        StepType.COMMENT: "# {annotation}",
+    }
+    
+    def __init__(self):
+        """Initialize template registry with default templates."""
+        self._templates = self.DEFAULT_TEMPLATES.copy()
+    
+    def register(self, step_type: StepType, template: str) -> None:
+        """
+        Register or override a template for a StepType.
+        
+        Args:
+            step_type: Type of step
+            template: Template string with placeholders
+        """
+        self._templates[step_type] = template
+    
+    def get(self, step_type: StepType) -> str:
+        """
+        Get template for a StepType.
+        
+        Args:
+            step_type: Type of step
+            
+        Returns:
+            Template string
+        """
+        return self._templates.get(step_type, "# TODO: {description}")
+    
+    def format_step(self, step: Step, indent: int = 4) -> str:
+        """
+        Format a step using its template.
+        
+        Args:
+            step: Step to format
+            indent: Indentation level for nested content
+            
+        Returns:
+            Formatted code string
+        """
+        template = self.get(step.type)
+        
+        if step.type == StepType.ASSIGNMENT:
+            target = step.outputs[0] if step.outputs else "result"
+            expression = step.expression or "None"
+            return template.format(target=target, expression=expression)
+        
+        elif step.type == StepType.LOOP_FOR:
+            iter_var = step.iter_var or "i"
+            iter_range = step.iter_range or "range(n)"
+            body = self._format_body(step.body, indent + 4)
+            code = template.format(
+                iter_var=iter_var,
+                iter_range=iter_range,
+                body=body
+            )
+            return self.indent_lines(code, indent)
+        
+        elif step.type == StepType.LOOP_WHILE:
+            condition = step.condition or "True"
+            body = self._format_body(step.body, indent + 4)
+            code = template.format(condition=condition, body=body)
+            return self.indent_lines(code, indent)
+        
+        elif step.type == StepType.CONDITIONAL:
+            condition = step.condition or "True"
+            if_body = self._format_body(step.body, indent + 4)
+            
+            if step.else_body:
+                else_body = self._format_body(step.else_body, indent + 4)
+                else_clause = f"\nelse:\n{else_body}"
+            else:
+                else_clause = ""
+            
+            code = template.format(
+                condition=condition,
+                if_body=if_body,
+                else_clause=else_clause
+            )
+            return self.indent_lines(code, indent)
+        
+        elif step.type == StepType.RETURN:
+            expression = step.expression or "None"
+            return template.format(expression=expression)
+        
+        elif step.type == StepType.CALL:
+            call_target = step.call_target or "function"
+            arguments = ", ".join(step.arguments) if step.arguments else ""
+            return template.format(call_target=call_target, arguments=arguments)
+        
+        elif step.type == StepType.COMMENT:
+            annotation = step.annotation or step.description
+            return template.format(annotation=annotation)
+        
+        return template.format(description=step.description)
+    
+    def _format_body(self, body_step_ids: list, indent: int) -> str:
+        """
+        Format body steps (placeholder - actual implementation needs step lookup).
+        
+        Args:
+            body_step_ids: List of step IDs in body
+            indent: Indentation level
+            
+        Returns:
+            Formatted body code
+        """
+        if not body_step_ids:
+            return self.indent_lines("pass", indent)
+        # This would require access to the step map
+        # For now, return pass
+        return self.indent_lines("# body steps would go here", indent)
+    
+    def indent_lines(self, code: str, level: int) -> str:
+        """
+        Indent multi-line code.
+        
+        Args:
+            code: Code string
+            level: Indentation level (spaces)
+            
+        Returns:
+            Indented code
+        """
+        if not code:
+            return ""
+        
+        lines = code.split('\n')
+        indent = ' ' * level
+        return '\n'.join(indent + line for line in lines)
+    
+    def format_math_expression(self, expression: str) -> str:
+        """
+        Format mathematical expression into Python code.
+        
+        Args:
+            expression: Mathematical expression text
+            
+        Returns:
+            Python code string
+        """
+        result = expression
+        
+        # Common patterns
+        patterns = [
+            (r'sum\s+of\s+(.+?)\s+for\s+(\w+)\s+in\s+(.+)', 
+             r'sum(\1 for \2 in \3)'),
+            (r'product\s+of\s+(.+?)\s+for\s+(\w+)\s+in\s+(.+)', 
+             r'math.prod([\1 for \2 in \3])'),
+            (r'sqrt\s*\((.+?)\)', r'math.sqrt(\1)'),
+            (r'\|(.+?)\|', r'abs(\1)'),
+        ]
+        
+        for pattern, replacement in patterns:
+            result = re.sub(pattern, replacement, result, flags=re.IGNORECASE)
+        
+        return result

package/src/generation/types.py

@@ -0,0 +1,196 @@
+"""Type inference utilities for code generation.
+
+This module provides type inference for mathematical variables
+and function signatures based on variable naming conventions.
+"""
+
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Tuple
+import re
+
+from src.extraction.schema import Algorithm, Step
+
+
+@dataclass
+class ValidationResult:
+    """
+    Represents validation results.
+    
+    Attributes:
+        is_valid: Whether validation passed
+        errors: List of error dictionaries
+        warnings: List of warning messages
+    """
+    is_valid: bool
+    errors: List[Dict[str, Any]]
+    warnings: List[str]
+    
+    @property
+    def has_errors(self) -> bool:
+        return len(self.errors) > 0
+    
+    @property
+    def error_count(self) -> int:
+        return len(self.errors)
+
+
+@dataclass
+class PythonType:
+    """Represents a Python type annotation."""
+    name: str
+    is_optional: bool = False
+    
+    def __str__(self) -> str:
+        if self.is_optional:
+            return f"Optional[{self.name}]"
+        return self.name
+
+
+@dataclass
+class FunctionSignature:
+    """Represents a function signature with parameters and return type."""
+    name: str
+    params: List[Tuple[str, str]]  # (param_name, type_annotation)
+    return_type: str
+    
+    def format_params(self) -> str:
+        """Format parameters for function definition."""
+        if not self.params:
+            return ""
+        return ", ".join(f"{name}: {ptype}" for name, ptype in self.params)
+
+
+class TypeInferrer:
+    """
+    Infer Python types from variable names and context.
+    
+    Uses naming conventions common in mathematical algorithms
+    to infer appropriate Python type annotations.
+    """
+    
+    # Variable name patterns → types
+    TYPE_PATTERNS = {
+        # Integer types
+        "int": [
+            r'^n$', r'^m$', r'^i$', r'^j$', r'^k$',
+            r'count', r'index', r'idx', r'size', r'length',
+            r'num', r'number', r'total', r'sum',
+        ],
+        # Float types
+        "float": [
+            r'epsilon', r'delta', r'tolerance', r'threshold',
+            r'error', r'precision', r'accuracy',
+        ],
+        # numpy ndarray types
+        "np.ndarray": [
+            r'matrix', r'^A$', r'^B$', r'^C$', r'^M$',
+            r'grid', r'vector', r'^vec', r'^arr',
+            r'tensor', r'^T$',
+        ],
+        # List types
+        "List": [
+            r'items', r'nodes', r'edges', r'vertices',
+            r'elements', r'values', r'keys', r'points',
+            r'neighbors', r'adj', r'list',
+        ],
+        # Dict types
+        "Dict": [
+            r'dict', r'map', r'hash', r'table',
+            r'graph', r'cache', r'memo',
+        ],
+        # Boolean types
+        "bool": [
+            r'visited', r'found', r'is_', r'has_',
+            r'valid', r'enabled', r'done',
+        ],
+    }
+    
+    def infer_variable_type(self, name: str, context: Dict[str, Any]) -> str:
+        """
+        Infer Python type from variable name.
+        
+        Args:
+            name: Variable name
+            context: Additional context (e.g., step information)
+            
+        Returns:
+            Python type annotation string
+        """
+        name_lower = name.lower()
+        
+        # Check each type pattern
+        for ptype, patterns in self.TYPE_PATTERNS.items():
+            for pattern in patterns:
+                try:
+                    if re.search(pattern, name_lower, re.IGNORECASE):
+                        return ptype
+                except re.error:
+                    # Skip invalid regex patterns
+                    continue
+        
+        # Default to Any for unknown types
+        return "Any"
+    
+    def infer_function_signature(self, algorithm: Algorithm) -> FunctionSignature:
+        """
+        Infer complete function signature from algorithm.
+        
+        Args:
+            algorithm: Algorithm to infer signature for
+            
+        Returns:
+            FunctionSignature with parameters and return type
+        """
+        # Infer parameter types from inputs
+        params = []
+        for inp in algorithm.inputs:
+            name = inp.get("name", "")
+            inferred_type = self.infer_variable_type(name, inp)
+            params.append((name, inferred_type))
+        
+        # Infer return type from outputs
+        if not algorithm.outputs:
+            return_type = "None"
+        elif len(algorithm.outputs) == 1:
+            name = algorithm.outputs[0].get("name", "")
+            # Special handling for common output names
+            if name.lower() in ["result", "path", "distances", "output", "answer"]:
+                return_type = "List[float]"
+            else:
+                return_type = self.infer_variable_type(name, algorithm.outputs[0])
+        else:
+            # Multiple outputs → Tuple
+            types = []
+            for out in algorithm.outputs:
+                name = out.get("name", "")
+                types.append(self.infer_variable_type(name, out))
+            return_type = f"Tuple[{', '.join(types)}]"
+        
+        return FunctionSignature(
+            name=self._to_snake_case(algorithm.name),
+            params=params,
+            return_type=return_type
+        )
+    
+    def format_type_hint(self, type_str: str, optional: bool = False) -> str:
+        """
+        Format type hint for PEP 484 compliance.
+        
+        Args:
+            type_str: Type string
+            optional: Whether type is optional
+            
+        Returns:
+            Formatted type hint
+        """
+        if optional and not type_str.startswith("Optional["):
+            return f"Optional[{type_str}]"
+        return type_str
+    
+    def _to_snake_case(self, name: str) -> str:
+        """Convert algorithm name to snake_case."""
+        # Replace spaces and dashes with underscores
+        name = re.sub(r'[\s\-]+', '_', name)
+        # Insert underscore before uppercase letters
+        name = re.sub(r'([a-z])([A-Z])', r'\1_\2', name)
+        return name.lower().strip('_')