empathy-framework 3.5.6__py3-none-any.whl → 3.7.0__py3-none-any.whl

empathy_os/monitoring.py

@@ -1,5 +1,4 @@
-"""
-Agent Monitoring for Distributed Memory Networks
+"""Agent Monitoring for Distributed Memory Networks
 
 Provides monitoring and metrics collection for multi-agent systems.
 Tracks individual agent performance, pattern contributions, and
@@ -79,8 +78,7 @@ class TeamMetrics:
 
     @property
     def collaboration_efficiency(self) -> float:
-        """
-        Measure of how effectively agents collaborate.
+        """Measure of how effectively agents collaborate.
 
         Higher values indicate more cross-agent pattern reuse,
         meaning agents are learning from each other.
@@ -91,8 +89,7 @@ class TeamMetrics:
 
 
 class AgentMonitor:
-    """
-    Monitors and tracks metrics for multi-agent systems.
+    """Monitors and tracks metrics for multi-agent systems.
 
     Provides insights into:
     - Individual agent performance
@@ -116,14 +113,15 @@ class AgentMonitor:
         >>> # Get team stats
         >>> team = monitor.get_team_stats()
         >>> print(f"Collaboration efficiency: {team['collaboration_efficiency']:.0%}")
+
     """
 
     def __init__(self, pattern_library: PatternLibrary | None = None):
-        """
-        Initialize the AgentMonitor.
+        """Initialize the AgentMonitor.
 
         Args:
             pattern_library: Optional pattern library to track for shared patterns
+
         """
         self.agents: dict[str, AgentMetrics] = {}
         self.pattern_library = pattern_library
@@ -139,12 +137,12 @@ class AgentMonitor:
         agent_id: str,
         response_time_ms: float = 0.0,
     ):
-        """
-        Record an agent interaction.
+        """Record an agent interaction.
 
         Args:
             agent_id: ID of the agent
             response_time_ms: Response time in milliseconds
+
         """
         agent = self._get_or_create_agent(agent_id)
         agent.total_interactions += 1
@@ -160,12 +158,12 @@ class AgentMonitor:
             )
 
     def record_pattern_discovery(self, agent_id: str, pattern_id: str | None = None):
-        """
-        Record that an agent discovered a new pattern.
+        """Record that an agent discovered a new pattern.
 
         Args:
             agent_id: ID of the agent that discovered the pattern
             pattern_id: Optional pattern ID for tracking
+
         """
         agent = self._get_or_create_agent(agent_id)
         agent.patterns_discovered += 1
@@ -178,14 +176,14 @@ class AgentMonitor:
         pattern_agent: str | None = None,
         success: bool = True,
     ):
-        """
-        Record that an agent used a pattern.
+        """Record that an agent used a pattern.
 
         Args:
             agent_id: ID of the agent using the pattern
             pattern_id: ID of the pattern being used
             pattern_agent: ID of the agent that contributed the pattern
             success: Whether the pattern use was successful
+
         """
         agent = self._get_or_create_agent(agent_id)
         agent.patterns_used += 1
@@ -207,18 +205,18 @@ class AgentMonitor:
                 "cross_agent": is_cross_agent,
                 "success": success,
                 "timestamp": datetime.now(),
-            }
+            },
         )
 
     def get_agent_stats(self, agent_id: str) -> dict[str, Any]:
-        """
-        Get statistics for a specific agent.
+        """Get statistics for a specific agent.
 
         Args:
             agent_id: ID of the agent
 
         Returns:
             Dictionary with agent statistics
+
         """
         agent = self.agents.get(agent_id)
 
@@ -252,11 +250,11 @@ class AgentMonitor:
         }
 
     def get_team_stats(self) -> dict[str, Any]:
-        """
-        Get aggregated statistics for the entire agent team.
+        """Get aggregated statistics for the entire agent team.
 
         Returns:
             Dictionary with team-wide statistics
