Update astro_core.py

astro_core.py

@@ -1,54 +1,38 @@
 from datetime import datetime, timedelta
-import zoneinfo  # Use zoneinfo instead of pytz
+import zoneinfo
 from typing import Dict, Any
 from flatlib.datetime import Datetime
 from flatlib.geopos import GeoPos
 from flatlib.chart import Chart
+import matplotlib.pyplot as plt
+import numpy as np
 
-# Define our own constants
+# Define constants
 ZODIAC_SIGNS = [
-    'Aries', 'Taurus', 'Gemini', 'Cancer', 
+    'Aries', 'Taurus', 'Gemini', 'Cancer',
     'Leo', 'Virgo', 'Libra', 'Scorpio',
     'Sagittarius', 'Capricorn', 'Aquarius', 'Pisces'
 ]
 
 class ChartCalculator:
     """Handles astrological calculations"""
-    
+
     def __init__(self):
         self.planets = [
-            'Sun', 'Moon', 'Mercury', 'Venus', 'Mars', 
+            'Sun', 'Moon', 'Mercury', 'Venus', 'Mars',
             'Jupiter', 'Saturn', 'Uranus', 'Neptune', 'Pluto'
         ]
-    
-    def _get_house_number(self, lon: float, chart: Chart) -> int:
-        """Determine house number for a given longitude"""
-        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)
-        
-        # Simplified zodiac wrap-around handling 
-        lon = self._normalize_longitude(lon)
-        house_lons = [self._normalize_longitude(lon) for lon in house_lons] 
-        for i in range(12):
-            if house_lons[i] <= lon < house_lons[(i + 1) % 12]:
-                return i + 1
-        return 1  # Default to first house if no match
 
     def _normalize_longitude(self, lon: float) -> float:
         """Normalize longitude to 0-360 range"""
         return lon % 360
-    
+
     def _get_zodiac_sign(self, longitude: float) -> str:
         """Get zodiac sign from longitude"""
         sign_num = int(self._normalize_longitude(longitude) / 30)
         return ZODIAC_SIGNS[sign_num]
-    
-    def calculate_birth_chart(self, 
+
+    def calculate_birth_chart(self,
                               birth_datetime: datetime,
                               latitude: float,
                               longitude: float,
@@ -58,69 +42,43 @@ class ChartCalculator:
         Returns a dictionary of planetary positions and house cusps
         """
         try:
-            # Timezone handling with zoneinfo
-            tz = zoneinfo.ZoneInfo(timezone) 
+            # Handle timezone
+            tz = zoneinfo.ZoneInfo(timezone)
             birth_datetime = birth_datetime.replace(tzinfo=tz)
-
-            # Get UTC offset in hours
             utc_offset = int(birth_datetime.utcoffset().total_seconds() / 3600)
 
-            # Extract date and time components (adjust time for UTC)
+            # Adjust to UTC
             adjusted_datetime = birth_datetime - timedelta(hours=utc_offset)
             date_str = adjusted_datetime.strftime('%Y/%m/%d')
             time_str = adjusted_datetime.strftime('%H:%M')
 
-            # Convert to flatlib datetime (using UTC offset)
-            date = Datetime(date_str, time_str, utc_offset)  # Pass numeric UTC offset here
+            # Create flatlib datetime and position
+            date = Datetime(date_str, time_str, utc_offset)
             pos = GeoPos(latitude, longitude)
 
-            # Calculate chart
+            # Generate the 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 = self._get_zodiac_sign(lon)
-
-                        # Get house
-                        house = self._get_house_number(lon, chart)
-
-                        positions[planet] = {
-                            'sign': sign,
-                            'degrees': lon,
-                            'house': house
-                        }
-                except Exception as e:
+                obj = chart.get(planet)
+                if obj:
+                    lon = self._normalize_longitude(obj.lon)
                     positions[planet] = {
-                        'sign': 'Unknown',
-                        'degrees': 0,
-                        'house': 1,
-                        'error': str(e)
+                        'sign': self._get_zodiac_sign(lon),
+                        'degrees': lon
                     }
 
             # Extract house cusps
             houses = {}
             for i in range(1, 13):
-                try:
-                    house = chart.houses.get(i)
-                    if house:
-                        lon = self._normalize_longitude(house.lon)
-                        houses[f'House_{i}'] = {
-                            'sign': self._get_zodiac_sign(lon),
-                            'degrees': lon
-                        }
-                except Exception as e:
+                house = chart.houses.get(i)
+                if house:
+                    lon = self._normalize_longitude(house.lon)
                     houses[f'House_{i}'] = {
-                        'sign': 'Unknown',
-                        'degrees': 0,
-                        'error': str(e)
+                        'sign': self._get_zodiac_sign(lon),
+                        'degrees': lon
                     }
 
             return {
@@ -128,26 +86,38 @@ class ChartCalculator:
                 'houses': houses
             }
 
-        except zoneinfo.ZoneInfoNotFoundError:
-            return {
-                'error': f"Invalid timezone: {timezone}",
-                'planets': {},
-                'houses': {}
-            }
-        except KeyError as e: 
-            return {
-                'error': f"KeyError during chart calculation: {str(e)}",
-                'planets': {},
-                'houses': {}
-            }
-        except Exception as e:  
+        except Exception as e:
             return {
-                'error': f"Failed to calculate birth chart: {str(e)}",
+                'error': str(e),
                 'planets': {},
                 'houses': {}
             }
 
-    def get_planet_aspects(self, chart_data: Dict[str, Any]) -> Dict[str, list]:
-        """Calculate major aspects between planets"""
-        # TODO: Implement aspect calculation using flatlib
-        return {}
+    def draw_chart(self, chart_data: Dict[str, Any]):
+        """Generate a graphical view of the astrology chart"""
+        fig, ax = plt.subplots(figsize=(8, 8), subplot_kw={'projection': 'polar'})
+        ax.set_theta_zero_location("S")
+        ax.set_theta_direction(-1)
+
+        # Draw zodiac signs
+        zodiac_angles = np.linspace(0, 2 * np.pi, 13)  # 12 zodiac signs
+        for i, sign in enumerate(ZODIAC_SIGNS):
+            angle = zodiac_angles[i]
+            ax.text(angle, 1.05, sign, ha='center', va='center', fontsize=10)
+
+        # Draw houses
+        house_angles = np.linspace(0, 2 * np.pi, 13)  # 12 houses
+        for i in range(1, 13):
+            angle = house_angles[i - 1]
+            ax.text(angle, 0.8, f"H{i}", ha='center', va='center', fontsize=10)
+
+        # Plot planets
+        for planet, data in chart_data['planets'].items():
+            degrees = data['degrees']
+            angle = np.deg2rad(degrees)
+            ax.plot([angle], [0.5], marker='o', label=planet, markersize=10)
+
+        # Draw the chart
+        ax.legend(loc='upper right', bbox_to_anchor=(1.3, 1))
+        plt.title("Astrology Chart", va='bottom', fontsize=15)
+        plt.show()