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

empathy_os/discovery.py

@@ -1,5 +1,4 @@
-"""
-Progressive Feature Discovery for Empathy Framework
+"""Progressive Feature Discovery for Empathy Framework
 
 Surface tips and suggestions at the right time based on usage patterns.
 Helps users discover power-user features without overwhelming them upfront.
@@ -87,8 +86,7 @@ def _days_since_sync(stats: dict) -> int:
 
 
 class DiscoveryEngine:
-    """
-    Tracks usage and surfaces contextual tips.
+    """Tracks usage and surfaces contextual tips.
 
     Usage:
         engine = DiscoveryEngine()
@@ -136,14 +134,14 @@ class DiscoveryEngine:
             json.dump(self.state, f, indent=2)
 
     def record_command(self, command: str) -> list:
-        """
-        Record a command execution and return any triggered tips.
+        """Record a command execution and return any triggered tips.
 
         Args:
             command: The command that was executed
 
         Returns:
             List of tip messages to show
+
         """
         # Update counts
         counts = self.state.get("command_counts", {})
@@ -177,8 +175,7 @@ class DiscoveryEngine:
         self._save()
 
     def get_pending_tips(self, trigger: str | None = None, max_tips: int = 2) -> list:
-        """
-        Get pending tips based on current state.
+        """Get pending tips based on current state.
 
         Args:
             trigger: Command that triggered this check (optional)
@@ -186,6 +183,7 @@ class DiscoveryEngine:
 
         Returns:
             List of tip messages
+
         """
         tips_to_show = []
         shown_tips = set(self.state.get("tips_shown", []))
@@ -207,7 +205,8 @@ class DiscoveryEngine:
             # Check condition-based tips
             elif "condition" in tip_config:
                 try:
-                    if tip_config["condition"](self.state):
+                    condition = tip_config["condition"]
+                    if callable(condition) and condition(self.state):
                         should_show = True
                 except Exception:
                     pass
@@ -218,11 +217,15 @@ class DiscoveryEngine:
                         "id": tip_id,
                         "tip": tip_config["tip"],
                         "priority": tip_config.get("priority", 3),
-                    }
+                    },
                 )
 
-        # Sort by priority and limit
-        tips_to_show.sort(key=lambda x: x["priority"])
+        # Sort by priority and limit - ensure we get an int for sorting
+        def get_priority(x: dict) -> int:
+            p = x.get("priority", 3)
+            return int(p) if isinstance(p, int | float | str) else 3
+
+        tips_to_show.sort(key=get_priority)
         return tips_to_show[:max_tips]
 
     def mark_shown(self, tip_id: str) -> None:
@@ -269,12 +272,12 @@ def get_engine(storage_dir: str = ".empathy") -> DiscoveryEngine:
 
 
 def show_tip_if_available(command: str, quiet: bool = False) -> None:
-    """
-    Check for tips after a command and display them.
+    """Check for tips after a command and display them.
 
     Args:
         command: The command that was just executed
         quiet: If True, don't print anything
+
     """
     engine = get_engine()
     tips = engine.record_command(command)

empathy_os/emergence.py

@@ -1,5 +1,4 @@
-"""
-Emergence Detection for AI-Human Collaboration
+"""Emergence Detection for AI-Human Collaboration
 
 Detects emergent properties in AI-human collaboration - system-level behaviors
 that arise from component interactions but aren't properties of components.
@@ -17,8 +16,7 @@ from typing import Any
 
 @dataclass
 class EmergentProperty:
-    """
-    An emergent property discovered in the system
+    """An emergent property discovered in the system
 
     Emergent properties are behaviors or patterns that arise from the
     interactions of system components but cannot be predicted from
@@ -34,8 +32,7 @@ class EmergentProperty:
 
 
 class EmergenceDetector:
-    """
-    Detects emergent properties in AI-human collaboration
+    """Detects emergent properties in AI-human collaboration
 
     Emergent properties are system-level behaviors that arise from
     component interactions but aren't properties of the components themselves.
@@ -57,6 +54,7 @@ class EmergenceDetector:
         >>> current = {"trust": 0.8, "interactions": 50, "shared_patterns": 5}
         >>> score = detector.measure_emergence(baseline, current)
         >>> print(f"Emergence score: {score:.2f}")
+
     """
 
     def __init__(self):
@@ -65,10 +63,10 @@ class EmergenceDetector:
         self.baseline_metrics: dict[str, Any] = {}
 
     def detect_emergent_norms(
-        self, team_interactions: list[dict[str, Any]]
+        self,
+        team_interactions: list[dict[str, Any]],
     ) -> list[EmergentProperty]:
-        """
-        Detect team norms that emerged organically
+        """Detect team norms that emerged organically
 
         Analyzes interaction history to identify behavioral patterns that:
         1. Were not explicitly programmed or prescribed
