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

empathy_os/socratic/storage.py

@@ -179,13 +179,15 @@ class JSONFileStorage(StorageBackend):
                 if state and data.get("state") != state.value:
                     continue
 
-                sessions.append({
-                    "session_id": data.get("session_id"),
-                    "state": data.get("state"),
-                    "goal": data.get("goal", "")[:100],
-                    "created_at": data.get("created_at"),
-                    "updated_at": data.get("updated_at"),
-                })
+                sessions.append(
+                    {
+                        "session_id": data.get("session_id"),
+                        "state": data.get("state"),
+                        "goal": data.get("goal", "")[:100],
+                        "created_at": data.get("created_at"),
+                        "updated_at": data.get("updated_at"),
+                    }
+                )
             except (json.JSONDecodeError, KeyError):
                 continue
 
@@ -245,13 +247,15 @@ class JSONFileStorage(StorageBackend):
                 if domain and data.get("domain") != domain:
                     continue
 
-                blueprints.append({
-                    "id": data.get("id"),
-                    "name": data.get("name"),
-                    "domain": data.get("domain"),
-                    "agents_count": len(data.get("agents", [])),
-                    "generated_at": data.get("generated_at"),
-                })
+                blueprints.append(
+                    {
+                        "id": data.get("id"),
+                        "name": data.get("name"),
+                        "domain": data.get("domain"),
+                        "agents_count": len(data.get("agents", [])),
+                        "generated_at": data.get("generated_at"),
+                    }
+                )
             except (json.JSONDecodeError, KeyError):
                 continue
 
@@ -329,7 +333,8 @@ class SQLiteStorage(StorageBackend):
     def _init_database(self) -> None:
         """Initialize database schema."""
         with self._get_connection() as conn:
-            conn.executescript("""
+            conn.executescript(
+                """
                 CREATE TABLE IF NOT EXISTS sessions (
                     session_id TEXT PRIMARY KEY,
                     state TEXT NOT NULL,
@@ -370,7 +375,8 @@ class SQLiteStorage(StorageBackend):
                 );
 
                 CREATE INDEX IF NOT EXISTS idx_evaluations_blueprint ON evaluations(blueprint_id);
-            """)
+            """
+            )
 
     def save_session(self, session: SocraticSession) -> None:
         """Save session to database."""
@@ -379,27 +385,29 @@ class SQLiteStorage(StorageBackend):
         confidence = session.goal_analysis.confidence if session.goal_analysis else None
 
         with self._get_connection() as conn:
-            conn.execute("""
+            conn.execute(
+                """
                 INSERT OR REPLACE INTO sessions
                 (session_id, state, goal, domain, confidence, created_at, updated_at, data)
                 VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-            """, (
-                session.session_id,
-                session.state.value,
-                session.goal,
-                domain,
-                confidence,
-                session.created_at.isoformat(),
-                session.updated_at.isoformat(),
-                json.dumps(data, default=str),
-            ))
+            """,
+                (
+                    session.session_id,
+                    session.state.value,
+                    session.goal,
+                    domain,
+                    confidence,
+                    session.created_at.isoformat(),
+                    session.updated_at.isoformat(),
+                    json.dumps(data, default=str),
+                ),
+            )
 
     def load_session(self, session_id: str) -> SocraticSession | None:
         """Load session from database."""
         with self._get_connection() as conn:
             row = conn.execute(
-                "SELECT data FROM sessions WHERE session_id = ?",
-                (session_id,)
+                "SELECT data FROM sessions WHERE session_id = ?", (session_id,)
             ).fetchone()
 
             if row:
@@ -415,30 +423,33 @@ class SQLiteStorage(StorageBackend):
         """List sessions from database."""
         with self._get_connection() as conn:
             if state:
