stratifyai 0.1.0__py3-none-any.whl

stratifyai/utils/log_extractor.py

@@ -0,0 +1,267 @@
+"""Log file error extraction for intelligent file analysis.
+
+This module extracts errors, warnings, and patterns from log files to reduce
+token usage by 90%+ while preserving critical information.
+"""
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+from collections import Counter
+from datetime import datetime
+
+
+@dataclass
+class LogEntry:
+    """A single log entry."""
+    timestamp: Optional[str]
+    level: str  # ERROR, WARN, INFO, DEBUG, etc.
+    message: str
+    line_number: int
+
+
+@dataclass
+class LogSummary:
+    """Summary of log file analysis."""
+    file_path: str
+    total_lines: int
+    errors: List[LogEntry]
+    warnings: List[LogEntry]
+    error_patterns: Dict[str, int]
+    warning_patterns: Dict[str, int]
+    timestamp_range: Optional[tuple[str, str]]
+    
+    def to_text(self) -> str:
+        """Convert summary to human-readable text.
+        
+        Returns:
+            Formatted log summary
+        """
+        lines = [
+            f"Log File: {self.file_path}",
+            f"Total Lines: {self.total_lines:,}",
+            f"Errors: {len(self.errors)}",
+            f"Warnings: {len(self.warnings)}",
+        ]
+        
+        if self.timestamp_range:
+            lines.append(f"Time Range: {self.timestamp_range[0]} to {self.timestamp_range[1]}")
+        
+        # Error patterns
+        if self.error_patterns:
+            lines.append("\nTop Error Patterns:")
+            for pattern, count in sorted(self.error_patterns.items(), key=lambda x: -x[1])[:10]:
+                lines.append(f"  [{count}×] {pattern}")
+        
+        # Warning patterns
+        if self.warning_patterns:
+            lines.append("\nTop Warning Patterns:")
+            for pattern, count in sorted(self.warning_patterns.items(), key=lambda x: -x[1])[:10]:
+                lines.append(f"  [{count}×] {pattern}")
+        
+        # Recent errors (last 5)
+        if self.errors:
+            lines.append("\nRecent Errors:")
+            for entry in self.errors[-5:]:
+                ts = entry.timestamp or "??:??:??"
+                lines.append(f"  [Line {entry.line_number}] {ts} - {entry.message[:100]}")
+        
+        # Recent warnings (last 5)
+        if self.warnings:
+            lines.append("\nRecent Warnings:")
+            for entry in self.warnings[-5:]:
+                ts = entry.timestamp or "??:??:??"
+                lines.append(f"  [Line {entry.line_number}] {ts} - {entry.message[:100]}")
+        
+        return "\n".join(lines)
+
+
+# Common log patterns
+LOG_LEVEL_PATTERNS = [
+    (r'\b(ERROR|FATAL|CRITICAL)\b', 'ERROR'),
+    (r'\b(WARN|WARNING)\b', 'WARN'),
+    (r'\b(INFO|INFORMATION)\b', 'INFO'),
+    (r'\b(DEBUG|TRACE)\b', 'DEBUG'),
+]
+
+TIMESTAMP_PATTERNS = [
+    r'\d{4}-\d{2}-\d{2}[T\s]\d{2}:\d{2}:\d{2}',  # ISO format
+    r'\d{2}/\d{2}/\d{4}\s+\d{2}:\d{2}:\d{2}',     # US format
+    r'\d{2}:\d{2}:\d{2}',                         # Time only
+]
+
+
+def extract_timestamp(line: str) -> Optional[str]:
+    """Extract timestamp from log line.
+    
+    Args:
+        line: Log line text
+        
+    Returns:
+        Extracted timestamp or None
+    """
+    for pattern in TIMESTAMP_PATTERNS:
+        match = re.search(pattern, line)
+        if match:
+            return match.group(0)
+    return None
+
+
+def extract_log_level(line: str) -> Optional[str]:
+    """Extract log level from log line.
+    
+    Args:
+        line: Log line text
+        
+    Returns:
+        Log level (ERROR, WARN, INFO, DEBUG) or None
+    """
+    for pattern, level in LOG_LEVEL_PATTERNS:
+        if re.search(pattern, line, re.IGNORECASE):
+            return level
+    return None
+
+
+def extract_error_pattern(message: str) -> str:
+    """Extract pattern from error message by removing variable parts.
+    
+    Args:
+        message: Error message
+        
+    Returns:
+        Pattern string with variables replaced
+    """
+    # Remove numbers
+    pattern = re.sub(r'\b\d+\b', '<NUM>', message)
+    
+    # Remove hex addresses
+    pattern = re.sub(r'0x[0-9a-fA-F]+', '<ADDR>', pattern)
+    
+    # Remove quoted strings
+    pattern = re.sub(r'"[^"]*"', '<STR>', pattern)
+    pattern = re.sub(r"'[^']*'", '<STR>', pattern)
+    
+    # Remove file paths
+    pattern = re.sub(r'(/[\w/.-]+|[A-Z]:\\[\w\\.-]+)', '<PATH>', pattern)
+    
+    # Remove timestamps
+    for ts_pattern in TIMESTAMP_PATTERNS:
+        pattern = re.sub(ts_pattern, '<TIME>', pattern)
+    
+    return pattern[:200]  # Truncate long patterns
+
+
+def analyze_log_file(
+    file_path: Path,
+    max_lines: Optional[int] = None,
+    max_errors: int = 100,
+    max_warnings: int = 100
+) -> LogSummary:
+    """Analyze a log file and extract errors/warnings.
+    
+    Args:
+        file_path: Path to log file
+        max_lines: Maximum lines to read (None = all)
+        max_errors: Maximum errors to store
+        max_warnings: Maximum warnings to store
+        
+    Returns:
+        LogSummary with extracted information
+        
+    Raises:
+        FileNotFoundError: If file doesn't exist
+    """
+    if not file_path.exists():
+        raise FileNotFoundError(f"Log file not found: {file_path}")
+    
+    errors: List[LogEntry] = []
+    warnings: List[LogEntry] = []
+    error_messages: List[str] = []
+    warning_messages: List[str] = []
+    timestamps: List[str] = []
+    
+    total_lines = 0
+    
+    with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+        for line_num, line in enumerate(f, 1):
+            if max_lines and line_num > max_lines:
+                break
+            
+            total_lines += 1
+            line = line.strip()
+            if not line:
+                continue
+            
+            # Extract timestamp
+            timestamp = extract_timestamp(line)
+            if timestamp:
+                timestamps.append(timestamp)
+            
+            # Extract log level
+            level = extract_log_level(line)
+            
+            if level == 'ERROR':
+                if len(errors) < max_errors:
+                    errors.append(LogEntry(
+                        timestamp=timestamp,
+                        level='ERROR',
+                        message=line,
+                        line_number=line_num
+                    ))
+                error_messages.append(line)
+            
+            elif level == 'WARN':
+                if len(warnings) < max_warnings:
+                    warnings.append(LogEntry(
+                        timestamp=timestamp,
+                        level='WARN',
+                        message=line,
+                        line_number=line_num
+                    ))
+                warning_messages.append(line)
+    
+    # Extract patterns
+    error_patterns = Counter(extract_error_pattern(msg) for msg in error_messages)
+    warning_patterns = Counter(extract_error_pattern(msg) for msg in warning_messages)
+    
+    # Timestamp range
+    timestamp_range = None
+    if timestamps:
+        timestamp_range = (timestamps[0], timestamps[-1])
+    
+    return LogSummary(
+        file_path=str(file_path),
+        total_lines=total_lines,
+        errors=errors,
+        warnings=warnings,
+        error_patterns=dict(error_patterns.most_common(10)),
+        warning_patterns=dict(warning_patterns.most_common(10)),
+        timestamp_range=timestamp_range
+    )
+
+
+def extract_log_summary(file_path: Path) -> Dict[str, Any]:
+    """Extract summary information from a log file.
+    
+    Args:
+        file_path: Path to log file
+        
+    Returns:
+        Dictionary with summary and metadata
+    """
+    summary = analyze_log_file(file_path)
+    summary_text = summary.to_text()
+    
+    # Calculate sizes
+    original_size = file_path.stat().st_size
+    summary_size = len(summary_text)
+    
+    return {
+        'summary': summary,
+        'summary_text': summary_text,
+        'original_size_bytes': original_size,
+        'summary_size_bytes': summary_size,
+        'token_reduction_pct': ((original_size - summary_size) / original_size * 100) if original_size > 0 else 0.0,
+        'recommended_action': 'Use summary for LLM analysis instead of full log file'
+    }