@@ -88,6 +86,7 @@ class EmergenceDetector:
             ...     {"type": "help_request", "response_time": 4}
             ... ]
             >>> norms = detector.detect_emergent_norms(interactions)
+
         """
         norms: list[EmergentProperty] = []
 
@@ -131,8 +130,7 @@ class EmergenceDetector:
         return norms
 
     def measure_emergence(self, baseline: dict[str, Any], current: dict[str, Any]) -> float:
-        """
-        Quantify emergence by comparing baseline to current state
+        """Quantify emergence by comparing baseline to current state
 
         Measures how much new system-level properties have emerged that
         weren't present in the baseline state.
@@ -151,6 +149,7 @@ class EmergenceDetector:
             >>> baseline = {"trust": 0.3, "interactions": 10}
             >>> current = {"trust": 0.8, "interactions": 50, "patterns": 5}
             >>> score = detector.measure_emergence(baseline, current)
+
         """
         emergence_score = 0.0
         max_score = 0.0
@@ -191,10 +190,10 @@ class EmergenceDetector:
         return 0.0
 
     def detect_emergent_capabilities(
-        self, historical_states: list[dict[str, Any]]
+        self,
+        historical_states: list[dict[str, Any]],
     ) -> list[EmergentProperty]:
-        """
-        Detect new capabilities that emerged over time
+        """Detect new capabilities that emerged over time
 
         Analyzes historical system states to identify capabilities that:
         1. Weren't present initially
@@ -206,6 +205,7 @@ class EmergenceDetector:
 
         Returns:
             List of emergent capabilities detected
+
         """
         if len(historical_states) < 2:
             return []
@@ -231,8 +231,7 @@ class EmergenceDetector:
         return capabilities
 
     def _calculate_consistency(self, values: list[float]) -> float:
-        """
-        Calculate consistency of a set of values (0.0-1.0)
+        """Calculate consistency of a set of values (0.0-1.0)
 
         Uses coefficient of variation: lower variation = higher consistency
         """
@@ -248,14 +247,14 @@ class EmergenceDetector:
         cv = std_dev / mean  # Coefficient of variation
 
         # Convert to consistency score (inverse of variation)
-        consistency = max(0.0, 1.0 - min(cv, 1.0))
+        consistency: float = max(0.0, 1.0 - min(cv, 1.0))
         return consistency
 
     def _analyze_communication_patterns(
-        self, interactions: list[dict[str, Any]]
+        self,
+        interactions: list[dict[str, Any]],
     ) -> dict[str, dict[str, Any]]:
-        """
-        Analyze communication patterns in interactions
+        """Analyze communication patterns in interactions
 
         Returns dict of pattern_name -> {frequency, examples}
         """
@@ -288,14 +287,14 @@ class EmergenceDetector:
         return patterns
 
     def get_detected_properties(self, property_type: str | None = None) -> list[EmergentProperty]:
-        """
-        Get all detected emergent properties, optionally filtered by type
+        """Get all detected emergent properties, optionally filtered by type
 
         Args:
             property_type: Optional filter ("norm", "pattern", "behavior", "capability")
 
         Returns:
             List of emergent properties
+
         """
         if property_type:
             return [p for p in self.detected_properties if p.property_type == property_type]

empathy_os/exceptions.py

@@ -1,5 +1,4 @@
-"""
-Custom exceptions for the Empathy Framework
+"""Custom exceptions for the Empathy Framework
 
 Provides domain-specific exceptions for better error handling and debugging.
 
@@ -9,36 +8,31 @@ Licensed under Fair Source 0.9
 
 
 class EmpathyFrameworkError(Exception):
-    """
-    Base exception for all Empathy Framework errors
+    """Base exception for all Empathy Framework errors
 
     All custom exceptions in the framework inherit from this class,
     making it easy to catch any framework-specific error.
     """
 
-    pass
-
 
 class ValidationError(EmpathyFrameworkError):
-    """
-    Raised when input validation fails
+    """Raised when input validation fails
 
     Examples:
         - Empty strings when non-empty required
         - Wrong type provided
         - Invalid value ranges
-    """
 
-    pass
+    """
 
 
 class PatternNotFoundError(EmpathyFrameworkError):
-    """
-    Raised when a pattern lookup fails
+    """Raised when a pattern lookup fails
 
     Examples:
         - Pattern ID doesn't exist in library
         - No patterns match query criteria
+
     """
 
     def __init__(self, pattern_id: str, message: str | None = None):
@@ -49,12 +43,12 @@ class PatternNotFoundError(EmpathyFrameworkError):
 
 
 class TrustThresholdError(EmpathyFrameworkError):
