Update app.py

app.py

@@ -1,206 +1,149 @@
-# app.py
+
+# astro_core.py
 """
-Streamlined Streamlit application for AI Astrology app with automatic timezone detection.
+Core astrology calculation module.
+Handles birth chart calculations using flatlib.
 """
 
-import streamlit as st
 from datetime import datetime
 import pytz
-from geopy.geocoders import Nominatim
-from geopy.exc import GeocoderTimedOut, GeocoderServiceError
-from timezonefinder import TimezoneFinder
-from dotenv import load_dotenv
-from astro_core import ChartCalculator
-from ai_interpreter import AstroAI
-
-# Load environment variables
-load_dotenv()
+from typing import Dict, Any
+from flatlib.datetime import Datetime
+from flatlib.geopos import GeoPos
+from flatlib.chart import Chart
 
-def init_session_state():
-    """Initialize session state variables"""
-    if 'birth_chart' not in st.session_state:
-        st.session_state.birth_chart = None
-    if 'chat_history' not in st.session_state:
-        st.session_state.chat_history = []
-    if 'user_info' not in st.session_state:
-        st.session_state.user_info = None
-    if 'location_coords' not in st.session_state:
-        st.session_state.location_coords = None
-    if 'calculation_error' not in st.session_state:
-        st.session_state.calculation_error = None
-
-def get_location_details(location_name: str) -> dict:
-    """Get coordinates and timezone from location name"""
-    try:
-        # Initialize geocoder and timezone finder
-        geolocator = Nominatim(user_agent="ai_astrology_app")
-        tf = TimezoneFinder()
-        
-        # Get location
-        location = geolocator.geocode(location_name)
-        if location:
-            latitude, longitude = location.latitude, location.longitude
-            
-            # Get timezone string for the coordinates
-            timezone_str = tf.timezone_at(lat=latitude, lng=longitude)
-            if not timezone_str:
-                timezone_str = 'UTC'  # Fallback to UTC if timezone not found
-            
-            return {
-                'latitude': latitude,
-                'longitude': longitude,
-                'timezone': timezone_str,
-                'error': None
-            }
-        return {'error': 'Location not found'}
-    except (GeocoderTimedOut, GeocoderServiceError) as e:
-        return {'error': f'Geocoding error: {str(e)}'}
-    except Exception as e:
-        return {'error': f'Unexpected error: {str(e)}'}
+# Define our own constants
+ZODIAC_SIGNS = [
+    'Aries', 'Taurus', 'Gemini', 'Cancer', 
+    'Leo', 'Virgo', 'Libra', 'Scorpio',
+    'Sagittarius', 'Capricorn', 'Aquarius', 'Pisces'
+]
 
-def calculate_chart(user_data: dict):
-    """Calculate birth chart based on user data"""
-    try:
-        calculator = ChartCalculator()
-        birth_datetime = datetime.combine(user_data['birth_date'], user_data['birth_time'])
-        
-        chart_data = calculator.calculate_birth_chart(
-            birth_datetime,
-            user_data['latitude'],
-            user_data['longitude'],
-            user_data['timezone']
-        )
-        
-        # Check for calculation errors
-        if 'error' in chart_data:
-            st.session_state.calculation_error = chart_data['error']
-            return None
-        
-        return chart_data
-    except Exception as e:
-        st.session_state.calculation_error = str(e)
-        return None
-
-def main():
-    st.title("AI Astrology Assistant")
+class ChartCalculator:
+    """Handles astrological calculations"""
     
-    # Initialize session state
-    init_session_state()
+    def __init__(self):
+        self.planets = [
+            'Sun', 'Moon', 'Mercury', 'Venus', 'Mars', 
+            'Jupiter', 'Saturn', 'Uranus', 'Neptune', 'Pluto'
+        ]
     
-    # User Information Form
-    with st.form("user_info_form"):
-        st.subheader("Personal Information")
-        
-        col1, col2 = st.columns(2)
-        with col1:
-            name = st.text_input("Full Name")
-            gender = st.selectbox("Gender", ["Male", "Female", "Non-binary", "Prefer not to say"])
-            birth_date = st.date_input("Birth Date", min_value=datetime(1900, 1, 1))
-        
-        with col2:
-            birth_time = st.time_input("Birth Time")
-            birth_place = st.text_input("Birth Place (City, Country)")
-        
-        submit_button = st.form_submit_button("Generate Birth Chart")
+    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)
         
