pygeai-orchestration 0.1.0b2__py3-none-any.whl

pygeai_orchestration/dev/templates.py

@@ -0,0 +1,321 @@
+"""Pattern templates and code generators."""
+
+from enum import Enum
+from pathlib import Path
+from typing import Dict, Optional
+
+
+class PatternTemplate(str, Enum):
+    """Available pattern templates."""
+
+    REFLECTION = "reflection"
+    REACT = "react"
+    PLANNING = "planning"
+    MULTI_AGENT = "multi_agent"
+    CUSTOM = "custom"
+
+
+class TemplateGenerator:
+    """Generate pattern boilerplate code."""
+
+    @staticmethod
+    def generate_reflection_pattern(
+        name: str,
+        description: str = "Custom reflection pattern"
+    ) -> str:
+        """Generate reflection pattern template.
+
+        Args:
+            name: Pattern class name
+            description: Pattern description
+
+        Returns:
+            Generated code
+        """
+        return f'''"""
+{description}
+"""
+
+from pygeai_orchestration.patterns.reflection import ReflectionPattern
+from pygeai_orchestration.core.base import PatternConfig, PatternResult
+
+
+class {name}(ReflectionPattern):
+    """{description}."""
+
+    async def reflect(self, task: str, result: str, context=None) -> str:
+        """Reflect on task and result.
+
+        Args:
+            task: Original task
+            result: Initial result
+            context: Optional context
+
+        Returns:
+            Reflection feedback
+        """
+        reflection_prompt = f"""
+        Task: {{task}}
+        Result: {{result}}
+
+        Please analyze this result and provide feedback for improvement.
+        """
+
+        reflection = await self.agent.generate(reflection_prompt)
+        return reflection
+
+    async def improve(self, task: str, result: str, reflection: str, context=None) -> str:
+        """Improve result based on reflection.
+
+        Args:
+            task: Original task
+            result: Initial result
+            reflection: Reflection feedback
+            context: Optional context
+
+        Returns:
+            Improved result
+        """
+        improvement_prompt = f"""
+        Task: {{task}}
+        Previous Result: {{result}}
+        Reflection: {{reflection}}
+
+        Please provide an improved result based on the reflection.
+        """
+
+        improved = await self.agent.generate(improvement_prompt)
+        return improved
+'''
+
+    @staticmethod
+    def generate_react_pattern(
+        name: str,
+        description: str = "Custom ReAct pattern"
+    ) -> str:
+        """Generate ReAct pattern template.
+
+        Args:
+            name: Pattern class name
+            description: Pattern description
+
+        Returns:
+            Generated code
+        """
+        return f'''"""
+{description}
+"""
+
+from pygeai_orchestration.patterns.react import ReActPattern
+from pygeai_orchestration.core.base import PatternConfig, PatternResult
+
+
+class {name}(ReActPattern):
+    """{description}."""
+
+    async def think(self, task: str, context=None) -> str:
+        """Reason about the task.
+
+        Args:
+            task: Task to think about
+            context: Optional context
+
+        Returns:
+            Reasoning result
+        """
+        thought_prompt = f"""
+        Task: {{task}}
+
+        Think step by step about how to solve this task.
+        """
+
+        thought = await self.agent.generate(thought_prompt)
+        return thought
+
+    async def act(self, task: str, thought: str, context=None) -> str:
+        """Take action based on reasoning.
+
+        Args:
+            task: Original task
+            thought: Reasoning result
+            context: Optional context
+
+        Returns:
+            Action result
+        """
+        action_prompt = f"""
+        Task: {{task}}
+        Thought: {{thought}}
+
+        Based on this reasoning, take the appropriate action.
+        """
+
+        action = await self.agent.generate(action_prompt)
+        return action
+'''
+
+    @staticmethod
+    def generate_custom_pattern(
+        name: str,
+        description: str = "Custom orchestration pattern"
+    ) -> str:
+        """Generate custom pattern template.
+
+        Args:
+            name: Pattern class name
+            description: Pattern description
+
+        Returns:
+            Generated code
+        """
+        return f'''"""
+{description}
+"""
+
+from pygeai_orchestration.core.base import OrchestrationPattern, PatternConfig, PatternResult
+
+
+class {name}(OrchestrationPattern):
+    """{description}."""
+
+    async def _execute_impl(self, task: str, context=None) -> PatternResult:
+        """Execute pattern implementation.
+
+        Args:
+            task: Task to execute
+            context: Optional execution context
+
+        Returns:
+            Pattern execution result
+        """
+        # TODO: Implement your pattern logic here
+
+        result = await self.agent.generate(task)
+
+        return PatternResult(
+            success=True,
+            result=result,
+            metadata={{"pattern": "{name}"}}
+        )
+'''
+
+    @staticmethod
+    def generate_test_file(
+        pattern_name: str,
+        template: PatternTemplate
+    ) -> str:
+        """Generate test file for pattern.
+
+        Args:
+            pattern_name: Pattern class name
+            template: Pattern template type
+
+        Returns:
+            Generated test code
+        """
+        return f'''"""
+Tests for {pattern_name}.
+"""
+
+import unittest
+from pygeai_orchestration.dev.testing import MockAgent, PatternTestCase
+
+
+class Test{pattern_name}(PatternTestCase):
+    """Test cases for {pattern_name}."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.agent = MockAgent()
+        # TODO: Initialize your pattern
+        # self.pattern = {pattern_name}(self.agent)
+
+    async def test_basic_execution(self):
+        """Test basic pattern execution."""
+        # TODO: Implement test
+        pass
+
+    async def test_error_handling(self):
+        """Test error handling."""
+        # TODO: Implement test
+        pass
+
+    async def test_result_format(self):
+        """Test result format."""
+        # TODO: Implement test
+        pass
+
+
+if __name__ == "__main__":
+    unittest.main()
+'''
+
+    @staticmethod
+    def save_template(
+        code: str,
+        output_path: Path,
+        overwrite: bool = False
+    ) -> None:
+        """Save generated template to file.
+
+        Args:
+            code: Generated code
+            output_path: Output file path
+            overwrite: Whether to overwrite existing file
+
+        Raises:
+            FileExistsError: If file exists and overwrite is False
+        """
+        if output_path.exists() and not overwrite:
+            raise FileExistsError(f"File already exists: {output_path}")
+
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(output_path, "w") as f:
+            f.write(code)
+
+    @classmethod
+    def create_pattern(
+        cls,
+        template: PatternTemplate,
+        name: str,
+        description: str,
+        output_dir: Optional[Path] = None,
+        include_tests: bool = True
+    ) -> Dict[str, str]:
+        """Create complete pattern with optional tests.
+
+        Args:
+            template: Pattern template type
+            name: Pattern class name
+            description: Pattern description
+            output_dir: Output directory (optional)
+            include_tests: Generate test file
+
+        Returns:
+            Dictionary of filename -> code
+        """
+        files = {}
+
+        if template == PatternTemplate.REFLECTION:
+            code = cls.generate_reflection_pattern(name, description)
+        elif template == PatternTemplate.REACT:
+            code = cls.generate_react_pattern(name, description)
+        else:
+            code = cls.generate_custom_pattern(name, description)
+
+        pattern_filename = f"{name.lower()}.py"
+        files[pattern_filename] = code
+
+        if include_tests:
+            test_code = cls.generate_test_file(name, template)
+            test_filename = f"test_{name.lower()}.py"
+            files[test_filename] = test_code
+
+        if output_dir:
+            output_path = Path(output_dir)
+            for filename, content in files.items():
+                file_path = output_path / filename
+                cls.save_template(content, file_path)
+
+        return files