-    """
-    Raised when trust level is insufficient for an operation
+    """Raised when trust level is insufficient for an operation
 
     Examples:
         - Trust too low for proactive actions
         - Erosion loop detected
+
     """
 
     def __init__(self, current_trust: float, required_trust: float, message: str | None = None):
@@ -66,12 +60,12 @@ class TrustThresholdError(EmpathyFrameworkError):
 
 
 class ConfidenceThresholdError(EmpathyFrameworkError):
-    """
-    Raised when confidence is too low for proactive action
+    """Raised when confidence is too low for proactive action
 
     Examples:
         - Pattern confidence below threshold
         - Prediction uncertainty too high
+
     """
 
     def __init__(self, confidence: float, threshold: float, message: str | None = None):
@@ -83,13 +77,13 @@ class ConfidenceThresholdError(EmpathyFrameworkError):
 
 
 class EmpathyLevelError(EmpathyFrameworkError):
-    """
-    Raised when empathy level operations fail
+    """Raised when empathy level operations fail
 
     Examples:
         - Invalid level number
         - Level not yet achieved
         - Cannot regress to lower level
+
     """
 
     def __init__(self, level: int, message: str | None = None):
@@ -100,36 +94,30 @@ class EmpathyLevelError(EmpathyFrameworkError):
 
 
 class LeveragePointError(EmpathyFrameworkError):
-    """
-    Raised when leverage point analysis fails
+    """Raised when leverage point analysis fails
 
     Examples:
         - No leverage points found
         - Intervention feasibility too low
-    """
 
-    pass
+    """
 
 
 class FeedbackLoopError(EmpathyFrameworkError):
-    """
-    Raised when feedback loop detection or management fails
+    """Raised when feedback loop detection or management fails
 
     Examples:
         - Vicious cycle detected but cannot break
         - Insufficient history for loop detection
-    """
 
-    pass
+    """
 
 
 class CollaborationStateError(EmpathyFrameworkError):
-    """
-    Raised when collaboration state operations fail
+    """Raised when collaboration state operations fail
 
     Examples:
         - Invalid state transition
         - State corruption detected
-    """
 
-    pass
+    """

empathy_os/feedback_loops.py

@@ -1,5 +1,4 @@
-"""
-Feedback Loop Detection for AI-Human Collaboration
+"""Feedback Loop Detection for AI-Human Collaboration
 
 Detects and analyzes reinforcing and balancing feedback loops in AI-human
 collaboration based on systems thinking (Meadows, Senge).
@@ -34,8 +33,7 @@ class LoopPolarity(Enum):
 
 @dataclass
 class FeedbackLoop:
-    """
-    A detected feedback loop in the system
+    """A detected feedback loop in the system
 
     Feedback loops are circular causal chains where:
     A -> B -> C -> A (with delays and polarities)
@@ -53,8 +51,7 @@ class FeedbackLoop:
 
 
 class FeedbackLoopDetector:
-    """
-    Detects reinforcing and balancing feedback loops in AI-human collaboration
+    """Detects reinforcing and balancing feedback loops in AI-human collaboration
 
     Based on systems thinking (Meadows, Senge):
 
@@ -85,6 +82,7 @@ class FeedbackLoopDetector:
         ... ]
         >>> loops = detector.detect_active_loop(history)
         >>> print(loops["dominant_loop"])
+
     """
 
     def __init__(self):
@@ -99,7 +97,7 @@ class FeedbackLoopDetector:
             loop_id="R1_trust_building",
             loop_type=LoopType.REINFORCING,
             polarity=LoopPolarity.VIRTUOUS,
-            description="Trust building virtuous cycle: Success → Trust ↑ → Delegation ↑ → More Success",
+            description="Trust building cycle: Success → Trust ↑ → Delegation ↑ → More Success",
             components=["trust", "success_rate", "delegation_level"],
             intervention_points=["celebrate_wins", "increase_transparency"],
         )
@@ -109,7 +107,7 @@ class FeedbackLoopDetector:
             loop_id="R2_trust_erosion",
             loop_type=LoopType.REINFORCING,
             polarity=LoopPolarity.VICIOUS,
-            description="Trust erosion vicious cycle: Failure → Trust ↓ → Micromanagement ↑ → More Failures",
+            description="Trust erosion: Failure → Trust ↓ → Micromanagement ↑ → More Failures",
             components=["trust", "failure_rate", "oversight_level"],
             intervention_points=["break_cycle", "rebuild_confidence", "adjust_scope"],
         )
@@ -128,8 +126,7 @@ class FeedbackLoopDetector:
         self.detected_loops.extend([trust_building, trust_erosion, quality_control])
 
     def detect_active_loop(self, session_history: list[dict[str, Any]]) -> dict[str, Any]:
-        """
-        Analyze session history for active feedback loops
+        """Analyze session history for active feedback loops
 
         Examines trends in trust, success rate, and collaboration metrics
         to determine which feedback loop is currently dominant.
