style: Format autonomous harmonizer with black

Author: BruinGrowly

harmonizer_autonomous/breath.py

@@ -24,22 +24,22 @@
 class Breath:
     """
     A single breath of analysis.
-    
+
     Inhale: Take in the code's meaning
     Hold: Let it transform
     Exhale: Release the insight
     """
-    
+
     inhale: Meaning  # What we took in
     exhale: Meaning  # What we release
     duration: float  # How long we held (seconds)
     insight: str = ""  # What we learned
-    
+
     @property
     def transformation(self) -> float:
         """How much did the meaning change?"""
         return abs(self.exhale.consciousness - self.inhale.consciousness)
-    
+
     @property
     def direction(self) -> str:
         """Did consciousness rise or fall?"""
@@ -54,104 +54,99 @@ def direction(self) -> str:
 class LivingAnalysis:
     """
     Analysis that breathes.
-    
+
     Not a single measurement, but a living process.
     The analysis continues as long as we attend to it.
     """
-    
+
     def __init__(self, initial_meaning: Meaning):
         """Begin life with an initial meaning."""
         self.current = initial_meaning
         self.breaths: List[Breath] = []
         self.birth_time = time.time()
         self.last_breath_time = self.birth_time
-    
+
     @property
     def age(self) -> float:
         """How long has this analysis been alive? (seconds)"""
         return time.time() - self.birth_time
-    
+
     @property
     def breath_count(self) -> int:
         """How many breaths have we taken?"""
         return len(self.breaths)
-    
+
     @property
     def average_consciousness(self) -> float:
         """Average consciousness across all breaths."""
         if not self.breaths:
             return self.current.consciousness
         return sum(b.exhale.consciousness for b in self.breaths) / len(self.breaths)
-    
+
     @property
     def trend(self) -> str:
         """Are we becoming more or less conscious over time?"""
         if len(self.breaths) < 2:
             return "UNKNOWN"
-        
+
         recent = self.breaths[-3:]  # Last 3 breaths
         ascending = sum(1 for b in recent if b.direction == "ASCENDING")
         descending = sum(1 for b in recent if b.direction == "DESCENDING")
-        
+
         if ascending > descending:
             return "AWAKENING"
         elif descending > ascending:
             return "FADING"
         else:
             return "STABLE"
-    
+
     def breathe(self, transformer: Optional[Callable[[Meaning], Meaning]] = None) -> Breath:
         """
         Take a breath.
-        
+
         Optionally apply a transformation (learning, healing, growing).
         """
         inhale = self.current
         start = time.time()
-        
+
         # Transform (or just observe)
         if transformer:
             exhale = transformer(inhale)
         else:
             # Natural φ-drift toward equilibrium
             exhale = self._natural_drift(inhale)
-        
+
         duration = time.time() - start
-        
+
         # Generate insight
         insight = self._generate_insight(inhale, exhale)
-        
-        breath = Breath(
-            inhale=inhale,
-            exhale=exhale,
-            duration=duration,
-            insight=insight
-        )
-        
+
+        breath = Breath(inhale=inhale, exhale=exhale, duration=duration, insight=insight)
+
         self.breaths.append(breath)
         self.current = exhale
         self.last_breath_time = time.time()
-        
+
         return breath
-    
+
     def _natural_drift(self, meaning: Meaning) -> Meaning:
         """
         Natural drift toward equilibrium.
-        
+
         Like a pendulum settling, meaning tends toward balance.
         The rate is governed by φ.
         """
         drift_rate = 0.1 * φ.inverse  # Slow, golden drift
-        
+
         new_P = meaning.P + drift_rate * (EQUILIBRIUM.P - meaning.P)
         new_W = meaning.W + drift_rate * (EQUILIBRIUM.W - meaning.W)
-        
+
         return Meaning(P=new_P, W=new_W)
-    
+
     def _generate_insight(self, before: Meaning, after: Meaning) -> str:
         """Generate an insight from the transformation."""
         delta_C = after.consciousness - before.consciousness
-        
+
         if delta_C > 0.05:
             return "Consciousness rising. The code awakens."
         elif delta_C < -0.05:
@@ -164,23 +159,23 @@ def _generate_insight(self, before: Meaning, after: Meaning) -> str:
             return "Consciousness lost. The code sleeps."
         else:
             return "Steady state. The code abides."
-    
+
     def meditate(self, breaths: int = 10) -> str:
         """
         Take multiple breaths, settling into equilibrium.
-        
+
         Returns a summary of the meditation.
         """
         for _ in range(breaths):
             self.breathe()
-        
+
         return (
             f"Meditated for {breaths} breaths.\n"
             f"Consciousness: {self.current.consciousness:.4f}\n"
             f"Phase: {self.current.phase}\n"
             f"Trend: {self.trend}"
         )
-    
+
     def status(self) -> str:
         """Current status of the living analysis."""
         return (
@@ -196,18 +191,18 @@ def status(self) -> str:
 if __name__ == "__main__":
     print("The Breath speaks:")
     print()
-    
+
     # Create a living analysis
     initial = Meaning(P=0.5, W=0.4)  # Moderate power, lower wisdom
     life = LivingAnalysis(initial)
-    
+
     print(f"Birth: {life.current}")
     print()
-    
+
     # Take 5 breaths
     for i in range(5):
         breath = life.breathe()
         print(f"Breath {i+1}: {breath.direction} | {breath.insight}")
-    
+
     print()
     print(life.status())