+
         """
         if not self.agents:
             # Get shared patterns count from library even if no agents
@@ -319,39 +317,41 @@ class AgentMonitor:
         }
 
     def get_top_contributors(self, n: int = 5) -> list[dict[str, Any]]:
-        """
-        Get the top pattern-contributing agents.
+        """Get the top pattern-contributing agents.
 
         Args:
             n: Number of agents to return
 
         Returns:
             List of agent stats, sorted by patterns discovered
+
         """
         sorted_agents = sorted(
-            self.agents.values(), key=lambda a: a.patterns_discovered, reverse=True
+            self.agents.values(),
+            key=lambda a: a.patterns_discovered,
+            reverse=True,
         )
 
         return [self.get_agent_stats(agent.agent_id) for agent in sorted_agents[:n]]
 
     def get_alerts(self, limit: int = 100) -> list[dict[str, Any]]:
-        """
-        Get recent alerts.
+        """Get recent alerts.
 
         Args:
             limit: Maximum number of alerts to return
 
         Returns:
             List of alert dictionaries
+
         """
         return self.alerts[-limit:]
 
     def check_health(self) -> dict[str, Any]:
-        """
-        Check overall system health.
+        """Check overall system health.
 
         Returns:
             Health status dictionary
+
         """
         team_stats = self.get_team_stats()
         recent_alerts = [
@@ -400,7 +400,7 @@ class AgentMonitor:
                 "message": message,
                 "severity": severity,
                 "timestamp": datetime.now(),
-            }
+            },
         )
 
         # Keep alerts bounded

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
@@ -138,6 +136,7 @@ class PatternLibrary:
             ...     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)
@@ -21,8 +20,7 @@ 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)
@@ -31,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
@@ -41,6 +38,7 @@ class PatternPersistence:
         Example:
             >>> library = PatternLibrary()
             >>> PatternPersistence.save_to_json(library, "patterns.json")
+
         """
         patterns_list: list[dict[str, Any]] = []
         data: dict[str, Any] = {
@@ -71,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
@@ -80,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
@@ -95,6 +92,7 @@ class PatternPersistence:
 
         Example:
             >>> library = PatternPersistence.load_from_json("patterns.json")
+
         """
         with open(filepath) as f:
             data = json.load(f)
@@ -132,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
@@ -146,6 +143,7 @@ class PatternPersistence:
         Example:
             >>> library = PatternLibrary()
             >>> PatternPersistence.save_to_sqlite(library, "patterns.db")
+
         """
         conn = sqlite3.connect(db_path)
         cursor = conn.cursor()
@@ -170,7 +168,7 @@ class PatternPersistence:
                 last_used TIMESTAMP,
                 updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
             )
-        """
+        """,
         )
 
         cursor.execute(
@@ -183,7 +181,7 @@ class PatternPersistence:
                 used_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                 FOREIGN KEY (pattern_id) REFERENCES patterns(id)
             )
-        """
+        """,
         )
 
         # Insert or update patterns
@@ -219,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
@@ -230,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
@@ -265,8 +263,7 @@ class PatternPersistence:
 
 
 class StateManager:
-    """
-    Persist collaboration state across sessions
+    """Persist collaboration state across sessions
 
     Enables:
     - Long-term trust tracking
@@ -279,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
@@ -289,6 +285,7 @@ class StateManager:
         Example:
             >>> manager = StateManager()
             >>> manager.save_state("user123", empathy.collaboration_state)
+
         """
         filepath = self.storage_path / f"{user_id}.json"
 
@@ -308,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
@@ -323,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"
 
@@ -349,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
@@ -359,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
@@ -375,6 +371,7 @@ class StateManager:
         Example:
             >>> manager = StateManager()
             >>> deleted = manager.delete_state("user123")
+
         """
         filepath = self.storage_path / f"{user_id}.json"
 
@@ -385,8 +382,7 @@ class StateManager:
 
 
 class MetricsCollector:
-    """
-    Collect and persist empathy framework metrics
+    """Collect and persist empathy framework metrics
 
     Tracks:
     - Empathy level usage
@@ -415,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()
@@ -443,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
@@ -462,6 +457,7 @@ class MetricsCollector:
             ...     response_time_ms=250.5,
             ...     metadata={"bottlenecks_predicted": 3}
             ... )
+
         """
         conn = sqlite3.connect(self.db_path)
         cursor = conn.cursor()
@@ -485,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
@@ -498,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