removed ephem

app.py

@@ -1,7 +1,6 @@
 import streamlit as st
 import pandas as pd
 from datetime import datetime
-import ephem
 import pytz
 from transformers import pipeline
 import math
@@ -27,56 +26,32 @@ except Exception as e:
     st.stop()
 
 
-def calculate_planetary_positions(birth_date, birth_time, timezone):
-    """Calculate planetary positions at the time of birth."""
-    # Create datetime object
-    date_time = datetime.combine(birth_date, birth_time)
-    tz = pytz.timezone(timezone)
-    date_time = tz.localize(date_time)
-
-    # Convert to UTC for ephem calculations
-    date_time_utc = date_time.astimezone(pytz.UTC)
-
-    # Initialize ephem date
-    ephem_date = ephem.Date(date_time_utc)
-
-    # Dictionary to store planetary positions
-    positions = {}
-
-    # Calculate positions for each planet
-    planets = {
-        'Sun': ephem.Sun(),
-        'Moon': ephem.Moon(),
-        'Mercury': ephem.Mercury(),
-        'Venus': ephem.Venus(),
-        'Mars': ephem.Mars(),
-        'Jupiter': ephem.Jupiter(),
-        'Saturn': ephem.Saturn(),
-        'Uranus': ephem.Uranus(),
-        'Neptune': ephem.Neptune(),
-        'Pluto': ephem.Pluto()
-    }
-
-    for name, planet in planets.items():
-        planet.compute(ephem_date)
-        # Convert position to degrees
-        position_deg = math.degrees(planet.hlong)
-        # Normalize to 0-360 degrees
-        position_deg = position_deg % 360
-        positions[name] = position_deg
-
-    return positions
-
-
-def get_zodiac_sign(longitude):
-    """Convert longitude to zodiac sign."""
-    signs = [
-        "Aries", "Taurus", "Gemini", "Cancer",
-        "Leo", "Virgo", "Libra", "Scorpio",
-        "Sagittarius", "Capricorn", "Aquarius", "Pisces"
-    ]
-    sign_index = int(longitude / 30)
-    return signs[sign_index]
+def calculate_zodiac_sign(month, day):
+    """Calculate zodiac sign based on birth date."""
+    if (month == 3 and day >= 21) or (month == 4 and day <= 19):
+        return "Aries"
+    elif (month == 4 and day >= 20) or (month == 5 and day <= 20):
+        return "Taurus"
+    elif (month == 5 and day >= 21) or (month == 6 and day <= 20):
+        return "Gemini"
+    elif (month == 6 and day >= 21) or (month == 7 and day <= 22):
+        return "Cancer"
+    elif (month == 7 and day >= 23) or (month == 8 and day <= 22):
+        return "Leo"
+    elif (month == 8 and day >= 23) or (month == 9 and day <= 22):
+        return "Virgo"
+    elif (month == 9 and day >= 23) or (month == 10 and day <= 22):
+        return "Libra"
+    elif (month == 10 and day >= 23) or (month == 11 and day <= 21):
+        return "Scorpio"
+    elif (month == 11 and day >= 22) or (month == 12 and day <= 21):
+        return "Sagittarius"
+    elif (month == 12 and day >= 22) or (month == 1 and day <= 19):
+        return "Capricorn"
+    elif (month == 1 and day >= 20) or (month == 2 and day <= 18):
+        return "Aquarius"
+    else:
+        return "Pisces"
 
 
 def get_element(sign):
@@ -90,44 +65,38 @@ def get_element(sign):
     return elements.get(sign, "Unknown")
 
 
-def generate_prediction(planetary_positions):
-    """Generate daily prediction based on planetary positions."""
-    # Create a prompt based on planetary positions and elements
-    prompt = "Astrological reading based on planetary positions:\n"
-
-    # Analyze dominant elements
-    elements_count = {"Fire": 0, "Earth": 0, "Air": 0, "Water": 0}
-
-    for planet, position in planetary_positions.items():
-        sign = get_zodiac_sign(position)
-        element = get_element(sign)
-        elements_count[element] += 1
-        prompt += f"{planet} in {sign} ({element})\n"
+def calculate_nakshatra(birth_date):
+    """Calculate Nakshatra based on birth date (simplified calculation)."""
+    nakshatras = [
+        "Ashwini", "Bharani", "Krittika", "Rohini", "Mrigashira", "Ardra",
+        "Punarvasu", "Pushya", "Ashlesha", "Magha", "Purva Phalguni",
+        "Uttara Phalguni", "Hasta", "Chitra", "Swati", "Vishakha", "Anuradha",
+        "Jyeshtha", "Mula", "Purva Ashadha", "Uttara Ashadha", "Shravana",
+        "Dhanishta", "Shatabhisha", "Purva Bhadrapada", "Uttara Bhadrapada", "Revati"
+    ]
+    # Simplified calculation based on birth date
+    day_of_year = birth_date.timetuple().tm_yday
+    nakshatra_index = (day_of_year * 27) // 365
+    return nakshatras[nakshatra_index]
 
