Update defrag_engine.py

defrag_engine.py

@@ -1,6 +1,5 @@
 import datetime
-# FIXED IMPORT: Uses 'Report' class for kerykeion > 2.0
-from kerykeion import Report
+from kerykeion import AstrologicalSubjectFactory
 from dateutil.parser import parse
 import math
 import json
@@ -9,7 +8,7 @@ import os
 class DefragDeepCompute:
     def __init__(self):
         self.user_profile = {}
-        
+
     # --- NUMEROLOGY ENGINE ---
     def calculate_numerology(self, dob_str):
         """Calculates Life Path and Personal Year/Month/Day."""
@@ -21,7 +20,7 @@ class DefragDeepCompute:
                 while n > 9 and n != 11 and n != 22 and n != 33:
                     n = sum(int(digit) for digit in str(n))
                 return n
-
+            
             # Life Path
             lp = reduce_sum(dob.day + dob.month + dob.year)
             
@@ -40,107 +39,100 @@ class DefragDeepCompute:
                 "personal_month": pm,
                 "personal_day": pd
             }
-        except:
-            # Fallback if date parse fails
-            return {"life_path": 1, "personal_year": 1, "personal_month": 1, "personal_day": 1}
+        except Exception as e:
+            return {"error": str(e)}
+
+    # --- I CHING ENGINE ---
+    def iching_cast(self):
+        """Casts a 6-line hexagram."""
+        import random
+        lines = [random.choice(["Yang", "Yin"]) for _ in range(6)]
+        return {"hexagram_lines": lines}
 
     # --- ASTROLOGY ENGINE ---
-    def calculate_astrology(self, name, dob_str, time_str, city, country_code="US"):
-        """Calculates Natal Chart using Kerykeion Report class."""
+    def astrology_chart(self, name, year, month, day, hour, minute, city="Unknown", nation="Unknown"):
+        """Uses kerykeion to calculate natal chart."""
         try:
-            # Parse Date
-            dt = parse(f"{dob_str} {time_str}")
-            
-            # FIXED INITIALIZATION: Using Report class
-            natal = Report(name, dt.year, dt.month, dt.day, dt.hour, dt.minute, city, country_code)
+            subject = AstrologicalSubjectFactory.from_birth_data(
+                name=name,
+                year=year,
+                month=month,
+                day=day,
+                hour=hour,
+                minute=minute,
+                city=city,
+                nation=nation,
+                online=False
+            )
             
