pygeai-orchestration 0.1.0b2__py3-none-any.whl

pygeai_orchestration/core/composition.py

@@ -0,0 +1,190 @@
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+from pygeai_orchestration.core.base.pattern import BasePattern, PatternResult
+from pygeai_orchestration.core.exceptions import PatternExecutionError
+
+
+class CompositionMode(str, Enum):
+    SEQUENTIAL = "sequential"
+    PARALLEL = "parallel"
+
+
+class CompositionConfig(BaseModel):
+    mode: CompositionMode = Field(
+        default=CompositionMode.SEQUENTIAL,
+        description="Execution mode for composed patterns"
+    )
+    stop_on_error: bool = Field(
+        default=True,
+        description="Stop execution if a pattern fails"
+    )
+    pass_output: bool = Field(
+        default=True,
+        description="Pass output of previous pattern as input to next"
+    )
+
+
+class PatternPipeline:
+    def __init__(self, config: Optional[CompositionConfig] = None):
+        self.config = config or CompositionConfig()
+        self._patterns: list[BasePattern] = []
+        self._results: list[PatternResult] = []
+
+    def add_pattern(self, pattern: BasePattern) -> "PatternPipeline":
+        if not isinstance(pattern, BasePattern):
+            raise TypeError(f"Expected BasePattern, got {type(pattern)}")
+        self._patterns.append(pattern)
+        return self
+
+    def add_patterns(self, *patterns: BasePattern) -> "PatternPipeline":
+        for pattern in patterns:
+            self.add_pattern(pattern)
+        return self
+
+    async def execute(self, initial_input: str, **kwargs) -> PatternResult:
+        if not self._patterns:
+            raise PatternExecutionError("No patterns in pipeline")
+
+        self._results.clear()
+        current_input = initial_input
+
+        if self.config.mode == CompositionMode.SEQUENTIAL:
+            return await self._execute_sequential(current_input, **kwargs)
+        elif self.config.mode == CompositionMode.PARALLEL:
+            return await self._execute_parallel(current_input, **kwargs)
+        else:
+            raise PatternExecutionError(f"Unsupported composition mode: {self.config.mode}")
+
+    async def _execute_sequential(self, initial_input: str, **kwargs) -> PatternResult:
+        current_input = initial_input
+        last_result = None
+
+        for i, pattern in enumerate(self._patterns):
+            try:
+                result = await pattern.execute(current_input, **kwargs)
+                self._results.append(result)
+                last_result = result
+
+                if self.config.pass_output and result.result:
+                    current_input = result.result
+
+            except Exception as e:
+                if self.config.stop_on_error:
+                    raise PatternExecutionError(f"Pattern {i} ({type(pattern).__name__}) failed: {str(e)}")
+
+                error_result = PatternResult(
+                    result="",
+                    success=False,
+                    error=str(e),
+                    metadata={"pattern_index": i, "error": str(e)}
+                )
+                self._results.append(error_result)
+                last_result = error_result
+
+        if last_result is None:
+            raise PatternExecutionError("No results produced")
+
+        return PatternResult(
+            result=last_result.result,
+            success=all(r.success for r in self._results),
+            metadata={
+                "pipeline_results": [
+                    {
+                        "index": i,
+                        "success": r.success,
+                        "result_length": len(r.result) if r.result else 0
+                    }
+                    for i, r in enumerate(self._results)
+                ],
+                "total_patterns": len(self._patterns),
+                "successful_patterns": sum(1 for r in self._results if r.success)
+            }
+        )
+
+    async def _execute_parallel(self, initial_input: str, **kwargs) -> PatternResult:
+        import asyncio
+
+        tasks = [pattern.execute(initial_input, **kwargs) for pattern in self._patterns]
+
+        try:
+            results = await asyncio.gather(*tasks, return_exceptions=True)
+        except Exception as e:
+            raise PatternExecutionError(f"Parallel execution failed: {str(e)}")
+
+        self._results = []
+        for i, result in enumerate(results):
+            if isinstance(result, Exception):
+                error_result = PatternResult(
+                    result="",
+                    success=False,
+                    error=str(result),
+                    metadata={"pattern_index": i, "error": str(result)}
+                )
+                self._results.append(error_result)
+            else:
+                self._results.append(result)
+
+        successful_results = [r for r in self._results if r.success]
+
+        if not successful_results:
+            raise PatternExecutionError("All patterns failed in parallel execution")
+
+        combined_output = "\n\n".join(r.result for r in successful_results if r.result)
+
+        return PatternResult(
+            result=combined_output,
+            success=any(r.success for r in self._results),
+            metadata={
+                "pipeline_results": [
+                    {
+                        "index": i,
+                        "success": r.success,
+                        "result_length": len(r.result) if r.result else 0
+                    }
+                    for i, r in enumerate(self._results)
+                ],
+                "total_patterns": len(self._patterns),
+                "successful_patterns": len(successful_results),
+                "mode": "parallel"
+            }
+        )
+
+    def get_results(self) -> list[PatternResult]:
+        return self._results.copy()
+
+    def clear(self) -> None:
+        self._patterns.clear()
+        self._results.clear()
+
+    def __len__(self) -> int:
+        return len(self._patterns)
+
+
+class PatternComposer:
+    @staticmethod
+    def sequential(*patterns: BasePattern) -> PatternPipeline:
+        config = CompositionConfig(mode=CompositionMode.SEQUENTIAL)
+        pipeline = PatternPipeline(config)
+        return pipeline.add_patterns(*patterns)
+
+    @staticmethod
+    def parallel(*patterns: BasePattern) -> PatternPipeline:
+        config = CompositionConfig(mode=CompositionMode.PARALLEL)
+        pipeline = PatternPipeline(config)
+        return pipeline.add_patterns(*patterns)
+
+    @staticmethod
+    def custom(
+        mode: CompositionMode,
+        stop_on_error: bool = True,
+        pass_output: bool = True
+    ) -> PatternPipeline:
+        config = CompositionConfig(
+            mode=mode,
+            stop_on_error=stop_on_error,
+            pass_output=pass_output
+        )
+        return PatternPipeline(config)

