Create app/engine.py

app/engine.py

@@ -0,0 +1,114 @@
+import swisseph as swe
+import math
+import datetime
+import os
+from .models import GeoLocation, PlanetPosition, HexagramAddress, CognitiveProfile
+
+# CONSTANTS
+ARC_GATE = 5.625
+ARC_LINE = 0.9375
+ARC_COLOR = 0.15625
+ARC_TONE = 0.02604166
+ARC_BASE = 0.00520833
+
+class PrecisionEngine:
+    def __init__(self):
+        # Point to the data files we downloaded in Dockerfile
+        ephe_path = os.getenv("SE_EPHE_PATH", "/app/ephe")
+        swe.set_ephe_path(ephe_path)
+
+    def _get_julian_day(self, dt: datetime.datetime) -> float:
+        # Calculate UT (Universal Time) Julian Day
+        return swe.julday(dt.year, dt.month, dt.day, dt.hour + dt.minute/60.0 + dt.second/3600.0)
+
+    def _calculate_solar_arc_regression(self, natal_jd: float) -> float:
+        """
+        Solves for the exact moment the Sun was 88 degrees behind natal position.
+        """
+        # 1. Get Natal Sun Longitude
+        res = swe.calc_ut(natal_jd, swe.SUN)
+        natal_sun_long = res[0][0]
+        
+        target_long = (natal_sun_long - 88.0) % 360.0
+        
+        # 2. Estimate 88 days back
+        current_jd = natal_jd - 88.0
+        
+        # 3. Newton-Raphson Iteration to zero in
+        for _ in range(5):
+            res = swe.calc_ut(current_jd, swe.SUN)
+            current_long = res[0][0]
+            
+            delta = target_long - current_long
+            if delta > 180: delta -= 360
+            if delta < -180: delta += 360
+            
+            if abs(delta) < 0.00001:
+                break
+                
+            current_jd += delta 
+            
+        return current_jd
+
+    def _decode_fractal(self, longitude: float) -> HexagramAddress:
+        l = longitude % 360
+        gate = math.floor(l / ARC_GATE) % 64 + 1
+        rem_g = l % ARC_GATE
+        line = math.floor(rem_g / ARC_LINE) + 1
+        rem_l = rem_g % ARC_LINE
+        color = math.floor(rem_l / ARC_COLOR) + 1
+        rem_c = rem_l % ARC_COLOR
+        tone = math.floor(rem_c / ARC_TONE) + 1
+        rem_t = rem_c % ARC_TONE
+        base = math.floor(rem_t / ARC_BASE) + 1
+        
+        return HexagramAddress(gate=gate, line=line, color=color, tone=tone, base=base)
+
+    def calculate_chart(self, dt: datetime.datetime, loc: GeoLocation, mode: str = "Personality") -> dict:
+        jd_utc = self._get_julian_day(dt)
+        
+        if mode == "Design":
+            jd_utc = self._calculate_solar_arc_regression(jd_utc)
+
+        # Set Topocentric Observer
+        swe.set_topo(loc.longitude, loc.latitude, loc.altitude)
+        
+        planets = {}
+        bodies = {
+            "Sun": swe.SUN, "Moon": swe.MOON, "Mercury": swe.MERCURY, 
+            "Venus": swe.VENUS, "Mars": swe.MARS, "Jupiter": swe.JUPITER, 
+            "Saturn": swe.SATURN, "Uranus": swe.URANUS, "Neptune": swe.NEPTUNE, 
+            "Pluto": swe.PLUTO, "North Node": swe.MEAN_NODE
+        }
+
+        for name, pid in bodies.items():
+            flags = swe.FLG_TOPOCTR | swe.FLG_SPEED | swe.FLG_SWIEPH
+            res = swe.calc_ut(jd_utc, pid, flags)
+            
+            planets[name] = PlanetPosition(
+                name=name,
+                longitude=res[0][0],
+                latitude=res[0][1],
+                speed=res[0][3],
+                house=1, 
+                is_retrograde=res[0][3] < 0
+            )
+            
+        return planets
+
+    def analyze_cognitive(self, p_sun_long, p_node_long, d_sun_long, d_node_long) -> CognitiveProfile:
+        d_sun = self._decode_fractal(d_sun_long)
+        d_node = self._decode_fractal(d_node_long)
+        p_sun = self._decode_fractal(p_sun_long)
+        p_node = self._decode_fractal(p_node_long)
+        
+        colors = {1: "Fear", 2: "Hope", 3: "Desire", 4: "Need", 5: "Guilt", 6: "Innocence"}
+        
+        return CognitiveProfile(
+            digestion=colors.get(d_sun.color, "Unknown"),
+            environment=f"Color {d_node.color}",
+            perspective=f"Color {p_node.color}",
+            motivation=colors.get(p_sun.color, "Unknown"),
+            orientation_body="Left" if d_sun.tone <= 3 else "Right",
+            orientation_mind="Left" if p_sun.tone <= 3 else "Right"
+        )