pygeai_orchestration/dev/testing.py

@@ -0,0 +1,301 @@
+"""Testing utilities and helpers."""
+
+import unittest
+from typing import Any, Dict, List, Optional
+from unittest.mock import AsyncMock, MagicMock
+
+from pygeai_orchestration.core.base import BasePattern, PatternConfig, PatternResult, PatternType
+
+
+class MockAgent:
+    """Mock agent for testing."""
+
+    def __init__(self, responses: Optional[List[str]] = None):
+        """Initialize mock agent.
+
+        Args:
+            responses: Pre-defined responses
+        """
+        self.responses = responses or ["Mock response"]
+        self.call_count = 0
+        self.calls: List[Dict[str, Any]] = []
+
+    async def generate(self, prompt: str, **kwargs) -> str:
+        """Generate mock response.
+
+        Args:
+            prompt: Input prompt
+            **kwargs: Additional arguments
+
+        Returns:
+            Mock response
+        """
+        self.calls.append({
+            "prompt": prompt,
+            "kwargs": kwargs,
+            "call_number": self.call_count
+        })
+
+        response_index = min(self.call_count, len(self.responses) - 1)
+        response = self.responses[response_index]
+        self.call_count += 1
+
+        return response
+
+    async def chat(self, messages: List[Dict[str, str]], **kwargs) -> str:
+        """Mock chat method.
+
+        Args:
+            messages: Chat messages
+            **kwargs: Additional arguments
+
+        Returns:
+            Mock response
+        """
+        last_message = messages[-1]["content"] if messages else ""
+        return await self.generate(last_message, **kwargs)
+
+    def reset(self) -> None:
+        """Reset mock agent state."""
+        self.call_count = 0
+        self.calls.clear()
+
+
+class MockPattern(BasePattern):
+    """Mock pattern for testing."""
+
+    def __init__(
+        self,
+        name: str = "MockPattern",
+        result: str = "Mock result",
+        success: bool = True,
+        iterations: int = 1
+    ):
+        """Initialize mock pattern.
+
+        Args:
+            name: Pattern name
+            result: Result to return
+            success: Success status
+            iterations: Number of iterations
+        """
+        config = PatternConfig(
+            name=name,
+            pattern_type=PatternType.REFLECTION
+        )
+        super().__init__(config)
+
+        self.agent = MockAgent([result])
+        self.mock_result = result
+        self.mock_success = success
+        self.mock_iterations = iterations
+        self.execution_count = 0
+
+    async def execute(self, task: str, **kwargs) -> PatternResult:
+        """Execute mock pattern.
+
+        Args:
+            task: Task to execute
+            **kwargs: Additional arguments
+
+        Returns:
+            Mock result
+        """
+        self.execution_count += 1
+
+        return PatternResult(
+            success=self.mock_success,
+            result=self.mock_result,
+            iterations=self.mock_iterations,
+            metadata={"execution_count": self.execution_count}
+        )
+
+    async def step(self, task: str, context=None) -> PatternResult:
+        """Execute one step.
+
+        Args:
+            task: Task to execute
+            context: Optional context
+
+        Returns:
+            Mock result
+        """
+        return await self.execute(task)
+
+
+class PatternTestCase(unittest.IsolatedAsyncioTestCase):
+    """Base test case for pattern testing."""
+
+    def create_mock_agent(self, responses: Optional[List[str]] = None) -> MockAgent:
+        """Create mock agent for testing.
+
+        Args:
+            responses: Pre-defined responses
+
+        Returns:
+            Mock agent instance
+        """
+        return MockAgent(responses)
+
+    def assert_pattern_result(
+        self,
+        result: PatternResult,
+        success: Optional[bool] = None,
+        has_result: bool = True,
+        min_iterations: int = 1
+    ) -> None:
+        """Assert pattern result properties.
+
+        Args:
+            result: Pattern result to check
+            success: Expected success status
+            has_result: Whether result should have output
+            min_iterations: Minimum iterations
+        """
+        self.assertIsInstance(result, PatternResult)
+
+        if success is not None:
+            self.assertEqual(result.success, success)
+
+        if has_result:
+            self.assertIsNotNone(result.result)
+            self.assertNotEqual(result.result, "")
+
+        self.assertGreaterEqual(result.iterations, min_iterations)
+
+    def assert_agent_called(
+        self,
+        agent: MockAgent,
+        min_calls: int = 1,
+        contains: Optional[str] = None
+    ) -> None:
+        """Assert agent was called correctly.
+
+        Args:
+            agent: Mock agent
+            min_calls: Minimum number of calls
+            contains: Text that should be in prompts
+        """
+        self.assertGreaterEqual(agent.call_count, min_calls)
+
+        if contains:
+            prompts = [call["prompt"] for call in agent.calls]
+            self.assertTrue(
+                any(contains in prompt for prompt in prompts),
+                f"No prompt contains '{contains}'"
+            )
+
+
+def create_test_pattern(
+    pattern_class: type,
+    agent_responses: Optional[List[str]] = None,
+    config_overrides: Optional[Dict[str, Any]] = None
+) -> BasePattern:
+    """Create pattern instance for testing.
+
+    Args:
+        pattern_class: Pattern class to instantiate
+        agent_responses: Mock agent responses
+        config_overrides: Configuration overrides
+
+    Returns:
+        Pattern instance
+    """
+    config_dict = {
+        "name": pattern_class.__name__,
+        "pattern_type": PatternType.REFLECTION
+    }
+
+    if config_overrides:
+        config_dict.update(config_overrides)
+
+    config = PatternConfig(**config_dict)
+    pattern = pattern_class(config)
+
+    if agent_responses:
+        pattern.agent = MockAgent(agent_responses)
+
+    return pattern
+
+
+class AsyncMockHelper:
+    """Helper for creating async mocks."""
+
+    @staticmethod
+    def create_async_mock(return_value: Any = None) -> AsyncMock:
+        """Create async mock with return value.
+
+        Args:
+            return_value: Value to return
+
+        Returns:
+            Async mock
+        """
+        mock = AsyncMock()
+        mock.return_value = return_value
+        return mock
+
+    @staticmethod
+    def create_agent_mock(responses: List[str]) -> MagicMock:
+        """Create mock agent with multiple responses.
+
+        Args:
+            responses: List of responses
+
+        Returns:
+            Mock agent
+        """
+        agent = MagicMock()
+        agent.generate = AsyncMock(side_effect=responses)
+        return agent
+
+
+class TestDataBuilder:
+    """Builder for test data."""
+
+    @staticmethod
+    def build_pattern_result(
+        success: bool = True,
+        result: str = "Test result",
+        iterations: int = 1,
+        **metadata
+    ) -> PatternResult:
+        """Build pattern result for testing.
+
+        Args:
+            success: Success status
+            result: Result string
+            iterations: Number of iterations
+            **metadata: Additional metadata
+
+        Returns:
+            Pattern result
+        """
+        return PatternResult(
+            success=success,
+            result=result,
+            iterations=iterations,
+            metadata=metadata
+        )
+
+    @staticmethod
+    def build_pattern_config(
+        name: str = "TestPattern",
+        pattern_type: PatternType = PatternType.REFLECTION,
+        **kwargs
+    ) -> PatternConfig:
+        """Build pattern config for testing.
+
+        Args:
+            name: Pattern name
+            pattern_type: Pattern type
+            **kwargs: Additional config
+
+        Returns:
+            Pattern config
+        """
+        return PatternConfig(
+            name=name,
+            pattern_type=pattern_type,
+            **kwargs
+        )

pygeai_orchestration/patterns/__init__.py

@@ -0,0 +1,15 @@
+from .reflection import ReflectionPattern
+from .tool_use import ToolUsePattern
+from .react import ReActPattern
+from .planning import PlanningPattern, PlanStep
+from .multi_agent import MultiAgentPattern, AgentRole
+
+__all__ = [
+    "ReflectionPattern",
+    "ToolUsePattern",
+    "ReActPattern",
+    "PlanningPattern",
+    "PlanStep",
+    "MultiAgentPattern",
+    "AgentRole",
+]