stratifyai/utils/model_selector.py

@@ -0,0 +1,324 @@
+"""Intelligent model selection for file extraction tasks.
+
+This module provides automatic model selection based on file type,
+extraction mode, and task requirements, optimizing for quality in
+structured data extraction scenarios.
+"""
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Tuple, Optional, List, Dict
+from pathlib import Path
+
+from .file_analyzer import FileType
+
+
+class ExtractionMode(Enum):
+    """Types of extraction tasks."""
+    SCHEMA = "schema"          # CSV/JSON schema extraction
+    ERRORS = "errors"          # Log file error extraction
+    SUMMARY = "summary"        # General summarization
+    STRUCTURE = "structure"    # Code structure extraction
+
+
+@dataclass
+class ModelRecommendation:
+    """Model recommendation with reasoning."""
+    provider: str
+    model: str
+    reasoning: str
+    quality_score: float
+    estimated_cost_per_1m: float
+
+
+class ModelSelector:
+    """Select optimal models for file extraction tasks."""
+    
+    def __init__(self):
+        """Initialize model selector with provider preferences."""
+        # Quality-focused models for schema extraction (ordered by preference)
+        self.schema_extraction_models = [
+            ("anthropic", "claude-3-5-sonnet-20241022", "Best structured output quality"),
+            ("openai", "gpt-4.5-turbo-20250205", "Excellent for data analysis"),
+            ("anthropic", "claude-sonnet-4-5-20250929", "High quality, latest model"),
+            ("google", "gemini-2.5-pro", "Strong structured reasoning"),
+        ]
+        
+        # Reasoning models for error/log analysis
+        self.error_extraction_models = [
+            ("deepseek", "deepseek-reasoner", "Excellent reasoning for error analysis"),
+            ("openai", "o1-mini", "Fast reasoning model"),
+            ("openai", "o3-mini", "Advanced reasoning"),
+            ("anthropic", "claude-3-5-sonnet-20241022", "Reliable error detection"),
+        ]
+        
+        # Code-optimized models for structure extraction
+        self.code_extraction_models = [
+            ("deepseek", "deepseek-chat", "Optimized for code understanding"),
+            ("anthropic", "claude-3-5-sonnet-20241022", "Strong code analysis"),
+            ("openai", "gpt-4.5-turbo-20250205", "Excellent code comprehension"),
+            ("google", "gemini-2.5-pro", "Good at code structure"),
+        ]
+        
+        # Fast models for general summarization
+        self.summary_models = [
+            ("google", "gemini-2.5-flash", "Fast and cost-effective"),
+            ("groq", "llama-3.1-70b-versatile", "Very fast inference"),
+            ("anthropic", "claude-3-5-haiku-20241022", "Quick, quality summaries"),
+            ("openai", "gpt-4.1-mini", "Balanced speed/quality"),
+        ]
+    
+    def select_for_file(
+        self,
+        file_path: Path,
+        extraction_mode: Optional[ExtractionMode] = None,
+        excluded_providers: Optional[List[str]] = None,
+    ) -> ModelRecommendation:
+        """Select optimal model for file extraction.
+        
+        Args:
+            file_path: Path to file being analyzed
+            extraction_mode: Specific extraction mode (auto-detected if None)
+            excluded_providers: Providers to exclude from selection
+            
+        Returns:
+            ModelRecommendation with selected provider/model and reasoning
+            
+        Examples:
+            >>> selector = ModelSelector()
+            >>> rec = selector.select_for_file(Path("data.csv"))
+            >>> print(f"{rec.provider}/{rec.model}: {rec.reasoning}")
+        """
+        from .file_analyzer import detect_file_type
+        
+        excluded = excluded_providers or []
+        file_type = detect_file_type(file_path)
+        
+        # Auto-detect extraction mode if not specified
+        if extraction_mode is None:
+            extraction_mode = self._infer_extraction_mode(file_type, file_path)
+        
+        # Select model list based on extraction mode
+        if extraction_mode == ExtractionMode.SCHEMA:
+            candidates = self.schema_extraction_models
+        elif extraction_mode == ExtractionMode.ERRORS:
+            candidates = self.error_extraction_models
+        elif extraction_mode == ExtractionMode.STRUCTURE:
+            candidates = self.code_extraction_models
+        elif extraction_mode == ExtractionMode.SUMMARY:
+            candidates = self.summary_models
+        else:
+            # Fallback to schema extraction models (highest quality)
+            candidates = self.schema_extraction_models
+        
+        # Filter out excluded providers
+        available_candidates = [
+            (provider, model, reason)
+            for provider, model, reason in candidates
+            if provider not in excluded
+        ]
+        
+        if not available_candidates:
+            # Fallback to any available provider
+            all_models = (
+                self.schema_extraction_models +
+                self.error_extraction_models +
+                self.code_extraction_models +
+                self.summary_models
+            )
+            available_candidates = [
+                (provider, model, reason)
+                for provider, model, reason in all_models
+                if provider not in excluded
+            ]
+        
+        if not available_candidates:
+            raise ValueError(
+                "No available models after filtering excluded providers. "
+                f"Excluded: {excluded}"
+            )
+        
+        # Select first available (highest priority)
+        provider, model, reasoning = available_candidates[0]
+        
+        # Get quality score and cost estimates
+        quality_score = self._get_quality_score(provider, model)
+        estimated_cost = self._get_estimated_cost(provider, model)
+        
+        # Enhance reasoning with file type
+        full_reasoning = f"{reasoning} (for {file_type.value} {extraction_mode.value})"
+        
+        return ModelRecommendation(
+            provider=provider,
+            model=model,
+            reasoning=full_reasoning,
+            quality_score=quality_score,
+            estimated_cost_per_1m=estimated_cost,
+        )
+    
+    def select_for_extraction_mode(
+        self,
+        file_type: FileType,
+        extraction_mode: ExtractionMode,
+        excluded_providers: Optional[List[str]] = None,
+    ) -> ModelRecommendation:
+        """Select model based on file type and extraction mode.
+        
+        Args:
+            file_type: Detected file type
+            extraction_mode: Type of extraction task
+            excluded_providers: Providers to exclude
+            
+        Returns:
+            ModelRecommendation with selected provider/model
+        """
+        excluded = excluded_providers or []
+        
+        # Select candidates based on mode
+        if extraction_mode == ExtractionMode.SCHEMA:
+            candidates = self.schema_extraction_models
+        elif extraction_mode == ExtractionMode.ERRORS:
+            candidates = self.error_extraction_models
+        elif extraction_mode == ExtractionMode.STRUCTURE:
+            candidates = self.code_extraction_models
+        else:
+            candidates = self.summary_models
+        
+        # Filter and select
+        available = [
+            (p, m, r) for p, m, r in candidates
+            if p not in excluded
+        ]
+        
+        if not available:
+            raise ValueError("No available models after filtering")
+        
+        provider, model, reasoning = available[0]
+        
+        return ModelRecommendation(
+            provider=provider,
+            model=model,
+            reasoning=f"{reasoning} (for {file_type.value} {extraction_mode.value})",
+            quality_score=self._get_quality_score(provider, model),
+            estimated_cost_per_1m=self._get_estimated_cost(provider, model),
+        )
+    
+    def _infer_extraction_mode(self, file_type: FileType, file_path: Path) -> ExtractionMode:
+        """Infer extraction mode from file type and name.
+        
+        Args:
+            file_type: Detected file type
+            file_path: Path to file
+            
+        Returns:
+            Inferred ExtractionMode
+        """
+        # Map file types to extraction modes
+        if file_type == FileType.CSV:
+            return ExtractionMode.SCHEMA
+        elif file_type == FileType.JSON:
+            return ExtractionMode.SCHEMA
+        elif file_type == FileType.LOG:
+            return ExtractionMode.ERRORS
+        elif file_type in [FileType.PYTHON, FileType.JAVASCRIPT, FileType.JAVA, FileType.GO]:
+            return ExtractionMode.STRUCTURE
+        else:
+            # Check filename for hints
+            filename_lower = file_path.name.lower()
+            if 'log' in filename_lower or 'error' in filename_lower:
+                return ExtractionMode.ERRORS
+            else:
+                return ExtractionMode.SUMMARY
+    
+    def _get_quality_score(self, provider: str, model: str) -> float:
+        """Get quality score for a model.
+        
+        These are estimated scores based on benchmarks.
+        Should match Router's quality_scores.
+        """
+        quality_scores = {
+            # OpenAI
+            "gpt-5": 0.98,
+            "o3-mini": 0.95,
+            "gpt-4.5-turbo-20250205": 0.93,
+            "gpt-4.1-turbo": 0.90,
+            "gpt-4.1-mini": 0.82,
+            "o1-mini": 0.88,
+            "o1": 0.96,
+            
+            # Anthropic
+            "claude-sonnet-4-5-20250929": 0.94,
+            "claude-3-5-sonnet-20241022": 0.92,
+            "claude-3-5-haiku-20241022": 0.80,
+            
+            # Google
+            "gemini-2.5-pro": 0.91,
+            "gemini-2.5-flash": 0.85,
+            "gemini-2.5-flash-lite": 0.78,
+            
+            # DeepSeek
+            "deepseek-chat": 0.85,
+            "deepseek-reasoner": 0.90,
+            
+            # Groq
+            "llama-3.1-70b-versatile": 0.83,
+            "llama-3.1-8b-instant": 0.75,
+            "mixtral-8x7b-32768": 0.80,
+            
+            # Grok
+            "grok-beta": 0.87,
+        }
+        
+        return quality_scores.get(model, 0.75)
+    
+    def _get_estimated_cost(self, provider: str, model: str) -> float:
+        """Get estimated cost per 1M tokens (average of input/output).
+        
+        Args:
+            provider: Provider name
+            model: Model name
+            
+        Returns:
+            Estimated cost per 1M tokens in USD
+        """
+        # Rough estimates - should match MODEL_CATALOG
+        cost_estimates = {
+            "gpt-4.5-turbo-20250205": 2.50,
+            "claude-3-5-sonnet-20241022": 3.00,
+            "claude-sonnet-4-5-20250929": 3.00,
+            "gemini-2.5-pro": 1.25,
+            "gemini-2.5-flash": 0.15,
+            "deepseek-chat": 0.14,
+            "deepseek-reasoner": 0.55,
+            "o1-mini": 3.00,
+            "o3-mini": 1.10,
+            "llama-3.1-70b-versatile": 0.08,
+            "claude-3-5-haiku-20241022": 1.00,
+            "gpt-4.1-mini": 0.15,
+        }
+        
+        return cost_estimates.get(model, 1.0)
+
+
+def select_model_for_file(
+    file_path: Path,
+    extraction_mode: Optional[ExtractionMode] = None,
+    excluded_providers: Optional[List[str]] = None,
+) -> Tuple[str, str, str]:
+    """Convenience function to select model for file.
+    
+    Args:
+        file_path: Path to file
+        extraction_mode: Optional extraction mode (auto-detected if None)
+        excluded_providers: Providers to exclude
+        
+    Returns:
+        Tuple of (provider, model, reasoning)
+        
+    Examples:
+        >>> provider, model, reason = select_model_for_file(Path("data.csv"))
+        >>> print(f"Selected {provider}/{model}: {reason}")
+    """
+    selector = ModelSelector()
+    recommendation = selector.select_for_file(file_path, extraction_mode, excluded_providers)
+    return recommendation.provider, recommendation.model, recommendation.reasoning