empathy-framework 4.6.6__py3-none-any.whl → 4.7.1__py3-none-any.whl

empathy_os/socratic/feedback.py

@@ -64,7 +64,9 @@ class AgentPerformance:
             return "insufficient_data"
 
         recent_5 = [s for _, s in self.recent_scores[-5:]]
-        older_5 = [s for _, s in self.recent_scores[-10:-5]] if len(self.recent_scores) >= 10 else []
+        older_5 = (
+            [s for _, s in self.recent_scores[-10:-5]] if len(self.recent_scores) >= 10 else []
+        )
 
         if not older_5:
             return "stable"
@@ -343,12 +345,12 @@ class FeedbackCollector:
         if success:
             pattern.successes += 1
         # Rolling average
-        pattern.average_score = (
-            (pattern.average_score * (pattern.uses - 1) + score) / pattern.uses
-        )
+        pattern.average_score = (pattern.average_score * (pattern.uses - 1) + score) / pattern.uses
 
         self._save_data()
-        logger.info(f"Recorded feedback for blueprint {blueprint.id[:8]}: success={success}, score={score:.2f}")
+        logger.info(
+            f"Recorded feedback for blueprint {blueprint.id[:8]}: success={success}, score={score:.2f}"
+        )
 
     def _generate_pattern_id(self, blueprint: WorkflowBlueprint) -> str:
         """Generate a unique ID for a workflow pattern."""
@@ -444,8 +446,7 @@ class FeedbackCollector:
 
         # Top performing agents
         all_agents = [
-            (tid, perf) for tid, perf in self._agent_performance.items()
-            if perf.total_uses >= 5
+            (tid, perf) for tid, perf in self._agent_performance.items() if perf.total_uses >= 5
         ]
         all_agents.sort(key=lambda x: x[1].average_score, reverse=True)
         insights["top_performing_agents"] = [
@@ -456,11 +457,13 @@ class FeedbackCollector:
         # Declining agents
         for tid, perf in self._agent_performance.items():
             if perf.trend == "declining" and perf.total_uses >= 5:
-                insights["declining_agents"].append({
-                    "template_id": tid,
-                    "current_score": perf.average_score,
-                    "uses": perf.total_uses,
-                })
+                insights["declining_agents"].append(
+                    {
+                        "template_id": tid,
+                        "current_score": perf.average_score,
+                        "uses": perf.total_uses,
+                    }
+                )
 
         # Domain insights
         domains: dict[str, dict[str, Any]] = {}
@@ -602,7 +605,7 @@ class AdaptiveAgentGenerator:
                         customizations={
                             "languages": languages,
                             "quality_focus": quality_focus,
-                        }
+                        },
                     )
                     scored_base.append((new_agent, score))
                     logger.info(f"Added high-performing agent '{tid}' based on feedback")
@@ -649,8 +652,11 @@ class AdaptiveAgentGenerator:
                 {
                     "template_id": tid,
                     "score": score,
-                    "performance": self.feedback.get_agent_performance(tid).to_dict()
-                    if self.feedback.get_agent_performance(tid) else None,
+                    "performance": (
+                        self.feedback.get_agent_performance(tid).to_dict()
+                        if self.feedback.get_agent_performance(tid)
+                        else None
+                    ),
                 }
                 for tid, score in best_agents
             ],
@@ -659,10 +665,9 @@ class AdaptiveAgentGenerator:
                 "total_executions": sum(
                     p.total_uses for p in self.feedback.get_all_performance().values()
                 ),
-                "agents_with_data": len([
-                    p for p in self.feedback.get_all_performance().values()
-                    if p.total_uses >= 5
-                ]),
+                "agents_with_data": len(
+                    [p for p in self.feedback.get_all_performance().values() if p.total_uses >= 5]
+                ),
             },
         }
 

empathy_os/socratic/forms.py

@@ -200,6 +200,7 @@ class FormField:
         # Check pattern
         if v.pattern and isinstance(value, str):
             import re
+
             if not re.match(v.pattern, value):
                 return False, v.error_message
 