-                rows = conn.execute("""
+                rows = conn.execute(
+                    """
                     SELECT session_id, state, goal, domain, confidence, created_at, updated_at
                     FROM sessions
                     WHERE state = ?
                     ORDER BY updated_at DESC
                     LIMIT ?
-                """, (state.value, limit)).fetchall()
+                """,
+                    (state.value, limit),
+                ).fetchall()
             else:
-                rows = conn.execute("""
+                rows = conn.execute(
+                    """
                     SELECT session_id, state, goal, domain, confidence, created_at, updated_at
                     FROM sessions
                     ORDER BY updated_at DESC
                     LIMIT ?
-                """, (limit,)).fetchall()
+                """,
+                    (limit,),
+                ).fetchall()
 
             return [dict(row) for row in rows]
 
     def delete_session(self, session_id: str) -> bool:
         """Delete session from database."""
         with self._get_connection() as conn:
-            cursor = conn.execute(
-                "DELETE FROM sessions WHERE session_id = ?",
-                (session_id,)
-            )
+            cursor = conn.execute("DELETE FROM sessions WHERE session_id = ?", (session_id,))
             return cursor.rowcount > 0
 
     def save_blueprint(self, blueprint: WorkflowBlueprint) -> None:
@@ -446,26 +457,28 @@ class SQLiteStorage(StorageBackend):
         data = blueprint.to_dict()
 
         with self._get_connection() as conn:
-            conn.execute("""
+            conn.execute(
+                """
                 INSERT OR REPLACE INTO blueprints
                 (blueprint_id, name, domain, agents_count, generated_at, source_session_id, data)
                 VALUES (?, ?, ?, ?, ?, ?, ?)
-            """, (
-                blueprint.id,
-                blueprint.name,
-                blueprint.domain,
-                len(blueprint.agents),
-                blueprint.generated_at,
-                blueprint.source_session_id,
-                json.dumps(data, default=str),
-            ))
+            """,
+                (
+                    blueprint.id,
+                    blueprint.name,
+                    blueprint.domain,
+                    len(blueprint.agents),
+                    blueprint.generated_at,
+                    blueprint.source_session_id,
+                    json.dumps(data, default=str),
+                ),
+            )
 
     def load_blueprint(self, blueprint_id: str) -> WorkflowBlueprint | None:
         """Load blueprint from database."""
         with self._get_connection() as conn:
             row = conn.execute(
-                "SELECT data FROM blueprints WHERE blueprint_id = ?",
-                (blueprint_id,)
+                "SELECT data FROM blueprints WHERE blueprint_id = ?", (blueprint_id,)
             ).fetchone()
 
             if row:
@@ -481,20 +494,26 @@ class SQLiteStorage(StorageBackend):
         """List blueprints from database."""
         with self._get_connection() as conn:
             if domain:
-                rows = conn.execute("""
+                rows = conn.execute(
+                    """
                     SELECT blueprint_id as id, name, domain, agents_count, generated_at
                     FROM blueprints
                     WHERE domain = ?
                     ORDER BY generated_at DESC
                     LIMIT ?
-                """, (domain, limit)).fetchall()
+                """,
+                    (domain, limit),
+                ).fetchall()
             else:
-                rows = conn.execute("""
+                rows = conn.execute(
+                    """
                     SELECT blueprint_id as id, name, domain, agents_count, generated_at
                     FROM blueprints
                     ORDER BY generated_at DESC
                     LIMIT ?
-                """, (limit,)).fetchall()
+                """,
+                    (limit,),
+                ).fetchall()
 
             return [dict(row) for row in rows]
 
@@ -507,17 +526,20 @@ class SQLiteStorage(StorageBackend):
         data = evaluation.to_dict()
 
         with self._get_connection() as conn:
