empathy-framework 5.2.1__py3-none-any.whl → 5.4.0__py3-none-any.whl

empathy_os/test_generator/__init__.py

@@ -1,38 +0,0 @@
-"""Risk-Driven Test Generator for Workflow Factory.
-
-Generates comprehensive tests for workflows based on risk analysis and patterns.
-
-Features:
-- Risk-based test prioritization
-- Pattern-driven test generation
-- Jinja2 templates for unit/integration/E2E tests
-- Fixture generation for common patterns
-- CLI integration
-
-Usage:
-    from test_generator import TestGenerator
-
-    generator = TestGenerator()
-    tests = generator.generate_tests(
-        workflow_id="soap_note",
-        pattern_ids=["linear_flow", "approval", "structured_fields"]
-    )
-
-    # Write tests to file
-    with open("test_soap_note.py", "w") as f:
-        f.write(tests["unit"])
-
-Copyright 2025 Smart AI Memory, LLC
-Licensed under Fair Source 0.9
-"""
-
-from .generator import TestGenerator
-from .risk_analyzer import RiskAnalysis, RiskAnalyzer
-
-__all__ = [
-    "TestGenerator",
-    "RiskAnalyzer",
-    "RiskAnalysis",
-]
-
-__version__ = "1.0.0"

empathy_os/test_generator/__main__.py

@@ -1,14 +0,0 @@
-"""Make test_generator runnable as a module.
-
-Usage:
-    python -m test_generator generate soap_note --patterns linear_flow,approval
-    python -m test_generator analyze debugging --patterns code_analysis_input
-
-Copyright 2025 Smart AI Memory, LLC
-Licensed under Fair Source 0.9
-"""
-
-from .cli import main
-
-if __name__ == "__main__":
-    main()

empathy_os/test_generator/cli.py