@@ -347,16 +348,20 @@ class Form:
                     "placeholder": f.placeholder,
                     "default": f.default,
                     "category": f.category,
-                    "options": [
-                        {
-                            "value": o.value,
-                            "label": o.label,
-                            "description": o.description,
-                            "icon": o.icon,
-                            "recommended": o.recommended,
-                        }
-                        for o in f.options
-                    ] if f.options else [],
+                    "options": (
+                        [
+                            {
+                                "value": o.value,
+                                "label": o.label,
+                                "description": o.description,
+                                "icon": o.icon,
+                                "recommended": o.recommended,
+                            }
+                            for o in f.options
+                        ]
+                        if f.options
+                        else []
+                    ),
                     "validation": {
                         "required": f.validation.required,
                         "min_length": f.validation.min_length,

empathy_os/socratic/generator.py

@@ -506,14 +506,16 @@ class AgentGenerator:
         # Build stage configuration
         stages_config = []
         for stage in blueprint.stages:
-            stages_config.append({
-                "id": stage.id,
-                "name": stage.name,
-                "agents": stage.agent_ids,
-                "parallel": stage.parallel,
-                "depends_on": stage.depends_on,
-                "timeout": stage.timeout,
-            })
+            stages_config.append(
+                {
+                    "id": stage.id,
+                    "name": stage.name,
+                    "agents": stage.agent_ids,
+                    "parallel": stage.parallel,
+                    "depends_on": stage.depends_on,
+                    "timeout": stage.timeout,
+                }
+            )
 
         return GeneratedWorkflow(
             blueprint=blueprint,
@@ -557,7 +559,11 @@ class AgentGenerator:
             Complete WorkflowBlueprint
         """
         # Group agents by role for staging
-        analyzers = [a for a in agents if a.spec.role in (AgentRole.ANALYZER, AgentRole.REVIEWER, AgentRole.AUDITOR)]
+        analyzers = [
+            a
+            for a in agents
+            if a.spec.role in (AgentRole.ANALYZER, AgentRole.REVIEWER, AgentRole.AUDITOR)
+        ]
         generators = [a for a in agents if a.spec.role == AgentRole.GENERATOR]
         reporters = [a for a in agents if a.spec.role == AgentRole.REPORTER]
 
@@ -565,25 +571,29 @@ class AgentGenerator:
 
         # Stage 1: Analysis (parallel)
         if analyzers:
-            stages.append(StageSpec(
-                id="analysis",
-                name="Analysis",
-                description="Analyze code and identify issues",
-                agent_ids=[a.spec.id for a in analyzers],
-                parallel=True,
-                output_aggregation="merge",
-            ))
+            stages.append(
+                StageSpec(
+                    id="analysis",
+                    name="Analysis",
+                    description="Analyze code and identify issues",
+                    agent_ids=[a.spec.id for a in analyzers],
+                    parallel=True,
+                    output_aggregation="merge",
+                )
+            )
 
         # Stage 2: Generation (sequential, depends on analysis)
         if generators:
-            stages.append(StageSpec(
-                id="generation",
-                name="Generation",
-                description="Generate fixes and improvements",
-                agent_ids=[a.spec.id for a in generators],
-                parallel=False,
-                depends_on=["analysis"] if analyzers else [],
-            ))
+            stages.append(
+                StageSpec(
+                    id="generation",
+                    name="Generation",
+                    description="Generate fixes and improvements",
+                    agent_ids=[a.spec.id for a in generators],
+                    parallel=False,
+                    depends_on=["analysis"] if analyzers else [],
+                )
+            )
 
         # Stage 3: Synthesis (always last)
         if reporters:
@@ -593,14 +603,16 @@ class AgentGenerator:
             if generators:
                 depends.append("generation")
 
-            stages.append(StageSpec(
-                id="synthesis",
-                name="Synthesis",
-                description="Synthesize findings into report",
-                agent_ids=[a.spec.id for a in reporters],
-                parallel=False,
-                depends_on=depends,
-            ))
+            stages.append(
+                StageSpec(
+                    id="synthesis",
+                    name="Synthesis",
+                    description="Synthesize findings into report",
+                    agent_ids=[a.spec.id for a in reporters],
+                    parallel=False,
+                    depends_on=depends,
+                )
+            )
 
         return WorkflowBlueprint(
             name=name,
@@ -667,8 +679,12 @@ class GeneratedWorkflow:
             for agent_id in agent_ids:
                 # Find agent
                 agent = next(
-                    (a for a in self.agents if hasattr(a, "role") and self._match_agent(a, agent_id)),
-                    None
+                    (
+                        a
+                        for a in self.agents
+                        if hasattr(a, "role") and self._match_agent(a, agent_id)
+                    ),
+                    None,
                 )
                 if agent:
                     # Execute agent (simplified)

empathy_os/socratic/llm_analyzer.py

@@ -15,13 +15,7 @@ import re
 from dataclasses import dataclass, field
 from typing import Any
 
-from .forms import (
-    FieldOption,
-    FieldType,
-    FieldValidation,
-    Form,
-    FormField,
-)
+from .forms import FieldOption, FieldType, FieldValidation, Form, FormField
 from .session import SocraticSession
 
 logger = logging.getLogger(__name__)
@@ -245,6 +239,7 @@ class LLMGoalAnalyzer:
             model_tier: Model tier (cheap, capable, premium)
         """
         import os
+
         self.api_key = api_key or os.environ.get("ANTHROPIC_API_KEY")
         self.provider = provider
         self.model_tier = model_tier
@@ -256,6 +251,7 @@ class LLMGoalAnalyzer:
         if self._client is None and self.api_key:
             try:
                 import anthropic
+
                 self._client = anthropic.Anthropic(api_key=self.api_key)
             except ImportError:
                 logger.warning("anthropic package not installed")
@@ -266,6 +262,7 @@ class LLMGoalAnalyzer:
         if self._executor is None:
             try:
                 from ..models.empathy_executor import EmpathyLLMExecutor
+
                 self._executor = EmpathyLLMExecutor(provider=self.provider)
             except ImportError:
                 logger.warning("EmpathyLLMExecutor not available, using mock")
@@ -310,7 +307,7 @@ class LLMGoalAnalyzer:
             prompt=prompt,
             system=system,
         )
-        return response.content if hasattr(response, 'content') else str(response)
+        return response.content if hasattr(response, "content") else str(response)
 
     async def analyze_goal(self, goal: str) -> LLMAnalysisResult:
         """Analyze a goal using LLM.
@@ -559,6 +556,7 @@ class MockLLMExecutor:
 
     async def run(self, **kwargs) -> Any:
         """Return mock response."""
+
         @dataclass
         class MockResponse:
             content: str = "{}"
@@ -604,21 +602,25 @@ def llm_questions_to_form(
             if isinstance(opt, str):
                 options.append(FieldOption(value=opt.lower().replace(" ", "_"), label=opt))
             elif isinstance(opt, dict):
-                options.append(FieldOption(
-                    value=opt.get("value", opt.get("label", "").lower().replace(" ", "_")),
-                    label=opt.get("label", ""),
-                    description=opt.get("description", ""),
-                ))
-
-        fields.append(FormField(
-            id=q_id,
-            field_type=field_type,
-            label=q.get("question", ""),
-            options=options,
-            validation=FieldValidation(required=q.get("required", False)),
-            category=q.get("category", "general"),
-            order=q.get("priority", 5),
-        ))
+                options.append(
+                    FieldOption(
+                        value=opt.get("value", opt.get("label", "").lower().replace(" ", "_")),
+                        label=opt.get("label", ""),
+                        description=opt.get("description", ""),
+                    )
+                )
+
+        fields.append(
+            FormField(
+                id=q_id,
+                field_type=field_type,
+                label=q.get("question", ""),
+                options=options,
+                validation=FieldValidation(required=q.get("required", False)),
+                category=q.get("category", "general"),
+                order=q.get("priority", 5),
+            )
+        )
 
     # Sort by priority (higher priority = lower order number = appears first)
     fields.sort(key=lambda f: f.order, reverse=True)