Update app.py

app.py

@@ -1,149 +1,203 @@
-
-# astro_core.py
+# app.py
 """
-Core astrology calculation module.
-Handles birth chart calculations using flatlib.
+Streamlined Streamlit application for AI Astrology app with automatic timezone detection.
 """
 
+import streamlit as st
 from datetime import datetime
-import pytz
-from typing import Dict, Any
-from flatlib.datetime import Datetime
-from flatlib.geopos import GeoPos
-from flatlib.chart import Chart
-
-# Define our own constants
-ZODIAC_SIGNS = [
-    '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', 
-            '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)
-        
-        # 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 _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
-            
-            # Extract date and time components from birth_datetime
-            date_str = birth_datetime.strftime('%Y/%m/%d')
-            time_str = birth_datetime.strftime('%H:%M')
-            
-            # Convert to flatlib datetime
-            date = Datetime(date_str, time_str, 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 = 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)
-                    }
-            
-            # 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)
-                    }
-            
-            return {
-                'planets': positions,
-                'houses': houses
-            }
-            
-        except Exception as e:
+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  # Assuming you have the astro_core.py file
+from ai_interpreter import AstroAI  # Assuming you have the ai_interpreter.py file
+
+# Load environment variables (if you are using .env for API keys etc.)
+load_dotenv()
+
+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 '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(lng=longitude, lat=latitude)
+            if not timezone_str:
+                timezone_str = 'UTC'  # Fallback to UTC if timezone not found
+
             return {
-                'error': f"Failed to calculate birth chart: {str(e)}",
-                'planets': {},
-                'houses': {}
+                'latitude': latitude,
+                'longitude': longitude,
+                'timezone': timezone_str,
+                'error': None
             }
-    
-    def get_planet_aspects(self, chart_data: Dict[str, Any]) -> Dict[str, list]:
-        """Calculate major aspects between planets"""
-        # TODO: Implement aspect calculation
-        return {}
+        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)}'}
+
+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")
+
+    # Initialize session state
+    init_session_state()
+
+    # 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")
+
+        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}")
+
+    # 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']}")
+
+            # 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']}")
+
+            # 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?"
+            ]
+
+            selected_question = st.selectbox(
+                "Choose a question or type your own below:",
+                [""] + question_templates
+            )
+
+            custom_question = st.text_input(
+                "Ask about your chart:",
+                value=selected_question
+            )
+
+            if custom_question:
+                with st.spinner("Generating interpretation..."):
+                    interpreter = AstroAI()  # Replace with your actual AI interpreter class
+                    interpretation = interpreter.get_interpretation(
+                        st.session_state.birth_chart,
+                        custom_question
+                    )
+                    st.session_state.chat_history.append({
+                        "question": custom_question,
+                        "answer": interpretation
+                    })
+
+            # 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()