-            conn.execute("""
+            conn.execute(
+                """
                 INSERT INTO evaluations
                 (blueprint_id, overall_success, overall_score, evaluated_at, data)
                 VALUES (?, ?, ?, ?, ?)
-            """, (
-                blueprint_id,
-                1 if evaluation.overall_success else 0,
-                evaluation.overall_score,
-                evaluation.evaluated_at,
-                json.dumps(data, default=str),
-            ))
+            """,
+                (
+                    blueprint_id,
+                    1 if evaluation.overall_success else 0,
+                    evaluation.overall_score,
+                    evaluation.evaluated_at,
+                    json.dumps(data, default=str),
+                ),
+            )
 
     def get_evaluations(
         self,
@@ -526,25 +548,31 @@ class SQLiteStorage(StorageBackend):
     ) -> list[dict[str, Any]]:
         """Get evaluations from database."""
         with self._get_connection() as conn:
-            rows = conn.execute("""
+            rows = conn.execute(
+                """
                 SELECT data FROM evaluations
                 WHERE blueprint_id = ?
                 ORDER BY evaluated_at DESC
                 LIMIT ?
-            """, (blueprint_id, limit)).fetchall()
+            """,
+                (blueprint_id, limit),
+            ).fetchall()
 
             return [json.loads(row["data"]) for row in rows]
 
     def get_success_rate(self, blueprint_id: str) -> float:
         """Get overall success rate for a blueprint."""
         with self._get_connection() as conn:
-            row = conn.execute("""
+            row = conn.execute(
+                """
                 SELECT
                     COUNT(*) as total,
                     SUM(overall_success) as successes
                 FROM evaluations
                 WHERE blueprint_id = ?
-            """, (blueprint_id,)).fetchone()
+            """,
+                (blueprint_id,),
+            ).fetchone()
 
             if row and row["total"] > 0:
                 return row["successes"] / row["total"]
@@ -557,13 +585,16 @@ class SQLiteStorage(StorageBackend):
     ) -> list[dict[str, Any]]:
         """Search blueprints by name or domain."""
         with self._get_connection() as conn:
-            rows = conn.execute("""
+            rows = conn.execute(
+                """
                 SELECT blueprint_id as id, name, domain, agents_count, generated_at
                 FROM blueprints
                 WHERE name LIKE ? OR domain LIKE ?
                 ORDER BY generated_at DESC
                 LIMIT ?
-            """, (f"%{query}%", f"%{query}%", limit)).fetchall()
+            """,
+                (f"%{query}%", f"%{query}%", limit),
+            ).fetchall()
 
             return [dict(row) for row in rows]
 

empathy_os/socratic/success.py

@@ -147,7 +147,9 @@ class SuccessMetric:
             if self.maximum_value is not None:
                 met = value <= self.maximum_value
                 # Score is inverse ratio (lower is better)
-                score = max(1.0 - (value / self.maximum_value), 0.0) if self.maximum_value > 0 else 1.0
+                score = (
+                    max(1.0 - (value / self.maximum_value), 0.0) if self.maximum_value > 0 else 1.0
+                )
             else:
                 met = True
                 score = 1.0
@@ -204,7 +206,11 @@ class SuccessMetric:
             parts.append(f"Measured: {value}")
 
         # Comparison to baseline
-        if baseline is not None and isinstance(value, (int, float)) and isinstance(baseline, (int, float)):
+        if (
+            baseline is not None
+            and isinstance(value, (int, float))
+            and isinstance(baseline, (int, float))
+        ):
             diff = value - baseline
             pct_change = (diff / baseline * 100) if baseline != 0 else 0
             direction = "↑" if diff > 0 else "↓" if diff < 0 else "→"
@@ -336,14 +342,16 @@ class SuccessCriteria:
 
             if value is None:
                 # Metric not found in output
-                results.append(MetricResult(
-                    metric_id=metric.id,
-                    value=0,
-                    met_criteria=False,
-                    score=0.0,
-                    explanation=f"Metric '{metric.name}' not found in output",
-                    timestamp=timestamp,
-                ))
+                results.append(
+                    MetricResult(
+                        metric_id=metric.id,
+                        value=0,
+                        met_criteria=False,
+                        score=0.0,
+                        explanation=f"Metric '{metric.name}' not found in output",
+                        timestamp=timestamp,
+                    )
+                )
                 continue
 
             # Get baseline if available
