realtimex-deeptutor 0.5.0.post1__py3-none-any.whl

src/agents/solve/utils/config_validator.py

@@ -0,0 +1,313 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Config Validator - Configuration validator
+Validates the completeness and correctness of config.yaml
+"""
+
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+
+class ConfigValidator:
+    """Configuration validator"""
+
+    # Required top-level configuration items
+    # Note: llm configuration has been moved to environment variables (env_config.py), no longer required in config.yaml
+    REQUIRED_SECTIONS = ["system", "agents"]
+
+    # Required system configuration
+    REQUIRED_SYSTEM_CONFIGS = [
+        "output_base_dir",
+        "save_intermediate_results",
+        # Note: language is now unified in config/main.yaml, not required in sub-configs
+    ]
+
+    # Supported languages (supports multiple formats)
+    SUPPORTED_LANGUAGES = ["zh", "en", "English", "Chinese"]
+
+    # Supported log levels
+    SUPPORTED_LOG_LEVELS = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+
+    # Agent list - dual-loop architecture
+    STANDARD_AGENTS = [
+        # Analysis Loop
+        "investigate_agent",
+        "note_agent",
+        # Solve Loop
+        "manager_agent",
+        "solve_agent",
+        "tool_agent",
+        "response_agent",
+        "precision_answer_agent",
+    ]
+
+    def __init__(self):
+        self.errors: list[str] = []
+        self.warnings: list[str] = []
+
+    def validate(self, config: dict[str, Any]) -> tuple[bool, list[str], list[str]]:
+        """
+        Validate configuration
+
+        Args:
+            config: Configuration dictionary
+
+        Returns:
+            (is_valid, errors, warnings)
+        """
+        self.errors = []
+        self.warnings = []
+
+        # 1. Validate top-level structure
+        self._validate_structure(config)
+
+        # 2. Validate system configuration
+        if "system" in config:
+            self._validate_system(config["system"])
+
+        # 3. Validate agents configuration
+        if "agents" in config:
+            self._validate_agents(config["agents"])
+
+        # 4. Validate llm configuration (optional, LLM config now mainly comes from environment variables)
+        if "llm" in config:
+            self._validate_llm(config["llm"])
+
+        # 5. Validate logging configuration (optional)
+        if "logging" in config:
+            self._validate_logging(config["logging"])
+
+        # 6. Validate monitoring configuration (optional)
+        if "monitoring" in config:
+            self._validate_monitoring(config["monitoring"])
+
+        is_valid = len(self.errors) == 0
+        return is_valid, self.errors, self.warnings
+
+    def _validate_structure(self, config: dict[str, Any]):
+        """Validate top-level structure"""
+        for section in self.REQUIRED_SECTIONS:
+            if section not in config:
+                self.errors.append(f"Missing required configuration section: {section}")
+
+    def _validate_system(self, system_config: dict[str, Any]):
+        """Validate system configuration"""
+        if system_config is None:
+            self.errors.append("system configuration cannot be None")
+            return
+
+        # Check required fields
+        for field in self.REQUIRED_SYSTEM_CONFIGS:
+            if field not in system_config:
+                self.errors.append(f"system config missing required field: {field}")
+
+        # Check language configuration (unified in config/main.yaml, optional in sub-configs)
+        if "language" in system_config:
+            lang = system_config["language"]
+            if lang not in self.SUPPORTED_LANGUAGES:
+                self.warnings.append(
+                    f"language '{lang}' not in supported list: {self.SUPPORTED_LANGUAGES}. Suggest unified configuration in config/main.yaml."
+                )
+        # Backward compatibility: if output_language still exists, give warning
+        if "output_language" in system_config:
+            self.warnings.append(
+                "output_language is deprecated, please use language field. Language configuration has been unified to system.language in config/main.yaml"
+            )
+
+        # Check auto_solve configuration
+        if "auto_solve" in system_config:
+            if not isinstance(system_config["auto_solve"], bool):
+                self.errors.append("auto_solve must be a boolean value")
+
+    def _validate_agents(self, agents_config: dict[str, Any]):
+        """Validate agents configuration"""
+        if agents_config is None:
+            self.errors.append("agents config cannot be None")
+            return
+
+        # Check if standard agents are configured
+        for agent_name in self.STANDARD_AGENTS:
+            if agent_name not in agents_config:
+                self.warnings.append(f"Agent not configured: {agent_name}")
+            else:
+                self._validate_agent_config(agent_name, agents_config[agent_name])
+
+    def _validate_agent_config(self, agent_name: str, agent_config: dict[str, Any]):
+        """Validate single Agent configuration"""
+        if agent_config is None:
+            self.errors.append(f"{agent_name} config cannot be None")
+            return
+
+        # Check enabled field
+        if "enabled" in agent_config:
+            if not isinstance(agent_config["enabled"], bool):
+                self.errors.append(f"{agent_name}.enabled must be a boolean value")
+
+        # Check model field
+        if "model" in agent_config:
+            if not isinstance(agent_config["model"], str):
+                self.errors.append(f"{agent_name}.model must be a string")
+
+        # Check temperature field
+        if "temperature" in agent_config:
+            temp = agent_config["temperature"]
+            if not isinstance(temp, (int, float)):
+                self.errors.append(f"{agent_name}.temperature must be a number")
+            elif not 0 <= temp <= 2:
+                self.warnings.append(
+                    f"{agent_name}.temperature={temp} exceeds recommended range [0, 2]"
+                )
+
+        # Check max_retries field
+        if "max_retries" in agent_config:
+            if not isinstance(agent_config["max_retries"], int):
+                self.errors.append(f"{agent_name}.max_retries must be an integer")
+            elif agent_config["max_retries"] < 0:
+                self.errors.append(f"{agent_name}.max_retries cannot be negative")
+
+    def _validate_llm(self, llm_config: dict[str, Any]):
+        """Validate llm configuration"""
+        if llm_config is None:
+            self.errors.append("llm config cannot be None")
+            return
+
+        # Check default_model
+        if "default_model" not in llm_config:
+            self.warnings.append("llm config missing default_model field")
+
+        # Check max_retries
+        if "max_retries" in llm_config:
+            if not isinstance(llm_config["max_retries"], int):
+                self.errors.append("llm.max_retries must be an integer")
+            elif llm_config["max_retries"] < 0:
+                self.errors.append("llm.max_retries cannot be negative")
+
+        # Check timeout
+        if "timeout" in llm_config:
+            if not isinstance(llm_config["timeout"], (int, float)):
+                self.errors.append("llm.timeout must be a number")
+            elif llm_config["timeout"] <= 0:
+                self.warnings.append("llm.timeout should not be negative or zero")
+
+    def _validate_logging(self, logging_config: dict[str, Any]):
+        """Validate logging configuration"""
+        if logging_config is None:
+            # logging is optional, if None but not empty key, may be considered error or ignored
+            self.errors.append("logging config cannot be None")
+            return
+
+        # Check level
+        if "level" in logging_config:
+            level = logging_config["level"]
+            if level not in self.SUPPORTED_LOG_LEVELS:
+                self.errors.append(
+                    f"logging.level '{level}' not in supported list: {self.SUPPORTED_LOG_LEVELS}"
+                )
+
+        # Check save_to_file
+        if "save_to_file" in logging_config:
+            if not isinstance(logging_config["save_to_file"], bool):
+                self.errors.append("logging.save_to_file must be a boolean value")
+
+        # Check verbose
+        if "verbose" in logging_config:
+            if not isinstance(logging_config["verbose"], bool):
+                self.errors.append("logging.verbose must be a boolean value")
+
+    def _validate_monitoring(self, monitoring_config: dict[str, Any]):
+        """Validate monitoring configuration"""
+        if monitoring_config is None:
+            self.errors.append("monitoring config cannot be None")
+            return
+
+        # Check enabled
+        if "enabled" in monitoring_config:
+            if not isinstance(monitoring_config["enabled"], bool):
+                self.errors.append("monitoring.enabled must be a boolean value")
+
+        # Check track_token_usage
+        if "track_token_usage" in monitoring_config:
+            if not isinstance(monitoring_config["track_token_usage"], bool):
+                self.errors.append("monitoring.track_token_usage must be a boolean value")
+
+        # Check track_time
+        if "track_time" in monitoring_config:
+            if not isinstance(monitoring_config["track_time"], bool):
+                self.errors.append("monitoring.track_time must be a boolean value")
+
+
+def validate_config_file(config_path: str) -> tuple[bool, list[str], list[str]]:
+    """
+    Validate configuration file
+
+    Args:
+        config_path: Configuration file path
+
+    Returns:
+        (is_valid, errors, warnings)
+    """
+    try:
+        with open(config_path, encoding="utf-8") as f:
+            config = yaml.safe_load(f)
+    except FileNotFoundError:
+        return False, [f"Configuration file does not exist: {config_path}"], []
+    except yaml.YAMLError as e:
+        return False, [f"YAML parsing error: {e!s}"], []
+    except Exception as e:
+        return False, [f"Failed to load configuration file: {e!s}"], []
+
+    validator = ConfigValidator()
+    return validator.validate(config)
+
+
+def print_validation_result(is_valid: bool, errors: list[str], warnings: list[str]):
+    """
+    Print validation result
+
+    Args:
+        is_valid: Whether configuration is valid
+        errors: List of errors
+        warnings: List of warnings
+    """
+    print("=" * 60)
+    print("Configuration Validation Result")
+    print("=" * 60)
+
+    if is_valid:
+        print("✓ Configuration validation passed")
+    else:
+        print("✗ Configuration validation failed")
+
+    print()
+
+    if errors:
+        print(f"Errors ({len(errors)}):")
+        for i, error in enumerate(errors, 1):
+            print(f"  {i}. {error}")
+        print()
+
+    if warnings:
+        print(f"Warnings ({len(warnings)}):")
+        for i, warning in enumerate(warnings, 1):
+            print(f"  {i}. {warning}")
+        print()
+
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    # Test configuration validation
+    print("Configuration Validation Test")
+    print("=" * 60)
+
+    # Validate config.yaml in current directory
+    config_path = Path(__file__).parent.parent.parent.parent / "config.yaml"
+
+    if config_path.exists():
+        is_valid, errors, warnings = validate_config_file(str(config_path))
+        print_validation_result(is_valid, errors, warnings)
+    else:
+        print(f"Configuration file not found: {config_path}")

src/agents/solve/utils/display_manager.py

@@ -0,0 +1,223 @@
+# -*- coding: utf-8 -*-
+"""
+Display Manager - Terminal display manager
+Uses rich library to implement beautiful terminal interface, including fixed header (status/statistics) and scrolling log area
+"""
+
+from datetime import datetime
+import sys
+from typing import Any
+
+try:
+    from rich.console import Console
+    from rich.layout import Layout
+    from rich.live import Live
+    from rich.panel import Panel
+    from rich.table import Table
+    from rich.text import Text
+
+    RICH_AVAILABLE = True
+except ImportError:
+    RICH_AVAILABLE = False
+
+
+class DisplayManager:
+    """
+    Terminal display manager
+
+    If rich is available, use TUI interface:
+    - Top: Agent status checklist + Token/Cost statistics
+    - Bottom: Scrolling logs
+
+    If rich is not available, fall back to standard stdout output
+    """
+
+    def __init__(self):
+        self.rich_available = RICH_AVAILABLE
+
+        self.agents_status = {
+            "InvestigateAgent": "pending",
+            "NoteAgent": "pending",
+            "ManagerAgent": "pending",
+            "SolveAgent": "pending",
+            "ToolAgent": "pending",
+            "ResponseAgent": "pending",
+            "PrecisionAnswerAgent": "pending",
+        }
+
+        self.stats = {
+            "model": "Unknown",
+            "calls": 0,
+            "tokens": 0,
+            "input_tokens": 0,
+            "output_tokens": 0,
+            "cost": 0.0,
+        }
+
+        # Log buffer
+        self.log_buffer = []
+        self.max_log_lines = 20
+
+        # Early return if rich not available (but after initializing core attributes)
+        if not self.rich_available:
+            self.console = None
+            self.layout = None
+            self.live = None
+            return
+
+        # Explicitly use raw stdout, bypass logger redirection
+        self.console = Console(file=sys.__stdout__)
+
+        # Layout
+        self.layout = self._make_layout()
+
+        # Live update context
+        self.live = None
+
+    def start(self):
+        """Start Live Display"""
+        if self.rich_available and self.live is None:
+            self.live = Live(
+                self.layout,
+                refresh_per_second=4,
+                console=self.console,
+                transient=True,  # Remove interface on exit to avoid blocking subsequent input
+            )
+            self.live.start()
+
+    def stop(self):
+        """Stop Live Display"""
+        if self.rich_available and self.live:
+            self.live.stop()
+            self.live = None
+
+    def _make_layout(self) -> "Layout":
+        """Create layout"""
+        layout = Layout()
+
+        # Split into upper part (fixed info) and lower part (logs)
+        layout.split_column(Layout(name="header", size=10), Layout(name="body"))
+
+        # Split upper part into left (Agents) and right (Stats)
+        layout["header"].split_row(Layout(name="agents", ratio=1), Layout(name="stats", ratio=2))
+
+        return layout
+
+    def update(self):
+        """Update interface content"""
+        if not self.rich_available:
+            return
+
+        # Update Agents status panel
+        agents_table = Table(show_header=False, box=None, padding=(0, 1), expand=True)
+        agents_table.add_column("Status", width=2)
+        agents_table.add_column("Name")
+
+        for name, status in self.agents_status.items():
+            if status == "done":
+                icon = "✓"
+                style = "green"
+            elif status == "running":
+                icon = "●"
+                style = "yellow"
+            elif status == "error":
+                icon = "✗"
+                style = "red"
+            else:
+                icon = " "
+                style = "dim"
+
+            agents_table.add_row(Text(icon, style=style), Text(name, style=style))
+
+        self.layout["agents"].update(
+            Panel(
+                agents_table,
+                title="📦 Agents Status",
+                border_style="blue",
+                padding=(0, 1),  # Increase panel padding
+            )
+        )
+
+        # Update statistics panel
+        stats_content = (
+            f"[bold]{self.stats['model']}[/bold]\n"
+            f"Calls: {self.stats['calls']}\n"
+            f"Tokens: {self.stats['tokens']:,} "
+            f"(Input: {self.stats['input_tokens']:,}, Output: {self.stats['output_tokens']:,})\n"
+            f"[bold yellow]Cost: ${self.stats['cost']:.6f} USD[/bold yellow]"
+        )
+
+        self.layout["stats"].update(
+            Panel(
+                stats_content,
+                title="📊 Performance & Cost",
+                border_style="green",
+                padding=(0, 1),  # Increase panel padding
+            )
+        )
+
+        # Update log panel
+        log_text = "\n".join(self.log_buffer[-self.max_log_lines :])
+        self.layout["body"].update(
+            Panel(
+                log_text,
+                title="📝 Activity Log",
+                border_style="white",
+                padding=(0, 1),  # Increase panel padding
+            )
+        )
+
+    def set_agent_status(self, agent_name: str, status: str):
+        """Set Agent status (pending, running, done, error)"""
+        self.agents_status[agent_name] = status
+        self.update()
+
+    def update_token_stats(self, summary: dict[str, Any]):
+        """Update Token statistics"""
+        self.stats["calls"] = summary.get("total_calls", 0)
+        self.stats["tokens"] = summary.get("total_tokens", 0)
+        self.stats["input_tokens"] = summary.get("total_prompt_tokens", 0)
+        self.stats["output_tokens"] = summary.get("total_completion_tokens", 0)
+        self.stats["cost"] = summary.get("total_cost_usd", 0.0)
+
+        # Try to get the main model used
+        by_model = summary.get("by_model", {})
+        if by_model:
+            # Find the most called model
+            top_model = max(by_model.items(), key=lambda x: x[1]["calls"])[0]
+            self.stats["model"] = top_model
+
+        self.update()
+
+    def log(self, message: str):
+        """Add log"""
+        if not self.rich_available:
+            print(message)
+            return
+
+        # Simple cleaning
+        clean_msg = message.rstrip()
+        if not clean_msg:
+            return
+
+        # Add timestamp
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        formatted_msg = f"[{timestamp}] {clean_msg}"
+
+        self.log_buffer.append(formatted_msg)
+        # Maintain buffer size
+        if len(self.log_buffer) > 100:
+            self.log_buffer = self.log_buffer[-50:]
+
+        self.update()
+
+
+# Global instance
+_display_manager = None
+
+
+def get_display_manager() -> DisplayManager:
+    global _display_manager
+    if _display_manager is None:
+        _display_manager = DisplayManager()
+    return _display_manager