Update astro_core.py

astro_core.py

@@ -1,10 +1,16 @@
+# astro_core.py
+"""
+Core astrology calculation module.
+Handles birth chart calculations using flatlib.
+"""
+
 from datetime import datetime
-from typing import Dict, Any
 import pytz
-import flatlib
+from typing import Dict, Any
 from flatlib.datetime import Datetime
 from flatlib.geopos import GeoPos
 from flatlib.chart import Chart
+from flatlib.const import LIST_SIGNS, LIST_PLANETS
 
 class ChartCalculator:
     """Handles astrological calculations"""
@@ -13,22 +19,30 @@ class ChartCalculator:
         self.planets = ['Sun', 'Moon', 'Mercury', 'Venus', 'Mars', 
                        'Jupiter', 'Saturn', 'Uranus', 'Neptune', 'Pluto']
     
-    def _get_utc_offset(self, dt: datetime, timezone: str) -> str:
+    def _get_house_number(self, lon: float, chart: Chart) -> int:
         """
-        Get UTC offset for a given datetime and timezone
-        Returns offset in format '+HH:MM' or '-HH:MM'
+        Determine house number for a given longitude
         """
-        tz = pytz.timezone(timezone)
-        offset = tz.utcoffset(dt)
-        
-        # Convert timedelta to hours and minutes
-        total_seconds = int(offset.total_seconds())
-        hours = total_seconds // 3600
-        minutes = (abs(total_seconds) % 3600) // 60
+        house_lons = []
+        for i in range(1, 13):
+            try:
+                house = chart.houses.get(i)
+                house_lons.append(house.lon if house else 0)
+            except (KeyError, AttributeError):
+                house_lons.append(0)
         
-        # Format as string
-        sign = '+' if hours >= 0 else '-'
-        return f"{sign}{abs(hours):02d}:{minutes:02d}"
+        # Convert longitude to house number
+        for i in range(12):
+            next_i = (i + 1) % 12
+            if (house_lons[i] <= lon < house_lons[next_i]) or \
+               (house_lons[i] > house_lons[next_i] and  # Handle zodiac wrap
+                (lon >= house_lons[i] or lon < house_lons[next_i])):
+                return i + 1
+        return 1  # Default to first house if no match found
+    
+    def _normalize_longitude(self, lon: float) -> float:
+        """Normalize longitude to 0-360 range"""
+        return lon % 360
     
     def calculate_birth_chart(self, 
                             birth_datetime: datetime,
@@ -39,66 +53,78 @@ class ChartCalculator:
         Calculate birth chart positions
         Returns a dictionary of planetary positions and house cusps
         """
-        # Convert datetime to format required by flatlib
-        date_str = birth_datetime.strftime("%Y/%m/%d")
-        time_str = birth_datetime.strftime("%H:%M")
-        
-        # Get UTC offset for the timezone
-        utc_offset = self._get_utc_offset(birth_datetime, timezone)
-        
-        # Create flatlib datetime object
-        date = Datetime(date_str, time_str, utc_offset)
-        pos = GeoPos(latitude, longitude)
-        
-        # Calculate chart
-        chart = Chart(date, pos)
-        
-        # Extract planetary positions
-        positions = {}
-        for planet in self.planets:
-            obj = chart.get(planet)
-            # Get house placement by comparing longitude to house cusps
-            house_num = self._get_house_number(obj.lon, chart)
-            positions[planet] = {
-                'sign': obj.sign,
-                'degrees': obj.lon,
-                'house': house_num
+        try:
+            # Ensure timezone is valid
+            tz = pytz.timezone(timezone)
+            birth_datetime = tz.localize(birth_datetime) if birth_datetime.tzinfo is None else birth_datetime
+            
+            # Convert to flatlib datetime
+            date = Datetime(birth_datetime, timezone)
+            pos = GeoPos(latitude, longitude)
+            
+            # Calculate chart
+            chart = Chart(date, pos)
+            
+            # Extract planetary positions
+            positions = {}
+            for planet in self.planets:
+                try:
+                    obj = chart.get(planet)
+                    if obj:
+                        # Normalize longitude
+                        lon = self._normalize_longitude(obj.lon)
+                        
+                        # Get sign
+                        sign_num = int(lon / 30)
+                        sign = LIST_SIGNS[sign_num]
+                        
+                        # Get house
+                        house = self._get_house_number(lon, chart)
+                        
+                        positions[planet] = {
+                            'sign': sign,
+                            'degrees': lon,
+                            'house': house
+                        }
+                except Exception as e:
+                    positions[planet] = {
+                        'sign': 'Unknown',
+                        'degrees': 0,
+                        'house': 1,
+                        'error': str(e)
+                    }
+            
+            # Extract house cusps
+            houses = {}
+            for i in range(1, 13):
+                try:
+                    house = chart.houses.get(i)
+                    if house:
+                        lon = self._normalize_longitude(house.lon)
+                        sign_num = int(lon / 30)
+                        houses[f'House_{i}'] = {
+                            'sign': LIST_SIGNS[sign_num],
+                            'degrees': lon
+                        }
+                except Exception as e:
+                    houses[f'House_{i}'] = {
+                        'sign': 'Unknown',
+                        'degrees': 0,
+                        'error': str(e)
+                    }
+            
+            return {
+                'planets': positions,
+                'houses': houses
             }
-        
-        # Extract house cusps
-        houses = {}
-        for i in range(1, 13):
-            house = chart.houses.get(i)
-            houses[f'House_{i}'] = {
-                'sign': house.sign,
-                'degrees': house.lon
+            
+        except Exception as e:
+            return {
+                'error': f"Failed to calculate birth chart: {str(e)}",
+                'planets': {},
+                'houses': {}
             }
-        
-        return {
-            'planets': positions,
-            'houses': houses
-        }
     
-    def _get_house_number(self, longitude: float, chart: Chart) -> int:
-        """
-        Determine which house a planet is in based on its longitude
-        """
-        for i in range(1, 13):
-            next_house = i + 1 if i < 12 else 1
-            cusp = chart.houses.get(i).lon
-            next_cusp = chart.houses.get(next_house).lon
-            
-            # Handle cases where house spans 0° Aries
-            if next_cusp < cusp:
-                if longitude >= cusp or longitude < next_cusp:
-                    return i
-            else:
-                if cusp <= longitude < next_cusp:
-                    return i
-        
-        # Fallback (shouldn't happen with valid data)
-        return 1
-
     def get_planet_aspects(self, chart_data: Dict[str, Any]) -> Dict[str, list]:
         """Calculate major aspects between planets"""
         # TODO: Implement aspect calculation