@@ -352,15 +360,17 @@ class SuccessCriteria:
             # Evaluate
             met, score, explanation = metric.evaluate(value, baseline)
 
-            results.append(MetricResult(
-                metric_id=metric.id,
-                value=value,
-                met_criteria=met,
-                score=score,
-                explanation=explanation,
-                baseline=baseline,
-                timestamp=timestamp,
-            ))
+            results.append(
+                MetricResult(
+                    metric_id=metric.id,
+                    value=value,
+                    met_criteria=met,
+                    score=score,
+                    explanation=explanation,
+                    baseline=baseline,
+                    timestamp=timestamp,
+                )
+            )
 
         # Calculate overall success
         return self._calculate_overall_success(results)
@@ -419,8 +429,7 @@ class SuccessCriteria:
 
         # Check primary metrics
         primary_results = [
-            r for r in results
-            if any(m.id == r.metric_id and m.is_primary for m in self.metrics)
+            r for r in results if any(m.id == r.metric_id and m.is_primary for m in self.metrics)
         ]
         primary_passed = sum(1 for r in primary_results if r.met_criteria)
 
@@ -435,15 +444,17 @@ class SuccessCriteria:
         else:
             # Weighted average score
             total_weight = sum(
-                m.weight for m in self.metrics
-                if any(r.metric_id == m.id for r in results)
+                m.weight for m in self.metrics if any(r.metric_id == m.id for r in results)
             )
 
             if total_weight > 0:
-                weighted_score = sum(
-                    r.score * next((m.weight for m in self.metrics if m.id == r.metric_id), 1.0)
-                    for r in results
-                ) / total_weight
+                weighted_score = (
+                    sum(
+                        r.score * next((m.weight for m in self.metrics if m.id == r.metric_id), 1.0)
+                        for r in results
+                    )
+                    / total_weight
+                )
             else:
                 weighted_score = sum(r.score for r in results) / len(results)
 

empathy_os/socratic/visual_editor.py

@@ -63,7 +63,9 @@ class EditorNode:
 
     def to_dict(self) -> dict[str, Any]:
         # Handle both string and enum for node_type
