empathy-framework 2.4.0__py3-none-any.whl → 3.8.2__py3-none-any.whl

empathy_os/pattern_library.py

@@ -1,5 +1,4 @@
-"""
-Pattern Library for Multi-Agent Collaboration
+"""Pattern Library for Multi-Agent Collaboration
 
 Enables AI agents to share discovered patterns with each other, accelerating
 learning across the agent collective (Level 5: Systems Empathy).
@@ -17,8 +16,7 @@ from typing import Any
 
 @dataclass
 class Pattern:
-    """
-    A discovered pattern that can be shared across AI agents
+    """A discovered pattern that can be shared across AI agents
 
     Patterns represent reusable solutions, common behaviors, or
     learned heuristics that one agent discovered and others can benefit from.
@@ -27,6 +25,7 @@ class Pattern:
     - Sequential patterns: "After action X, users typically need Y"
     - Temporal patterns: "On Mondays, prioritize Z"
     - Conditional patterns: "If context A, then approach B works best"
+
     """
 
     id: str
@@ -76,8 +75,7 @@ class PatternMatch:
 
 
 class PatternLibrary:
-    """
-    Shared library for multi-agent pattern discovery and sharing
+    """Shared library for multi-agent pattern discovery and sharing
 
     Enables Level 5 Systems Empathy: AI-AI cooperation where one agent's
     discovery benefits all agents in the collective.
@@ -112,6 +110,7 @@ class PatternLibrary:
         >>> context = {"recent_event": "system_update", "user_confusion": True}
         >>> matches = library.query_patterns("documentation_agent", context)
         >>> print(f"Found {len(matches)} relevant patterns")
+
     """
 
     def __init__(self):
@@ -121,8 +120,7 @@ class PatternLibrary:
         self.pattern_graph: dict[str, list[str]] = {}  # pattern_id -> related_pattern_ids
 
     def contribute_pattern(self, agent_id: str, pattern: Pattern) -> None:
-        """
-        Agent contributes a discovered pattern to the library
+        """Agent contributes a discovered pattern to the library
 
         Args:
             agent_id: ID of contributing agent
@@ -134,10 +132,11 @@ class PatternLibrary:
             ...     agent_id="agent_1",
             ...     pattern_type="conditional",
             ...     name="High-stakes decision pattern",
-            ...     description="For high-stakes decisions, provide multiple options with tradeoffs",
+            ...     description="For high-stakes decisions, provide options with tradeoffs",
             ...     confidence=0.9
             ... )
             >>> library.contribute_pattern("agent_1", pattern)
+
         """
         # Store pattern
         self.patterns[pattern.id] = pattern
@@ -159,8 +158,7 @@ class PatternLibrary:
         min_confidence: float = 0.5,
         limit: int = 10,
     ) -> list[PatternMatch]:
-        """
-        Query relevant patterns for current context
+        """Query relevant patterns for current context
 
         Args:
             agent_id: ID of querying agent
@@ -179,6 +177,7 @@ class PatternLibrary:
             ...     "time_of_day": "morning"
             ... }
             >>> matches = library.query_patterns("debug_agent", context, min_confidence=0.7)
+
         """
         matches: list[PatternMatch] = []
 
@@ -199,7 +198,7 @@ class PatternLibrary:
                         pattern=pattern,
                         relevance_score=relevance_score,
                         matching_factors=matching_factors,
-                    )
+                    ),
                 )
 
         # Sort by relevance and limit
@@ -207,40 +206,40 @@ class PatternLibrary:
         return matches[:limit]
 
     def get_pattern(self, pattern_id: str) -> Pattern | None:
-        """
-        Get a specific pattern by ID
+        """Get a specific pattern by ID
 
         Args:
             pattern_id: Pattern identifier
 
         Returns:
             Pattern if found, None otherwise
+
         """
         return self.patterns.get(pattern_id)
 
     def record_pattern_outcome(self, pattern_id: str, success: bool):
-        """
-        Record outcome of using a pattern
+        """Record outcome of using a pattern
 
         Updates pattern statistics to improve future recommendations.
 
         Args:
             pattern_id: ID of pattern that was used
             success: Whether using the pattern was successful
+
         """
         pattern = self.patterns.get(pattern_id)
         if pattern:
             pattern.record_usage(success)
 
     def link_patterns(self, pattern_id_1: str, pattern_id_2: str):
-        """
-        Create a link between related patterns
+        """Create a link between related patterns
 
         Helps agents discover complementary patterns.
 
         Args:
             pattern_id_1: First pattern ID
             pattern_id_2: Second pattern ID
+
         """
         if pattern_id_1 in self.pattern_graph:
             if pattern_id_2 not in self.pattern_graph[pattern_id_1]:
@@ -251,8 +250,7 @@ class PatternLibrary:
                 self.pattern_graph[pattern_id_2].append(pattern_id_1)
 
     def get_related_patterns(self, pattern_id: str, depth: int = 1) -> list[Pattern]:
-        """
-        Get patterns related to a given pattern
+        """Get patterns related to a given pattern
 
         Args:
             pattern_id: Source pattern ID
@@ -260,6 +258,7 @@ class PatternLibrary:
 
         Returns:
             List of related patterns
+
         """
         if depth <= 0 or pattern_id not in self.pattern_graph:
             return []