@@ -151,6 +148,7 @@ class FeedbackLoopDetector:
             ...     {"trust": 0.7, "success_rate": 0.8}
             ... ]
             >>> result = detector.detect_active_loop(history)
+
         """
         if len(session_history) < 2:
             return {
@@ -183,7 +181,7 @@ class FeedbackLoopDetector:
                 "details": dominant_loop,
             }
 
-        elif trust_trend < -0.1 and success_rate < 0.4:
+        if trust_trend < -0.1 and success_rate < 0.4:
             # Trust erosion vicious cycle active
             dominant_loop = self._get_loop_by_id("R2_trust_erosion")
             return {
@@ -191,25 +189,23 @@ class FeedbackLoopDetector:
                 "loop_type": "reinforcing_vicious",
                 "loop_strength": min(abs(trust_trend) * (1 - success_rate), 1.0),
                 "trend": "amplifying_negative",
-                "recommendation": "INTERVENTION NEEDED: Break the cycle. Reduce scope, rebuild confidence.",
+                "recommendation": "INTERVENTION NEEDED: Break cycle. Reduce scope, rebuild confidence.",
                 "details": dominant_loop,
             }
 
-        else:
-            # Quality control balancing loop active
-            dominant_loop = self._get_loop_by_id("B1_quality_control")
-            return {
-                "dominant_loop": "B1_quality_control",
-                "loop_type": "balancing",
-                "loop_strength": 0.5,
-                "trend": "stabilizing",
-                "recommendation": "System stable. Monitor for reinforcing loop activation.",
-                "details": dominant_loop,
-            }
+        # Quality control balancing loop active
+        dominant_loop = self._get_loop_by_id("B1_quality_control")
+        return {
+            "dominant_loop": "B1_quality_control",
+            "loop_type": "balancing",
+            "loop_strength": 0.5,
+            "trend": "stabilizing",
+            "recommendation": "System stable. Monitor for reinforcing loop activation.",
+            "details": dominant_loop,
+        }
 
     def detect_virtuous_cycle(self, history: list[dict[str, Any]]) -> bool:
-        """
-        Detect reinforcing positive feedback (virtuous cycle)
+        """Detect reinforcing positive feedback (virtuous cycle)
 
         A virtuous cycle is present when:
         1. Trust is increasing
@@ -230,6 +226,7 @@ class FeedbackLoopDetector:
             ... ]
             >>> detector.detect_virtuous_cycle(history)
             True
+
         """
         if len(history) < 3:
             return False
@@ -256,8 +253,7 @@ class FeedbackLoopDetector:
         return is_accelerating
 
     def detect_vicious_cycle(self, history: list[dict[str, Any]]) -> bool:
-        """
-        Detect reinforcing negative feedback (vicious cycle)
+        """Detect reinforcing negative feedback (vicious cycle)
 
         A vicious cycle is present when:
         1. Trust is decreasing
@@ -278,6 +274,7 @@ class FeedbackLoopDetector:
             ... ]
             >>> detector.detect_vicious_cycle(history)
             True
+
         """
         if len(history) < 3:
             return False
@@ -304,8 +301,7 @@ class FeedbackLoopDetector:
         return is_accelerating_down
 
     def get_intervention_recommendations(self, loop_id: str) -> list[str]:
-        """
-        Get recommended interventions for a specific loop
+        """Get recommended interventions for a specific loop
 
         Args:
             loop_id: ID of the loop (e.g., "R1_trust_building")
@@ -317,6 +313,7 @@ class FeedbackLoopDetector:
             >>> recommendations = detector.get_intervention_recommendations("R2_trust_erosion")
             >>> print(recommendations)
             ['break_cycle', 'rebuild_confidence', 'adjust_scope']
+
         """
         loop = self._get_loop_by_id(loop_id)
         if loop:
@@ -324,8 +321,7 @@ class FeedbackLoopDetector:
         return []
 
     def _calculate_trend(self, values: list[float]) -> float:
-        """
-        Calculate trend direction and magnitude
+        """Calculate trend direction and magnitude
 
         Uses simple linear regression slope as trend indicator.
 
@@ -333,6 +329,7 @@ class FeedbackLoopDetector:
             Positive value: increasing trend
             Negative value: decreasing trend
             Near zero: stable
+
         """
         if len(values) < 2:
             return 0.0
@@ -359,11 +356,11 @@ class FeedbackLoopDetector:
         return None
 
     def register_custom_loop(self, loop: FeedbackLoop):
-        """
-        Register a custom feedback loop for detection
+        """Register a custom feedback loop for detection
 
         Args:
             loop: FeedbackLoop instance to register
+
         """
         self.detected_loops.append(loop)