-        if submit_button:
-            if not birth_place:
-                st.error("Please enter your birth place.")
-            else:
-                with st.spinner("Looking up location details..."):
-                    location_details = get_location_details(birth_place)
-                
-                if location_details.get('error'):
-                    st.error(location_details['error'])
-                else:
-                    # Reset error state
-                    st.session_state.calculation_error = None
-                    
-                    # Store user information
-                    st.session_state.user_info = {
-                        'name': name,
-                        'gender': gender,
-                        'birth_date': birth_date,
-                        'birth_time': birth_time,
-                        'birth_place': birth_place,
-                        'latitude': location_details['latitude'],
-                        'longitude': location_details['longitude'],
-                        'timezone': location_details['timezone']
-                    }
-                    
-                    # Display detected timezone
-                    st.info(f"Detected timezone for {birth_place}: {location_details['timezone']}")
-                    
-                    # Calculate birth chart
-                    with st.spinner("Calculating your birth chart..."):
-                        st.session_state.birth_chart = calculate_chart(st.session_state.user_info)
-                    
-                    if st.session_state.birth_chart:
-                        st.success("Birth chart calculated successfully!")
-                    elif st.session_state.calculation_error:
-                        st.error(f"Error calculating birth chart: {st.session_state.calculation_error}")
+        # 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
     
-    # Display areas (only show if birth chart is calculated)
-    if st.session_state.birth_chart and st.session_state.user_info:
-        col1, col2 = st.columns([2, 3])
-        
-        with col1:
-            st.subheader(f"Birth Chart for {st.session_state.user_info['name']}")
+    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, 
+                            birth_datetime: datetime,
+                            latitude: float,
+                            longitude: float,
+                            timezone: str) -> Dict[str, Any]:
+        """
+        Calculate birth chart positions
+        Returns a dictionary of planetary positions and house cusps
+        """
+        try:
+            # Ensure timezone is valid
+            tz = pytz.timezone(timezone)
+            birth_datetime = tz.localize(birth_datetime) if birth_datetime.tzinfo is None else birth_datetime
             
-            # Display birth details
-            st.write("**Birth Details:**")
-            st.write(f"Date: {st.session_state.user_info['birth_date'].strftime('%B %d, %Y')}")
-            st.write(f"Time: {st.session_state.user_info['birth_time'].strftime('%H:%M')}")
-            st.write(f"Location: {st.session_state.user_info['birth_place']}")
-            st.write(f"Timezone: {st.session_state.user_info['timezone']}")
+            # Extract date and time components from birth_datetime
+            date_str = birth_datetime.strftime('%Y/%m/%d')
+            time_str = birth_datetime.strftime('%H:%M')
             
-            # Display planetary positions
-            st.write("**Planetary Positions:**")
-            for planet, data in st.session_state.birth_chart['planets'].items():
-                if 'error' in data:
-                    st.write(f"{planet}: Could not calculate position")
-                else:
-                    st.write(f"{planet}: {data['degrees']:.2f}° {data['sign']} in House {data['house']}")
-        
-        with col2:
-            st.subheader("AI Interpretation")
-            # Suggested questions
-            question_templates = [
-                "What are the main themes in my birth chart?",
-                f"How does my {st.session_state.user_info['gender'].lower()} energy manifest in this chart?",
-                "What career paths might suit me based on my chart?",
-                "What are my relationship patterns according to this chart?",
-                "What are my greatest strengths based on this chart?"
-            ]
+            # Convert to flatlib datetime
+            date = Datetime(date_str, time_str, timezone)
+            pos = GeoPos(latitude, longitude)
+            
+            # Calculate chart
+            chart = Chart(date, pos)
             
-            selected_question = st.selectbox(
-                "Choose a question or type your own below:",
-                [""] + question_templates
-            )
+            # 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:
+                    positions[planet] = {
+                        'sign': 'Unknown',
+                        'degrees': 0,
+                        'house': 1,
+                        'error': str(e)
+                    }
             
-            custom_question = st.text_input(
-                "Ask about your chart:",
-                value=selected_question
-            )
+            # 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:
+                    houses[f'House_{i}'] = {
+                        'sign': 'Unknown',
+                        'degrees': 0,
+                        'error': str(e)
+                    }
             
-            if custom_question:
-                with st.spinner("Generating interpretation..."):
-                    interpreter = AstroAI()
-                    interpretation = interpreter.get_interpretation(
-                        st.session_state.birth_chart,
-                        custom_question
-                    )
-                    st.session_state.chat_history.append({
-                        "question": custom_question,
-                        "answer": interpretation
-                    })
+            return {
+                'planets': positions,
+                'houses': houses
+            }
             
-            # Display chat history
-            if st.session_state.chat_history:
-                st.write("**Previous Interpretations:**")
-                for exchange in st.session_state.chat_history:
-                    with st.expander(f"Q: {exchange['question']}", expanded=False):
-                        st.write(exchange['answer'])
-
-if __name__ == "__main__":
-    main()
+        except Exception as e:
+            return {
+                'error': f"Failed to calculate birth chart: {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
+        return {}