@@ -278,21 +277,20 @@ class PatternLibrary:
         return [self.patterns[pid] for pid in related_ids if pid in self.patterns]
 
     def get_agent_patterns(self, agent_id: str) -> list[Pattern]:
-        """
-        Get all patterns contributed by a specific agent
+        """Get all patterns contributed by a specific agent
 
         Args:
             agent_id: Agent identifier
 
         Returns:
             List of patterns from this agent
+
         """
         pattern_ids = self.agent_contributions.get(agent_id, [])
         return [self.patterns[pid] for pid in pattern_ids if pid in self.patterns]
 
     def get_top_patterns(self, n: int = 10, sort_by: str = "success_rate") -> list[Pattern]:
-        """
-        Get top N patterns by specified metric
+        """Get top N patterns by specified metric
 
         Args:
             n: Number of patterns to return
@@ -300,6 +298,7 @@ class PatternLibrary:
 
         Returns:
             Top N patterns
+
         """
         patterns = list(self.patterns.values())
 
@@ -313,11 +312,11 @@ class PatternLibrary:
         return patterns[:n]
 
     def get_library_stats(self) -> dict[str, Any]:
-        """
-        Get statistics about the pattern library
+        """Get statistics about the pattern library
 
         Returns:
             Dict with library statistics
+
         """
         if not self.patterns:
             return {
@@ -350,13 +349,15 @@ class PatternLibrary:
         }
 
     def _calculate_relevance(
-        self, pattern: Pattern, context: dict[str, Any]
+        self,
+        pattern: Pattern,
+        context: dict[str, Any],
     ) -> tuple[float, list[str]]:
-        """
-        Calculate how relevant a pattern is to current context
+        """Calculate how relevant a pattern is to current context
 
         Returns:
             (relevance_score, matching_factors)
+
         """
         relevance = 0.0
         matching_factors = []

empathy_os/persistence.py

@@ -1,5 +1,4 @@
-"""
-Persistence Layer for Empathy Framework
+"""Persistence Layer for Empathy Framework
 
 Provides:
 - Pattern library save/load (JSON, SQLite)
@@ -14,14 +13,14 @@ import json
 import sqlite3
 from datetime import datetime
 from pathlib import Path
+from typing import Any
 
 from .core import CollaborationState
 from .pattern_library import Pattern, PatternLibrary
 
 
 class PatternPersistence:
-    """
-    Save and load PatternLibrary to/from files
+    """Save and load PatternLibrary to/from files
 
     Supports:
     - JSON format (human-readable, good for backups)
@@ -30,8 +29,7 @@ class PatternPersistence:
 
     @staticmethod
     def save_to_json(library: PatternLibrary, filepath: str):
-        """
-        Save pattern library to JSON file
+        """Save pattern library to JSON file
 
         Args:
             library: PatternLibrary instance to save
@@ -40,9 +38,11 @@ class PatternPersistence:
         Example:
             >>> library = PatternLibrary()
             >>> PatternPersistence.save_to_json(library, "patterns.json")
+
         """
-        data = {
-            "patterns": [],
+        patterns_list: list[dict[str, Any]] = []
+        data: dict[str, Any] = {
+            "patterns": patterns_list,
             "agent_contributions": library.agent_contributions,
             "metadata": {
                 "saved_at": datetime.now().isoformat(),
@@ -53,7 +53,7 @@ class PatternPersistence:
 
         # Serialize each pattern
         for _pattern_id, pattern in library.patterns.items():
-            data["patterns"].append(
+            patterns_list.append(
                 {
                     "id": pattern.id,
                     "agent_id": pattern.agent_id,
@@ -69,7 +69,7 @@ class PatternPersistence:
                     "tags": pattern.tags,
                     "discovered_at": pattern.discovered_at.isoformat(),
                     "last_used": pattern.last_used.isoformat() if pattern.last_used else None,
-                }
+                },
             )
 
         # Write to file
@@ -78,8 +78,7 @@ class PatternPersistence:
 
     @staticmethod
     def load_from_json(filepath: str) -> PatternLibrary:
-        """
-        Load pattern library from JSON file
+        """Load pattern library from JSON file
 
         Args:
             filepath: Path to JSON file
@@ -93,6 +92,7 @@ class PatternPersistence:
 
         Example:
             >>> library = PatternPersistence.load_from_json("patterns.json")
+
         """
         with open(filepath) as f:
             data = json.load(f)
@@ -130,8 +130,7 @@ class PatternPersistence:
 
     @staticmethod
     def save_to_sqlite(library: PatternLibrary, db_path: str):
-        """
-        Save pattern library to SQLite database
+        """Save pattern library to SQLite database
 
         Args:
             library: PatternLibrary instance to save
@@ -144,6 +143,7 @@ class PatternPersistence:
         Example:
             >>> library = PatternLibrary()
             >>> PatternPersistence.save_to_sqlite(library, "patterns.db")