pygeai_orchestration/core/config.py

@@ -0,0 +1,356 @@
+"""Enhanced configuration system for PyGEAI Orchestration.
+
+This module provides a comprehensive configuration management system with support for:
+- Environment variables with .env file loading
+- Configuration profiles (dev, prod, test)
+- YAML/JSON configuration files
+- Validation and type safety
+- Configuration merging and inheritance
+"""
+
+import os
+import json
+from enum import Enum
+from pathlib import Path
+from typing import Any, Dict, Optional, Union
+from pydantic import BaseModel, Field, field_validator
+
+
+class ConfigProfile(str, Enum):
+    """Configuration profile types."""
+
+    DEVELOPMENT = "development"
+    PRODUCTION = "production"
+    TEST = "test"
+    CUSTOM = "custom"
+
+
+class LogLevel(str, Enum):
+    """Logging levels."""
+
+    DEBUG = "DEBUG"
+    INFO = "INFO"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+    CRITICAL = "CRITICAL"
+
+
+class CacheConfig(BaseModel):
+    """Cache configuration settings."""
+
+    enabled: bool = Field(default=True, description="Enable caching")
+    max_size: int = Field(default=1000, description="Maximum cache size")
+    ttl: int = Field(default=3600, description="Cache TTL in seconds")
+    backend: str = Field(default="memory", description="Cache backend type")
+
+    @field_validator("max_size")
+    @classmethod
+    def validate_max_size(cls, v: int) -> int:
+        """Validate max_size is positive."""
+        if v <= 0:
+            raise ValueError("max_size must be positive")
+        return v
+
+    @field_validator("ttl")
+    @classmethod
+    def validate_ttl(cls, v: int) -> int:
+        """Validate TTL is non-negative."""
+        if v < 0:
+            raise ValueError("ttl must be non-negative")
+        return v
+
+
+class MetricsConfig(BaseModel):
+    """Metrics and monitoring configuration."""
+
+    enabled: bool = Field(default=True, description="Enable metrics collection")
+    export_interval: int = Field(default=60, description="Metrics export interval in seconds")
+    export_format: str = Field(default="json", description="Metrics export format")
+    include_labels: bool = Field(default=True, description="Include label dimensions")
+
+    @field_validator("export_interval")
+    @classmethod
+    def validate_export_interval(cls, v: int) -> int:
+        """Validate export interval is positive."""
+        if v <= 0:
+            raise ValueError("export_interval must be positive")
+        return v
+
+
+class ExecutionConfig(BaseModel):
+    """Pattern execution configuration."""
+
+    max_iterations: int = Field(default=10, description="Maximum pattern iterations")
+    timeout: int = Field(default=300, description="Execution timeout in seconds")
+    retry_attempts: int = Field(default=3, description="Number of retry attempts")
+    retry_delay: float = Field(default=1.0, description="Retry delay in seconds")
+    parallel_workers: int = Field(default=4, description="Number of parallel workers")
+
+    @field_validator("max_iterations", "retry_attempts", "parallel_workers")
+    @classmethod
+    def validate_positive(cls, v: int) -> int:
+        """Validate value is positive."""
+        if v <= 0:
+            raise ValueError("Value must be positive")
+        return v
+
+    @field_validator("timeout")
+    @classmethod
+    def validate_timeout(cls, v: int) -> int:
+        """Validate timeout is non-negative."""
+        if v < 0:
+            raise ValueError("timeout must be non-negative")
+        return v
+
+
+class OrchestrationConfig(BaseModel):
+    """Main orchestration configuration."""
+
+    profile: ConfigProfile = Field(
+        default=ConfigProfile.DEVELOPMENT,
+        description="Configuration profile"
+    )
+    log_level: LogLevel = Field(default=LogLevel.INFO, description="Logging level")
+    debug: bool = Field(default=False, description="Enable debug mode")
+    cache: CacheConfig = Field(default_factory=CacheConfig, description="Cache settings")
+    metrics: MetricsConfig = Field(default_factory=MetricsConfig, description="Metrics settings")
+    execution: ExecutionConfig = Field(
+        default_factory=ExecutionConfig,
+        description="Execution settings"
+    )
+    custom: Dict[str, Any] = Field(default_factory=dict, description="Custom configuration")
+
+    @classmethod
+    def from_env(cls, prefix: str = "PYGEAI_") -> "OrchestrationConfig":
+        """Create configuration from environment variables.
+
+        Args:
+            prefix: Environment variable prefix
+
+        Returns:
+            OrchestrationConfig instance
+        """
+        config_data: Dict[str, Any] = {}
+
+        profile = os.getenv(f"{prefix}PROFILE")
+        if profile:
+            config_data["profile"] = profile
+
+        log_level = os.getenv(f"{prefix}LOG_LEVEL")
+        if log_level:
+            config_data["log_level"] = log_level
+
+        debug = os.getenv(f"{prefix}DEBUG")
+        if debug:
+            config_data["debug"] = debug.lower() in ("true", "1", "yes")
+
+        cache_enabled = os.getenv(f"{prefix}CACHE_ENABLED")
+        if cache_enabled:
+            config_data.setdefault("cache", {})
+            config_data["cache"]["enabled"] = cache_enabled.lower() in ("true", "1", "yes")
+
+        cache_size = os.getenv(f"{prefix}CACHE_MAX_SIZE")
+        if cache_size:
+            config_data.setdefault("cache", {})
+            config_data["cache"]["max_size"] = int(cache_size)
+
+        metrics_enabled = os.getenv(f"{prefix}METRICS_ENABLED")
+        if metrics_enabled:
+            config_data.setdefault("metrics", {})
+            config_data["metrics"]["enabled"] = metrics_enabled.lower() in ("true", "1", "yes")
+
+        max_iterations = os.getenv(f"{prefix}MAX_ITERATIONS")
+        if max_iterations:
+            config_data.setdefault("execution", {})
+            config_data["execution"]["max_iterations"] = int(max_iterations)
+
+        timeout = os.getenv(f"{prefix}TIMEOUT")
+        if timeout:
+            config_data.setdefault("execution", {})
+            config_data["execution"]["timeout"] = int(timeout)
+
+        return cls(**config_data)
+
+    @classmethod
+    def from_file(cls, path: Union[str, Path]) -> "OrchestrationConfig":
+        """Load configuration from JSON file.
+
+        Args:
+            path: Path to configuration file
+
+        Returns:
+            OrchestrationConfig instance
+
+        Raises:
+            FileNotFoundError: If file doesn't exist
+            ValueError: If file format is invalid
+        """
+        file_path = Path(path)
+        if not file_path.exists():
+            raise FileNotFoundError(f"Configuration file not found: {path}")
+
+        with open(file_path, "r") as f:
+            data = json.load(f)
+
+        return cls(**data)
+
+    def to_file(self, path: Union[str, Path]) -> None:
+        """Save configuration to JSON file.
+
+        Args:
+            path: Path to save configuration
+        """
+        file_path = Path(path)
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(file_path, "w") as f:
+            json.dump(self.model_dump(), f, indent=2)
+
+    def merge(self, other: "OrchestrationConfig") -> "OrchestrationConfig":
+        """Merge with another configuration.
+
+        Args:
+            other: Configuration to merge
+
+        Returns:
+            New merged configuration
+        """
+        self_dict = self.model_dump()
+        other_dict = other.model_dump()
+
+        merged = self._deep_merge(self_dict, other_dict)
+        return OrchestrationConfig(**merged)
+
+    @staticmethod
+    def _deep_merge(base: Dict[str, Any], override: Dict[str, Any]) -> Dict[str, Any]:
+        """Deep merge two dictionaries.
+
+        Args:
+            base: Base dictionary
+            override: Override dictionary
+
+        Returns:
+            Merged dictionary
+        """
+        result = base.copy()
+
+        for key, value in override.items():
+            if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+                result[key] = OrchestrationConfig._deep_merge(result[key], value)
+            else:
+                result[key] = value
+
+        return result
+
+    def get_profile_config(self) -> "OrchestrationConfig":
+        """Get profile-specific configuration.
+
+        Returns:
+            Configuration with profile-specific defaults
+        """
+        if self.profile == ConfigProfile.PRODUCTION:
+            base_dict = self.model_dump()
+            profile_overrides = {
+                "log_level": LogLevel.WARNING,
+                "debug": False,
+                "execution": {
+                    "max_iterations": 20,
+                    "timeout": 600,
+                    "retry_attempts": 5
+                }
+            }
+            merged = self._deep_merge(base_dict, profile_overrides)
+            return OrchestrationConfig(**merged)
+        elif self.profile == ConfigProfile.TEST:
+            base_dict = self.model_dump()
+            profile_overrides = {
+                "log_level": LogLevel.DEBUG,
+                "debug": True,
+                "cache": {"enabled": False},
+                "metrics": {"enabled": False},
+                "execution": {
+                    "max_iterations": 5,
+                    "timeout": 10
+                }
+            }
+            merged = self._deep_merge(base_dict, profile_overrides)
+            return OrchestrationConfig(**merged)
+        else:
+            return self
+
+
+class ConfigManager:
+    """Configuration manager for global configuration access."""
+
+    _instance: Optional["ConfigManager"] = None
+    _config: Optional[OrchestrationConfig] = None
+
+    def __new__(cls) -> "ConfigManager":
+        """Ensure singleton instance."""
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    @classmethod
+    def initialize(
+        cls,
+        config: Optional[OrchestrationConfig] = None,
+        config_file: Optional[Union[str, Path]] = None,
+        from_env: bool = True
+    ) -> "ConfigManager":
+        """Initialize configuration manager.
+
+        Args:
+            config: Configuration instance
+            config_file: Path to configuration file
+            from_env: Load from environment variables
+
+        Returns:
+            ConfigManager instance
+        """
+        instance = cls()
+
+        if config:
+            instance._config = config
+        elif config_file:
+            instance._config = OrchestrationConfig.from_file(config_file)
+            instance._config = instance._config.get_profile_config()
+        elif from_env:
+            instance._config = OrchestrationConfig.from_env()
+            instance._config = instance._config.get_profile_config()
+        else:
+            instance._config = OrchestrationConfig()
+            instance._config = instance._config.get_profile_config()
+
+        return instance
+
+    @classmethod
+    def get_config(cls) -> OrchestrationConfig:
+        """Get current configuration.
+
+        Returns:
+            Current configuration
+
+        Raises:
+            RuntimeError: If not initialized
+        """
+        instance = cls()
+        if instance._config is None:
+            instance._config = OrchestrationConfig()
+        return instance._config
+
+    @classmethod
+    def set_config(cls, config: OrchestrationConfig) -> None:
+        """Set configuration.
+
+        Args:
+            config: Configuration to set
+        """
+        instance = cls()
+        instance._config = config
+
+    @classmethod
+    def reset(cls) -> None:
+        """Reset configuration to default."""
+        instance = cls()
+        instance._config = None