-            # Simple Element Calculation (Based on Sun/Moon signs)
-            elements = {"Fire": 0, "Earth": 0, "Air": 0, "Water": 0}
-            signs_element = {
-                "Aries": "Fire", "Leo": "Fire", "Sagittarius": "Fire",
-                "Taurus": "Earth", "Virgo": "Earth", "Capricorn": "Earth",
-                "Gemini": "Air", "Libra": "Air", "Aquarius": "Air",
-                "Cancer": "Water", "Scorpio": "Water", "Pisces": "Water"
+            # Extract key positions
+            return {
+                "sun_sign": subject.sun.sign if hasattr(subject, 'sun') else "Unknown",
+                "moon_sign": subject.moon.sign if hasattr(subject, 'moon') else "Unknown",
+                "rising_sign": subject.first_house.sign if hasattr(subject, 'first_house') else "Unknown",
+                "planets": {
+                    "sun": {"sign": subject.sun.sign, "position": subject.sun.position} if hasattr(subject, 'sun') else {},
+                    "moon": {"sign": subject.moon.sign, "position": subject.moon.position} if hasattr(subject, 'moon') else {},
+                    "mercury": {"sign": subject.mercury.sign, "position": subject.mercury.position} if hasattr(subject, 'mercury') else {},
+                    "venus": {"sign": subject.venus.sign, "position": subject.venus.position} if hasattr(subject, 'venus') else {},
+                    "mars": {"sign": subject.mars.sign, "position": subject.mars.position} if hasattr(subject, 'mars') else {}
+                }
             }
+        except Exception as e:
+            return {"error": str(e)}
+
+    # --- MASTER COMPUTE ---
+    def execute_defrag(self, birth_data, system_status="normal"):
+        """Master function that runs all engines and returns Soul Log."""
+        try:
+            # Parse birth data
+            name = birth_data.get("name", "User")
+            dob_str = birth_data.get("dob")
+            year = birth_data.get("year")
+            month = birth_data.get("month")
+            day = birth_data.get("day")
+            hour = birth_data.get("hour", 12)
+            minute = birth_data.get("minute", 0)
+            city = birth_data.get("city", "Unknown")
+            nation = birth_data.get("nation", "US")
             
-            # Kerykeion returns signs as strings (e.g., "Scorpio")
-            sun_sign = natal.sun["sign"]
-            moon_sign = natal.moon["sign"]
-            
-            elements[signs_element.get(sun_sign, "Fire")] += 2
-            elements[signs_element.get(moon_sign, "Water")] += 2
+            # Run engines
+            numerology = self.calculate_numerology(dob_str)
+            iching = self.iching_cast()
+            astrology = self.astrology_chart(name, year, month, day, hour, minute, city, nation)
             
-            dominant_element = max(elements, key=elements.get).lower()
+            # Calculate stability score (0-100)
+            stability = self._calculate_stability(numerology, astrology, system_status)
             
-            return {
-                "sun_sign": sun_sign,
-                "moon_sign": moon_sign,
-                "ascendant": natal.first_house["sign"],
-                "dominant_element": dominant_element,
-                "natal_data": "Full chart data calculated"
+            # Generate Soul Log
+            soul_log = {
+                "timestamp": datetime.datetime.now().isoformat(),
+                "user": name,
+                "numerology": numerology,
+                "iching": iching,
+                "astrology": astrology,
+                "stability_score": stability,
+                "system_status": system_status
             }
+            
+            return soul_log
         except Exception as e:
-            print(f"Astro Error: {e}")
-            return {"dominant_element": "water", "error": str(e), "sun_sign": "Unknown", "moon_sign": "Unknown"}
-
-    # --- HUMAN DESIGN ENGINE (STUB) ---
-    def calculate_human_design(self, dob_str, time_str):
-        """
-        Approximates HD Profile based on Sun position logic stub.
-        """
-        return {
-            "type": "Generator", 
-            "strategy": "Wait to Respond",
-            "authority": "Sacral",
-            "profile": "5/1"
-        }
-
-    # --- HEXAGRAM ENGINE ---
-    def get_current_hexagram(self):
-        """
-        Calculates the I-Ching Hexagram based on current transit Sun (Day of Year).
-        """
-        day_of_year = datetime.datetime.now().timetuple().tm_yday
-        gate = (day_of_year % 64) + 1
+            return {"error": str(e)}
+    
+    def _calculate_stability(self, numerology, astrology, system_status):
+        """Calculate stability score based on various factors."""
+        base_score = 75
         
-        # Generates a random binary structure for visual prototype
-        import random
-        binary = [random.randint(0,1) for _ in range(6)]
-        return {
-            "gate": gate,
-            "hexagram_binary": binary
-        }
-
-    # --- MASTER SYNTH ---
-    def run_deep_compute(self, name, dob, time, loc, user_input):
-        astro = self.calculate_astrology(name, dob, time, loc)
-        nums = self.calculate_numerology(dob)
-        hd = self.calculate_human_design(dob, time)
-        hex_data = self.get_current_hexagram()
+        # Adjust based on life path
+        if "life_path" in numerology:
+            lp = numerology["life_path"]
+            if lp in [11, 22, 33]:
+                base_score += 10
         
-        # Calculate Friction Level based on Numerology Cycle
-        friction = "STABLE"
-        if nums['personal_day'] == 5 or nums['personal_day'] == 7:
-            friction = "CRITICAL"
-
-        # The Soul Log
-        soul_log = {
-            "timestamp": datetime.datetime.now().isoformat(),
-            "user_input": user_input,
-            "hardware": {
-                "hd": hd,
-                "numerology": nums
-            },
-            "weather": {
-                "astro": astro,
-                "hexagram": hex_data
-            },
-            "computed_vector": {
-                "friction_level": friction,
-                "visual_seed": nums['personal_day'],
-                "visual_element": astro['dominant_element'],
-                "visual_code": hex_data['hexagram_binary']
-            }
-        }
+        # Adjust based on system status
+        if system_status == "chaotic":
+            base_score -= 25
+        elif system_status == "harmonious":
+            base_score += 15
         
-        return soul_log
+        return max(0, min(100, base_score))