-    # Find dominant element
-    dominant_element = max(elements_count.items(), key=lambda x: x[1])[0]
-    prompt += f"\nDominant element: {dominant_element}\n"
 
-    # Calculate major aspects
-    aspects = []
-    planets = list(planetary_positions.items())
-    for i, (planet1, pos1) in enumerate(planets):
-        for planet2, pos2 in planets[i + 1:]:
-            angle = abs(pos1 - pos2) % 360
-            if abs(angle - 120) < 8:  # Trine
-                aspects.append(f"Harmonious trine between {planet1} and {planet2}")
-            elif abs(angle - 90) < 8:  # Square
-                aspects.append(f"Challenging square between {planet1} and {planet2}")
-            elif abs(angle - 180) < 8:  # Opposition
-                aspects.append(f"Dynamic opposition between {planet1} and {planet2}")
+def generate_prediction(birth_date, birth_time, timezone):
+    """Generate prediction based on astrological factors."""
+    zodiac_sign = calculate_zodiac_sign(birth_date.month, birth_date.day)
+    element = get_element(zodiac_sign)
+    nakshatra = calculate_nakshatra(birth_date)
 
-    if aspects:
-        prompt += "\nSignificant aspects:\n" + "\n".join(aspects)
+    prompt = f"""
+    Astrological reading for a person born under:
+    - Zodiac Sign: {zodiac_sign}
+    - Element: {element}
+    - Nakshatra: {nakshatra}
+    - Birth Time: {birth_time.strftime('%H:%M')}
 
-    prompt += "\nBased on these positions, today's prediction: "
+    Based on these positions, today's prediction: 
+    """
 
     try:
-        # Generate prediction using the model
         prediction = generator(
             prompt,
             max_length=200,
@@ -135,9 +104,7 @@ def generate_prediction(planetary_positions):
             temperature=0.7
         )[0]['generated_text']
 
-        # Clean up the prediction
-        prediction = prediction.split("today's prediction: ")[-1].strip()
-        return prediction
+        return prediction.split("today's prediction: ")[-1].strip()
     except Exception as e:
         return "Unable to generate prediction at this time. Please try again later."
 
@@ -167,30 +134,26 @@ timezone = st.selectbox(
 )
 
 if st.button("Get Prediction"):
-    with st.spinner("Calculating planetary positions and generating prediction..."):
+    with st.spinner("Calculating astrological factors and generating prediction..."):
         try:
-            # Calculate planetary positions
-            positions = calculate_planetary_positions(birth_date, birth_time, timezone)
-
-            # Display planetary positions
-            st.subheader("Planetary Positions at Birth")
-            planet_data = []
-            for planet, position in positions.items():
-                sign = get_zodiac_sign(position)
-                element = get_element(sign)
-                planet_data.append({
-                    "Planet": planet,
-                    "Sign": sign,
-                    "Element": element,
-                    "Degrees": f"{position:.2f}°"
-                })
-
-            df = pd.DataFrame(planet_data)
-            st.table(df)
+            # Display birth chart information
+            st.subheader("Your Astrological Profile")
+            zodiac_sign = calculate_zodiac_sign(birth_date.month, birth_date.day)
+            element = get_element(zodiac_sign)
+            nakshatra = calculate_nakshatra(birth_date)
+
+            profile_data = pd.DataFrame([{
+                "Zodiac Sign": zodiac_sign,
+                "Element": element,
+                "Nakshatra": nakshatra,
+                "Birth Time": birth_time.strftime("%H:%M")
+            }])
+
+            st.table(profile_data)
 
             # Generate and display prediction
             st.subheader("Your Daily Prediction")
-            prediction = generate_prediction(positions)
+            prediction = generate_prediction(birth_date, birth_time, timezone)
             st.write(prediction)
 
             # Add disclaimer