-        node_type_str = self.node_type.value if isinstance(self.node_type, NodeType) else self.node_type
+        node_type_str = (
+            self.node_type.value if isinstance(self.node_type, NodeType) else self.node_type
+        )
         # Handle both dict and Position for position
         pos_dict = self.position.to_dict() if isinstance(self.position, Position) else self.position
         return {
@@ -193,20 +195,24 @@ class WorkflowVisualizer:
 
             # Connect from start or dependencies
             if first_stage:
-                edges.append(EditorEdge(
-                    edge_id=f"start->{stage.id}",
-                    source="start",
-                    target=stage.id,
-                    animated=True,
-                ))
+                edges.append(
+                    EditorEdge(
+                        edge_id=f"start->{stage.id}",
+                        source="start",
+                        target=stage.id,
+                        animated=True,
+                    )
+                )
                 first_stage = False
             else:
                 for dep in stage.depends_on:
-                    edges.append(EditorEdge(
-                        edge_id=f"{dep}->{stage.id}",
-                        source=dep,
-                        target=stage.id,
-                    ))
+                    edges.append(
+                        EditorEdge(
+                            edge_id=f"{dep}->{stage.id}",
+                            source=dep,
+                            target=stage.id,
+                        )
+                    )
 
             # Create agent nodes for this stage
             agent_x_start = 200
@@ -232,11 +238,13 @@ class WorkflowVisualizer:
                 nodes.append(agent_node)
 
                 # Connect stage to agent
-                edges.append(EditorEdge(
-                    edge_id=f"{stage.id}->{agent_id}",
-                    source=stage.id,
-                    target=agent_id,
-                ))
+                edges.append(
+                    EditorEdge(
+                        edge_id=f"{stage.id}->{agent_id}",
+                        source=stage.id,
+                        target=agent_id,
+                    )
+                )
 
             y_offset += self.stage_spacing
 
@@ -253,12 +261,14 @@ class WorkflowVisualizer:
         # Connect last stage to end
         if blueprint.stages:
             last_stage = blueprint.stages[-1]
-            edges.append(EditorEdge(
-                edge_id=f"{last_stage.id}->end",
-                source=last_stage.id,
-                target="end",
-                animated=True,
-            ))
+            edges.append(
+                EditorEdge(
+                    edge_id=f"{last_stage.id}->end",
+                    source=last_stage.id,
+                    target="end",
+                    animated=True,
+                )
+            )
 
         return EditorState(workflow_id=blueprint.id, nodes=nodes, edges=edges)
 
@@ -273,6 +283,7 @@ class WorkflowVisualizer:
         if original_blueprint is None:
             # Create minimal blueprint for reconstruction
             from .blueprint import WorkflowBlueprint
+
             original_blueprint = WorkflowBlueprint(
                 id=state.workflow_id,
                 name="Reconstructed Workflow",
@@ -320,21 +331,21 @@ class WorkflowVisualizer:
             dependencies = [
                 source
                 for source in edges_by_target.get(stage_node.node_id, [])
-                if source != "start" and any(
-                    s.node_id == source and s.node_type == NodeType.STAGE
-                    for s in stage_nodes
-                )
+                if source != "start"
+                and any(s.node_id == source and s.node_type == NodeType.STAGE for s in stage_nodes)
             ]
 
-            new_stages.append(StageSpec(
-                id=stage_node.node_id,
-                name=stage_node.label,
-                description=stage_node.data.get("description", f"Stage: {stage_node.label}"),
-                agent_ids=agent_ids,
-                depends_on=dependencies,
-                parallel=stage_node.data.get("parallel", False),
-                timeout=stage_node.data.get("timeout"),
-            ))
+            new_stages.append(
+                StageSpec(
+                    id=stage_node.node_id,
+                    name=stage_node.label,
+                    description=stage_node.data.get("description", f"Stage: {stage_node.label}"),
+                    agent_ids=agent_ids,
+                    depends_on=dependencies,
+                    parallel=stage_node.data.get("parallel", False),
+                    timeout=stage_node.data.get("timeout"),
+                )
+            )
 
         # Update blueprint
         return WorkflowBlueprint(
@@ -414,7 +425,7 @@ class ASCIIVisualizer:
             if stage.agent_ids:
                 agent_str = " → ".join(stage.agent_ids)
                 if len(agent_str) > self.width - 10:
-                    agent_str = agent_str[:self.width - 13] + "..."
+                    agent_str = agent_str[: self.width - 13] + "..."
                 lines.append(self._center(f"({agent_str})"))
 
             # Connector
@@ -636,8 +647,8 @@ def generate_editor_html(
         const {{ useState, useCallback }} = React;
         const {{ ReactFlow, Background, Controls, MiniMap }} = window.ReactFlow;
 
-        const initialNodes = {json.dumps(react_schema['nodes'], indent=2)};
-        const initialEdges = {json.dumps(react_schema['edges'], indent=2)};
+        const initialNodes = {json.dumps(react_schema["nodes"], indent=2)};
+        const initialEdges = {json.dumps(react_schema["edges"], indent=2)};
 
         function WorkflowEditor() {{
             const [nodes, setNodes] = useState(initialNodes);
@@ -826,6 +837,7 @@ class VisualWorkflowEditor:
         # Check for cycles (simple detection)
         # Note: A more robust implementation would use DFS
         visited: set[str] = set()
+
         def check_cycle(node_id: str, path: set[str]) -> bool:
             if node_id in path:
                 return True