@@ -1,234 +0,0 @@
-"""CLI for test generator.
-
-Usage:
-    python -m test_generator.cli generate soap_note --patterns linear_flow,approval,structured_fields
-    python -m test_generator.cli analyze soap_note --patterns linear_flow,approval
-
-Copyright 2025 Smart AI Memory, LLC
-Licensed under Fair Source 0.9
-"""
-
-import argparse
-import heapq
-import json
-import logging
-import sys
-from pathlib import Path
-
-from empathy_os.config import _validate_file_path
-
-from .generator import TestGenerator
-from .risk_analyzer import RiskAnalyzer
-
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(levelname)s: %(message)s",
-)
-logger = logging.getLogger(__name__)
-
-
-def cmd_generate(args):
-    """Generate tests for a workflow.
-
-    Args:
-        args: Command line arguments
-
-    """
-    workflow_id = args.workflow_id
-    pattern_ids = args.patterns.split(",") if args.patterns else []
-
-    logger.info(f"Generating tests for workflow: {workflow_id}")
-    logger.info(f"Patterns: {', '.join(pattern_ids)}")
-
-    # Generate tests
-    generator = TestGenerator()
-    tests = generator.generate_tests(
-        workflow_id=workflow_id,
-        pattern_ids=pattern_ids,
-        workflow_module=args.module,
-        workflow_class=args.workflow_class,
-    )
-
-    # Determine output directory
-    output_dir = Path(args.output) if args.output else Path("tests/unit/workflows")
-    output_dir.mkdir(parents=True, exist_ok=True)
-
-    # Write unit tests
-    unit_test_file = output_dir / f"test_{workflow_id}_workflow.py"
-    validated_unit_test = _validate_file_path(str(unit_test_file))
-    with open(validated_unit_test, "w") as f:
-        f.write(tests["unit"])
-    logger.info(f"✓ Unit tests written to: {validated_unit_test}")
-
-    # Write integration tests (if generated)
-    if tests["integration"]:
-        integration_test_file = (
-            output_dir.parent.parent / "integration" / f"test_{workflow_id}_integration.py"
-        )
-        integration_test_file.parent.mkdir(parents=True, exist_ok=True)
-        validated_integration = _validate_file_path(str(integration_test_file))
-        with open(validated_integration, "w") as f:
-            f.write(tests["integration"])
-        logger.info(f"✓ Integration tests written to: {validated_integration}")
-
-    # Write fixtures
-    fixtures_file = output_dir / f"fixtures_{workflow_id}.py"
-    validated_fixtures = _validate_file_path(str(fixtures_file))
-    with open(validated_fixtures, "w") as f:
-        f.write(tests["fixtures"])
-    logger.info(f"✓ Fixtures written to: {validated_fixtures}")
-
-    print("\n🎉 Test generation complete!")
-    print("\nGenerated files:")
-    print(f"  - {unit_test_file}")
-    if tests["integration"]:
-        print(f"  - {integration_test_file}")
-    print(f"  - {fixtures_file}")
-
-    print("\nNext steps:")
-    print("  1. Review generated tests")
-    print(f"  2. Run tests: pytest {unit_test_file}")
-    print("  3. Add custom test cases as needed")
-
-
-def cmd_analyze(args):
-    """Analyze workflow risk and show recommendations.
-
-    Args:
-        args: Command line arguments
-
-    """
-    workflow_id = args.workflow_id
-    pattern_ids = args.patterns.split(",") if args.patterns else []
-
-    logger.info(f"Analyzing workflow: {workflow_id}")
-
-    # Perform risk analysis
-    analyzer = RiskAnalyzer()
-    analysis = analyzer.analyze(workflow_id, pattern_ids)
-
-    # Display results
-    print(f"\n{'=' * 60}")
-    print(f"Risk Analysis: {workflow_id}")
-    print(f"{'=' * 60}\n")
-
-    print(f"Patterns Used: {len(analysis.pattern_ids)}")
-    for pid in analysis.pattern_ids:
-        print(f"  - {pid}")
-
-    print(f"\nCritical Paths: {len(analysis.critical_paths)}")
-    for path in analysis.critical_paths:
-        print(f"  - {path}")
-
-    print(f"\nHigh-Risk Inputs: {len(analysis.high_risk_inputs)}")
-    for input_risk in analysis.high_risk_inputs[:5]:  # Top 5
-        print(f"  - {input_risk}")
-
-    print(f"\nValidation Points: {len(analysis.validation_points)}")
-    for validation in analysis.validation_points[:5]:  # Top 5
-        print(f"  - {validation}")
-
-    print(f"\n{'=' * 60}")
-    print(f"Recommended Test Coverage: {analysis.recommended_coverage}%")
-    print(f"{'=' * 60}\n")
-
-    print("Test Priorities:")
-    for test_name, priority in heapq.nsmallest(
-        10, analysis.test_priorities.items(), key=lambda x: x[1]
-    ):
-        priority_label = {
-            1: "CRITICAL",
-            2: "HIGH",
-            3: "MEDIUM",
-            4: "LOW",
-            5: "OPTIONAL",
-        }.get(priority, "UNKNOWN")
-        print(f"  [{priority_label:8}] {test_name}")
-
-    # JSON output if requested
-    if args.json:
-        json_output = analysis.to_dict()
-        json_file = Path(f"{workflow_id}_risk_analysis.json")
-        with open(json_file, "w") as f:
-            json.dump(json_output, f, indent=2)
-        print(f"\n✓ JSON output written to: {json_file}")
-
-
-def main():
-    """Main CLI entry point."""
-    parser = argparse.ArgumentParser(
-        description="Test Generator for Empathy Workflow Factory",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-  # Generate tests for SOAP Note workflow
-  %(prog)s generate soap_note --patterns linear_flow,approval,structured_fields
-
-  # Analyze risk for debugging workflow
-  %(prog)s analyze debugging --patterns code_analysis_input,risk_assessment
-
-  # Generate with custom module/class
-  %(prog)s generate my_workflow --patterns linear_flow --module workflows.my_workflow --class MyWorkflow
-
-  # Output to custom directory
-  %(prog)s generate soap_note --patterns linear_flow --output tests/custom/
-        """,
-    )
-
-    subparsers = parser.add_subparsers(dest="command", help="Command to run")
-
-    # Generate command
-    gen_parser = subparsers.add_parser("generate", help="Generate tests for a workflow")
-    gen_parser.add_argument("workflow_id", help="Workflow identifier (e.g., soap_note)")
-    gen_parser.add_argument(
-        "--patterns",
-        required=True,
-        help="Comma-separated pattern IDs (e.g., linear_flow,approval)",
-    )
-    gen_parser.add_argument(
-        "--module",
-        help="Python module path (e.g., workflows.soap_note)",
-    )
-    gen_parser.add_argument(
-        "--class",
-        dest="workflow_class",
-        help="Workflow class name (e.g., SOAPNoteWorkflow)",
-    )
-    gen_parser.add_argument(
-        "--output",
-        "-o",
-        help="Output directory (default: tests/unit/workflows/)",
-    )
-
-    # Analyze command
-    analyze_parser = subparsers.add_parser("analyze", help="Analyze workflow risk")
-    analyze_parser.add_argument("workflow_id", help="Workflow identifier")
-    analyze_parser.add_argument(
-        "--patterns",
-        required=True,
-        help="Comma-separated pattern IDs",
-    )
-    analyze_parser.add_argument(
-        "--json",
-        action="store_true",
-        help="Output JSON file with analysis results",
-    )
-
-    args = parser.parse_args()
-
-    if not args.command:
-        parser.print_help()
-        sys.exit(1)
-
-    # Execute command
-    if args.command == "generate":
-        cmd_generate(args)
-    elif args.command == "analyze":
-        cmd_analyze(args)
-    else:
-        parser.print_help()
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()

empathy_os/test_generator/generator.py

@@ -1,355 +0,0 @@
-"""Test generator core implementation.
-
-Generates comprehensive tests for workflows using Jinja2 templates
-and risk-based prioritization.
-
-Copyright 2025 Smart AI Memory, LLC
-Licensed under Fair Source 0.9
-"""
-
-import logging
-from datetime import datetime
-from pathlib import Path
-from typing import Any
-
-from jinja2 import Environment, FileSystemLoader
-
-from patterns import get_pattern_registry
-from patterns.structural import LinearFlowPattern, PhasedProcessingPattern
-
-from .risk_analyzer import RiskAnalyzer
-
-logger = logging.getLogger(__name__)
-
-
-def _get_default_template_dir() -> Path:
-    """Get default template directory.
-
-    Returns:
-        Path to templates directory
-
-    Note:
-        Uses multiple fallback strategies to avoid __file__ AttributeError
-        in pytest environments.
-    """
-    try:
-        # Try __file__ first (works in most cases)
-        return Path(__file__).parent / "templates"
-    except (AttributeError, NameError):
-        # Fallback: Use module __spec__ if available
-        import importlib.util
-        import sys
-
-        spec = importlib.util.find_spec("empathy_os.test_generator")
-        if spec and spec.origin:
-            return Path(spec.origin).parent / "templates"
-
-        # Last resort: Try to find from sys.modules
-        this_module = sys.modules.get(__name__)
-        if this_module and hasattr(this_module, "__file__") and this_module.__file__:
-            return Path(this_module.__file__).parent / "templates"
-
-        # Final fallback: Use current working directory
-        return Path.cwd() / "src" / "empathy_os" / "test_generator" / "templates"
-
-
-class TestGenerator:
-    """Generates tests for workflows based on patterns and risk analysis.
-
-    Uses Jinja2 templates to generate:
-    - Unit tests with risk-prioritized coverage
-    - Integration tests for multi-step workflows
-    - E2E tests for critical paths
-    - Test fixtures for common patterns
-    """
-
-    def __init__(self, template_dir: Path | None = None):
-        """Initialize test generator.
-
-        Args:
-            template_dir: Directory containing Jinja2 templates
-                         (defaults to test_generator/templates/)
-
-        """
-        if template_dir is None:
-            template_dir = _get_default_template_dir()
-
-        self.template_dir = template_dir
-        self.env = Environment(
-            loader=FileSystemLoader(str(template_dir)),
-            trim_blocks=True,
-            lstrip_blocks=True,
-            autoescape=True,  # Enable autoescape for security (test gen templates should be safe)
-        )
-
-        self.risk_analyzer = RiskAnalyzer()
-        self.registry = get_pattern_registry()
-
-    def generate_tests(
-        self,
-        workflow_id: str,
-        pattern_ids: list[str],
-        workflow_module: str | None = None,
-        workflow_class: str | None = None,
-    ) -> dict[str, str | None]:
-        """Generate tests for a workflow.
-
-        Args:
-            workflow_id: Workflow identifier
-            pattern_ids: List of pattern IDs used by workflow
-            workflow_module: Python module path (e.g., "workflows.soap_note")
-            workflow_class: Workflow class name (e.g., "SOAPNoteWorkflow")
-
-        Returns:
-            Dictionary with test types:
-                {
-                    "unit": "...",  # Unit test code
-                    "integration": "...",  # Integration test code (if applicable)
-                    "fixtures": "...",  # Test fixtures
-                }
-
-        """
-        logger.info(f"Generating tests for workflow: {workflow_id}")
-
-        # Perform risk analysis
-        risk_analysis = self.risk_analyzer.analyze(workflow_id, pattern_ids)
-
-        # Infer module and class if not provided
-        if not workflow_module:
-            workflow_module = self._infer_module(workflow_id)
-
-        if not workflow_class:
-            workflow_class = self._infer_class_name(workflow_id)
-
-        # Gather template context
-        context = self._build_template_context(
-            workflow_id=workflow_id,
-            pattern_ids=pattern_ids,
-            workflow_module=workflow_module,
-            workflow_class=workflow_class,
-            risk_analysis=risk_analysis,
-        )
-
-        # Generate unit tests (always)
-        unit_tests = self._generate_unit_tests(context)
-
-        # Generate integration tests (for multi-step workflows)
-        integration_tests = None
-        if self._needs_integration_tests(pattern_ids):
-            integration_tests = self._generate_integration_tests(context)
-
-        # Generate test fixtures
-        fixtures = self._generate_fixtures(context)
-
-        logger.info(
-            f"Generated tests for {workflow_id}: "
-            f"unit={len(unit_tests)} chars, "
-            f"integration={'yes' if integration_tests else 'no'}, "
-            f"fixtures={len(fixtures)} chars"
-        )
-
-        return {
-            "unit": unit_tests,
-            "integration": integration_tests,
-            "fixtures": fixtures,
-        }
-
-    def _build_template_context(
-        self,
-        workflow_id: str,
-        pattern_ids: list[str],
-        workflow_module: str,
-        workflow_class: str,
-        risk_analysis: Any,
-    ) -> dict:
-        """Build Jinja2 template context.
-
-        Args:
-            workflow_id: Workflow identifier
-            pattern_ids: Pattern IDs
-            workflow_module: Module path
-            workflow_class: Class name
-            risk_analysis: RiskAnalysis object
-
-        Returns:
-            Context dictionary for templates
-
-        """
-        # Get pattern details
-        patterns = [self.registry.get(pid) for pid in pattern_ids if self.registry.get(pid)]
-
-        # Check for specific patterns
-        has_linear_flow = "linear_flow" in pattern_ids
-        has_phased = "phased_processing" in pattern_ids
-        has_approval = "approval" in pattern_ids
-        has_async = True  # Assume async by default for modern workflows
-
-        # Get linear flow details if present
-        total_steps = None
-        if has_linear_flow:
-            linear_pattern = self.registry.get("linear_flow")
-            if isinstance(linear_pattern, LinearFlowPattern):
-                total_steps = linear_pattern.total_steps
-
-        # Get phases if present
-        phases = []
-        if has_phased:
-            phased_pattern = self.registry.get("phased_processing")
-            if isinstance(phased_pattern, PhasedProcessingPattern):
-                phases = phased_pattern.phases
-
-        return {
-            "workflow_id": workflow_id,
-            "workflow_module": workflow_module,
-            "workflow_class": workflow_class,
-            "pattern_ids": pattern_ids,
-            "patterns": patterns,
-            "risk_analysis": risk_analysis,
-            "has_async": has_async,
-            "has_linear_flow": has_linear_flow,
-            "has_phased": has_phased,
-            "has_approval": has_approval,
-            "total_steps": total_steps,
-            "phases": phases,
-            "timestamp": datetime.now().isoformat(),
-        }
-
-    def _generate_unit_tests(self, context: dict) -> str:
-        """Generate unit tests from template.
-
-        Args:
-            context: Template context
-
-        Returns:
-            Generated unit test code
-
-        """
-        template = self.env.get_template("unit_test.py.jinja2")
-        return template.render(**context)
-
-    def _generate_integration_tests(self, context: dict) -> str:
-        """Generate integration tests.
-
-        Args:
-            context: Template context
-
-        Returns:
-            Generated integration test code
-
-        """
-        # For now, return a simple integration test template
-        # In full implementation, would use integration_test.py.jinja2
-        return f'''"""Integration tests for {context["workflow_id"]} workflow.
-
-Auto-generated by Empathy Framework Test Generator
-Tests end-to-end workflow workflows.
-"""
-
-import pytest
-from {context["workflow_module"]} import {context["workflow_class"]}
-
-
-class TestIntegration{context["workflow_class"]}:
-    """Integration tests for {context["workflow_id"]} workflow."""
-
-    @pytest.fixture
-    async def workflow(self):
-        """Create workflow instance."""
-        return {context["workflow_class"]}()
-
-    @pytest.mark.asyncio
-    async def test_complete_workflow_workflow(self, workflow):
-        """Test complete workflow workflow end-to-end."""
-        # Start workflow
-        session = await workflow.start()
-        workflow_id = session["workflow_id"]
-
-        # Complete all steps with valid data
-        # TODO: Add step completion logic
-
-        # Verify final state
-        assert session.get("completed", False) is True
-'''
-
-    def _generate_fixtures(self, context: dict) -> str:
-        """Generate test fixtures.
-
-        Args:
-            context: Template context
-
-        Returns:
-            Generated fixture code
-
-        """
-        return f'''"""Test fixtures for {context["workflow_id"]} workflow.
-
-Auto-generated by Empathy Framework Test Generator
-Provides common test data and mocks.
-"""
-
-import pytest
-from unittest.mock import MagicMock
-
-
-@pytest.fixture
-def sample_{context["workflow_id"]}_data():
-    """Sample data for {context["workflow_id"]} workflow."""
-    return {{
-        "field1": "test value 1",
-        "field2": "test value 2",
-    }}
-
-
-@pytest.fixture
-def mock_{context["workflow_id"]}_dependencies():
-    """Mock dependencies for {context["workflow_id"]} workflow."""
-    return {{
-        "database": MagicMock(),
-        "api_client": MagicMock(),
-    }}
-'''
-
-    def _needs_integration_tests(self, pattern_ids: list[str]) -> bool:
-        """Determine if integration tests are needed.
-
-        Args:
-            pattern_ids: Pattern IDs
-
-        Returns:
-            True if integration tests recommended
-
-        """
-        # Integration tests for multi-step or phased workflows
-        return "linear_flow" in pattern_ids or "phased_processing" in pattern_ids
-
-    def _infer_module(self, workflow_id: str) -> str:
-        """Infer module path from workflow ID.
-
-        Args:
-            workflow_id: Workflow identifier
-
-        Returns:
-            Inferred module path
-
-        """
-        # Try to determine workflow location
-        # This is a simple heuristic - can be improved
-        if workflow_id in ["soap_note", "sbar", "care_plan"]:
-            return f"workflows.{workflow_id}"
-        else:
-            return f"workflows.{workflow_id}_workflow"
-
-    def _infer_class_name(self, workflow_id: str) -> str:
-        """Infer workflow class name from ID.
-
-        Args:
-            workflow_id: Workflow identifier
-
-        Returns:
-            Inferred class name
-
-        """
-        # Convert snake_case to PascalCase and add "Workflow"
-        parts = workflow_id.split("_")
-        class_name = "".join(part.capitalize() for part in parts)
-        return f"{class_name}Workflow"