Update app.py

app.py

@@ -1,7 +1,8 @@
 import gradio as gr
 import matplotlib.pyplot as plt
 from datetime import datetime
-from dateutil import parser
+from
+ dateutil import parser
 from io import BytesIO
 from PIL import Image
 from geopy.geocoders import Nominatim
@@ -75,51 +76,111 @@ def lon_to_sign(lon):
     minutes = int((lon % 1) * 60)
     return f"{signs[sign_index]} {degrees}°{minutes}'"
 
+import swisseph as swe
+from datetime import datetime
+
 def PLadder_ZSizes(utc_dt, lat, lon):
     """Calculate Planetary Ladder and Zone Sizes using Swiss Ephemeris."""
-    if not 1900 <= utc_dt.year <= 2050:
-        return {"error": "Date out of range (1900–2050)."}
-
-    # Initialize Swiss Ephemeris
-    swe.set_ephe_path("https://github.com/aloistr/swisseph/tree/master/ephe")  # Use default ephemeris path
     
-    # Map planet names to Swiss Ephemeris constants
+    # Updated time range check (Swiss Ephemeris supports -13000 to +17000)
+    if not -13000 <= utc_dt.year <= 17000:
+        return {"error": "Date out of Swiss Ephemeris range (-13,000–17,000 CE)."}
+    
+    # Configure Swiss Ephemeris for high precision
+    swe.set_ephe_path(None)  # Use default ephemeris path
+    swe.set_jpl_file('de441.eph')  # Use DE441 for best modern accuracy (optional)
+    
+    # Planet mapping (Swiss Ephemeris constants)
     planet_objects = {
         'Sun': swe.SUN, 'Moon': swe.MOON, 'Mercury': swe.MERCURY,
         'Venus': swe.VENUS, 'Mars': swe.MARS, 
         'Jupiter': swe.JUPITER, 'Saturn': swe.SATURN
     }
     
-    # Convert datetime to Julian Day
-    jd = swe.julday(utc_dt.year, utc_dt.month, utc_dt.day, 
-                    utc_dt.hour + utc_dt.minute/60 + utc_dt.second/3600)
+    # Convert datetime to Julian Day (high precision)
+    jd_utc = swe.julday(
+        utc_dt.year, utc_dt.month, utc_dt.day,
+        utc_dt.hour + utc_dt.minute/60 + utc_dt.second/3600
+    )
     
-    # Calculate geocentric ecliptic longitudes for each planet
+    # Calculate geocentric ecliptic longitudes (with light-time correction)
     longitudes = {}
     for planet, planet_id in planet_objects.items():
-        # Calculate position (geocentric, apparent, with light-time correction)
-        flags = swe.FLG_SWIEPH | swe.FLG_SPEED
-        xx, _ = swe.calc_ut(jd, planet_id, flags)
-        lon = xx[0]  # ecliptic longitude in degrees
-        longitudes[planet] = lon % 360  # ensure 0-360 range
-
-    # Sort planets by their ecliptic longitude
-    sorted_planets = sorted(longitudes.items(), key=lambda x: x[1])
+        flags = swe.FLG_SWIEPH | swe.FLG_SPEED  # High-precision mode
+        xx, _ = swe.calc_ut(jd_utc, planet_id, flags)
+        lon = xx[0] % 360  # Normalize to 0-360°
+        
+        # Convert to degrees, minutes, seconds (DMS)
+        d = int(lon)
+        m = int((lon - d) * 60)
+        s = round(((lon - d) * 60 - m) * 60)
+        
+        # Handle rounding (e.g., 59.999" → 60" → increment minute)
+        if s >= 60:
+            s -= 60
+            m += 1
+        if m >= 60:
+            m -= 60
+            d += 1
+        
+        longitudes[planet] = f"{d}°{m:02d}'{s:02d}\""
+    
+    # Sort planets by longitude (for PLadder and ZSizes)
+    sorted_planets = sorted(
+        longitudes.items(),
+        key=lambda x: float(x[1].split('°')[0])  # Sort by degrees
+    )
     PLadder = [p for p, _ in sorted_planets]
-    sorted_lons = [lon for _, lon in sorted_planets]
-
-    # Calculate zone sizes (angular distances between consecutive planets)
-    zone_sizes = [sorted_lons[0]] + [sorted_lons[i+1] - sorted_lons[i] for i in range(6)] + [360 - sorted_lons[6]]
-    bordering = [[PLadder[0]]] + [[PLadder[i-1], PLadder[i]] for i in range(1, 7)] + [[PLadder[6]]]
+    sorted_lons = [float(lon.split('°')[0]) for _, lon in sorted_planets]
+    
+    # Calculate zone sizes (angular distances)
+    zone_sizes = (
+        [sorted_lons[0]] +
+        [sorted_lons[i+1] - sorted_lons[i] for i in range(6)] +
+        [360 - sorted_lons[6]]
+    )
+    
+    # Classify zone sizes (with exact DMS)
+    bordering = (
+        [[PLadder[0]]] +
+        [[PLadder[i-1], PLadder[i]] for i in range(1, 7)] +
+        [[PLadder[6]]]
+    )
+    
     ZSizes = []
     for i, size in enumerate(zone_sizes):
         bord = bordering[i]
-        X = 7 if any(p in ['Sun', 'Moon'] for p in bord) else 6 if any(p in ['Mercury', 'Venus', 'Mars'] for p in bord) else 5
-        classification = ('Swallowed' if size <= 1 else 'Tiny' if size <= X else 'Small' if size <= 40 else
-                         'Ideal' if 50 <= size <= 52 else 'Normal' if size < 60 else 'Big')
-        d, m = int(size), int((size - int(size)) * 60)
-        ZSizes.append((f"{d}°{m}'", classification))
-    return {'PLadder': PLadder, 'ZSizes': ZSizes, 'longitudes': longitudes}
+        X = (7 if any(p in ['Sun', 'Moon'] for p in bord)
+            else 6 if any(p in ['Mercury', 'Venus', 'Mars'] for p in bord)
+            else 5)
+        
+        # Exact DMS for zone size
+        d = int(size)
+        m = int((size - d) * 60)
+        s = round(((size - d) * 60 - m) * 60)
+        if s >= 60:
+            s -= 60
+            m += 1
+        if m >= 60:
+            m -= 60
+            d += 1
+        
+        classification = (
+            'Swallowed' if size <= 1 else
+            'Tiny' if size <= X else
+            'Small' if size <= 40 else
+            'Ideal' if 50 <= size <= 52 else
+            'Normal' if size < 60 else
+            'Big'
+        )
+        
+        ZSizes.append((f"{d}°{m:02d}'{s:02d}\"", classification))
+    
+    return {
+        'PLadder': PLadder,
+        'ZSizes': ZSizes,
+        'longitudes': longitudes  # Now in DMS format (e.g., "12°59'55\"")
+    }
 
 def plot_pladder(PLadder):
     fig, ax = plt.subplots()