+
         """
         conn = sqlite3.connect(db_path)
         cursor = conn.cursor()
@@ -168,7 +168,7 @@ class PatternPersistence:
                 last_used TIMESTAMP,
                 updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
             )
-        """
+        """,
         )
 
         cursor.execute(
@@ -181,7 +181,7 @@ class PatternPersistence:
                 used_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                 FOREIGN KEY (pattern_id) REFERENCES patterns(id)
             )
-        """
+        """,
         )
 
         # Insert or update patterns
@@ -217,8 +217,7 @@ class PatternPersistence:
 
     @staticmethod
     def load_from_sqlite(db_path: str) -> PatternLibrary:
-        """
-        Load pattern library from SQLite database
+        """Load pattern library from SQLite database
 
         Args:
             db_path: Path to SQLite database file
@@ -228,6 +227,7 @@ class PatternPersistence:
 
         Example:
             >>> library = PatternPersistence.load_from_sqlite("patterns.db")
+
         """
         conn = sqlite3.connect(db_path)
         conn.row_factory = sqlite3.Row  # Access columns by name
@@ -263,8 +263,7 @@ class PatternPersistence:
 
 
 class StateManager:
-    """
-    Persist collaboration state across sessions
+    """Persist collaboration state across sessions
 
     Enables:
     - Long-term trust tracking
@@ -277,8 +276,7 @@ class StateManager:
         self.storage_path.mkdir(exist_ok=True, parents=True)
 
     def save_state(self, user_id: str, state: CollaborationState):
-        """
-        Save user's collaboration state to JSON
+        """Save user's collaboration state to JSON
 
         Args:
             user_id: User identifier
@@ -287,6 +285,7 @@ class StateManager:
         Example:
             >>> manager = StateManager()
             >>> manager.save_state("user123", empathy.collaboration_state)
+
         """
         filepath = self.storage_path / f"{user_id}.json"
 
@@ -306,8 +305,7 @@ class StateManager:
             json.dump(data, f, indent=2)
 
     def load_state(self, user_id: str) -> CollaborationState | None:
-        """
-        Load user's previous state
+        """Load user's previous state
 
         Args:
             user_id: User identifier
@@ -321,6 +319,7 @@ class StateManager:
             >>> if state:
             ...     empathy = EmpathyOS(user_id="user123", target_level=4)
             ...     empathy.collaboration_state = state
+
         """
         filepath = self.storage_path / f"{user_id}.json"
 
@@ -347,8 +346,7 @@ class StateManager:
             return None
 
     def list_users(self) -> list[str]:
-        """
-        List all users with saved state
+        """List all users with saved state
 
         Returns:
             List of user IDs
@@ -357,12 +355,12 @@ class StateManager:
             >>> manager = StateManager()
             >>> users = manager.list_users()
             >>> print(f"Found {len(users)} users")
+
         """
         return [p.stem for p in self.storage_path.glob("*.json")]
 
     def delete_state(self, user_id: str) -> bool:
-        """
-        Delete user's saved state
+        """Delete user's saved state
 
         Args:
             user_id: User identifier
@@ -373,6 +371,7 @@ class StateManager:
         Example:
             >>> manager = StateManager()
             >>> deleted = manager.delete_state("user123")
+
         """
         filepath = self.storage_path / f"{user_id}.json"
 
@@ -383,8 +382,7 @@ class StateManager:
 
 
 class MetricsCollector:
-    """
-    Collect and persist empathy framework metrics
+    """Collect and persist empathy framework metrics
 
     Tracks:
     - Empathy level usage
@@ -413,21 +411,21 @@ class MetricsCollector:
                 timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                 metadata TEXT
             )
-        """
+        """,
         )
 
         cursor.execute(
             """
             CREATE INDEX IF NOT EXISTS idx_user_level
             ON metrics(user_id, empathy_level)
-        """
+        """,
         )
 
         cursor.execute(
             """
             CREATE INDEX IF NOT EXISTS idx_timestamp
             ON metrics(timestamp)
-        """
+        """,
         )
 
         conn.commit()
@@ -441,8 +439,7 @@ class MetricsCollector:
         response_time_ms: float,
         metadata: dict | None = None,
     ):
-        """
-        Record a single metric event
+        """Record a single metric event
 
         Args:
             user_id: User identifier
@@ -460,6 +457,7 @@ class MetricsCollector:
             ...     response_time_ms=250.5,
             ...     metadata={"bottlenecks_predicted": 3}
             ... )
+
         """
         conn = sqlite3.connect(self.db_path)
         cursor = conn.cursor()
@@ -483,8 +481,7 @@ class MetricsCollector:
         conn.close()
 
     def get_user_stats(self, user_id: str) -> dict:
-        """
-        Get aggregated statistics for a user
+        """Get aggregated statistics for a user
 
         Args:
             user_id: User identifier
@@ -496,6 +493,7 @@ class MetricsCollector:
             >>> collector = MetricsCollector()
             >>> stats = collector.get_user_stats("user123")
             >>> print(f"Success rate: {stats['success_rate']:.1%}")
+
         """
         conn = sqlite3.connect(self.db_path)
         conn.row_factory = sqlite3.Row