Update app.py

app.py

@@ -2,6 +2,7 @@ import gradio as gr
 import matplotlib.pyplot as plt
 from skyfield.api import load, Topos
 from datetime import datetime
+from dateutil import parser
 from io import BytesIO
 from PIL import Image
 from geopy.geocoders import Nominatim
@@ -20,67 +21,51 @@ planet_symbols = {
     'Mars': '♂', 'Jupiter': '♃', 'Saturn': '♄'
 }
 
-def parse_query(query_content):
-    """Parse the query into UTC datetime, latitude, and longitude."""
-    parts = query_content.split()
+def parse_query(query):
+    """Parse the query into date, time, and location."""
+    parts = query.split()
     if len(parts) < 3:
-        return None, None, None, "Insufficient information in query."
-    
-    date_str = parts[0]
-    time_str = parts[1]
-    location_str = " ".join(parts[2:])
-    
-    # Parse local date and time
+        return None, None, "Insufficient information."
+    date_str, time_str, *location_parts = parts
+    location = " ".join(location_parts)
     try:
-        local_dt = datetime.strptime(f"{date_str} {time_str}", "%Y-%m-%d %H:%M")
+        dt = parser.parse(f"{date_str} {time_str}")
+        return dt, location, None
     except ValueError:
-        return None, None, None, "Invalid date or time format."
-    
-    # Geocode location to get latitude and longitude
-    geolocator = Nominatim(user_agent="pladder_app")
+        return None, None, "Invalid date or time format."
+
+def get_utc_time(dt, location):
+    """Convert local time to UTC using location's time zone."""
+    geolocator = Nominatim(user_agent="pladder")
     try:
-        location = geolocator.geocode(location_str)
-        if location is None:
+        loc = geolocator.geocode(location)
+        if not loc:
             return None, None, None, "Location not found."
-        lat, lon = location.latitude, location.longitude
-    except Exception as e:
-        return None, None, None, f"Geocoding error: {str(e)}"
-    
-    # Determine time zone
-    tf = TimezoneFinder()
-    try:
+        lat, lon = loc.latitude, loc.longitude
+        tf = TimezoneFinder()
         tz_str = tf.timezone_at(lng=lon, lat=lat)
-        if tz_str is None:
+        if not tz_str:
             return None, None, None, "Time zone not found."
         tz = pytz.timezone(tz_str)
-    except Exception as e:
-        return None, None, None, f"Time zone determination error: {str(e)}"
-    
-    # Convert local time to UTC
-    try:
-        local_dt = tz.localize(local_dt)
+        local_dt = tz.localize(dt)
         utc_dt = local_dt.astimezone(pytz.utc)
+        return utc_dt, lat, lon, None
     except Exception as e:
-        return None, None, None, f"Time conversion error: {str(e)}"
-    
-    return utc_dt, lat, lon, None
+        return None, None, None, f"Error: {str(e)}"
 
 def format_coords(lat, lon):
-    """Format latitude and longitude as degrees, minutes, seconds."""
-    def format_part(value, pos_dir, neg_dir):
-        direction = pos_dir if value >= 0 else neg_dir
+    """Format coordinates as degrees, minutes, seconds."""
+    def dms(value, pos, neg):
+        dir = pos if value >= 0 else neg
         value = abs(value)
-        degrees = int(value)
-        minutes = int((value - degrees) * 60)
-        seconds = int(((value - degrees) * 60 - minutes) * 60)
-        return f"{degrees}°{minutes:02d}'{seconds:02d}\" {direction}"
-    
-    lat_str = format_part(lat, "N", "S")
-    lon_str = format_part(lon, "E", "W")
-    return f"{lat_str}, {lon_str}"
+        d = int(value)
+        m = int((value - d) * 60)
+        s = int(((value - d) * 60 - m) * 60)
+        return f"{d}°{m:02}'{s:02}\" {dir}"
+    return f"{dms(lat, 'N', 'S')}, {dms(lon, 'E', 'W')}"
 
 def lon_to_sign(lon):
-    """Convert longitude to zodiac sign with degrees and minutes."""
+    """Convert longitude to zodiac sign format."""
     signs = ["Овен", "Телец", "Близнецы", "Рак", "Лев", "Дева", 
              "Весы", "Скорпион", "Стрелец", "Козерог", "Водолей", "Рыбы"]
     sign_index = int(lon // 30)
@@ -90,67 +75,50 @@ def lon_to_sign(lon):
 
 def PLadder_ZSizes(utc_dt, lat, lon):
     """Calculate Planetary Ladder and Zone Sizes."""
-    try:
-        if not 1900 <= utc_dt.year <= 2050:
-            return {"error": "Date out of range (1900–2050)."}
-        
-        planets = load('de421.bsp')
-        earth = planets['earth']
-        observer = earth + Topos(latitude_degrees=lat, longitude_degrees=lon)
-        
-        planet_objects = {
-            'Sun': planets['sun'], 'Moon': planets['moon'], 'Mercury': planets['mercury'],
-            'Venus': planets['venus'], 'Mars': planets['mars'], 
-            'Jupiter': planets['jupiter barycenter'], 'Saturn': planets['saturn barycenter']
-        }
-        
-        ts = load.timescale()
-        t = ts.from_datetime(utc_dt)
-        
-        longitudes = {}
-        for planet, obj in planet_objects.items():
-            astrometric = observer.at(t).observe(obj)
-            _, lon, _ = astrometric.apparent().ecliptic_latlon()
-            longitudes[planet] = lon.degrees
-        
-        sorted_planets = sorted(longitudes.items(), key=lambda x: x[1])
-        PLadder = [p for p, _ in sorted_planets]
-        sorted_lons = [lon for _, lon in sorted_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]]]
-        
-        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}
-    
-    except Exception as e:
-        return {"error": f"Calculation error: {str(e)}"}
+    if not 1900 <= utc_dt.year <= 2050:
+        return {"error": "Date out of range (1900–2050)."}
+    planets = load('de421.bsp')
+    earth = planets['earth']
+    observer = earth + Topos(latitude_degrees=lat, longitude_degrees=lon)
+    planet_objects = {
+        'Sun': planets['sun'], 'Moon': planets['moon'], 'Mercury': planets['mercury'],
+        'Venus': planets['venus'], 'Mars': planets['mars'], 
+        'Jupiter': planets['jupiter barycenter'], 'Saturn': planets['saturn barycenter']
+    }
+    ts = load.timescale()
+    t = ts.from_datetime(utc_dt)
+    longitudes = {}
+    for planet, obj in planet_objects.items():
+        astrometric = observer.at(t).observe(obj)
+        _, lon, _ = astrometric.apparent().ecliptic_latlon()
+        longitudes[planet] = lon.degrees
+    sorted_planets = sorted(longitudes.items(), key=lambda x: x[1])
+    PLadder = [p for p, _ in sorted_planets]
+    sorted_lons = [lon for _, lon in sorted_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]]]
+    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}
 
 def plot_pladder(PLadder):
-    """Plot the Planetary Ladder with adjusted symbol positions and horizontal lines."""
+    """Plot the Planetary Ladder with symbols outside the triangle."""
     fig, ax = plt.subplots()
-    # Triangle boundaries
-    ax.plot([0, 1.5, 3, 0], [0, 3, 0, 0], 'k-')
+    # Plot triangle
+    ax.plot([0, 0, 3, 0], [0, 3, 0, 0], 'k-')
     # Horizontal lines within triangle
-    ax.plot([0.5, 2.5], [1, 1], 'k--')
-    ax.plot([1, 2], [2, 2], 'k--')
-    # Planet symbol positions, offset ~0.2 units from triangle sides
+    ax.plot([0, 2], [1, 1], 'k--')
+    ax.plot([0, 1], [2, 2], 'k--')
+    # Symbol positions outside the triangle
     positions = [
-        (0.575, 0.75),  # Left side
-        (0.95, 1.5),
-        (1.325, 2.25),
-        (1.5, 2.7),     # Top
-        (1.675, 2.25),  # Right side
-        (2.05, 1.5),
-        (2.425, 0.75)
+        (-0.2, 0), (-0.2, 1), (-0.2, 2), (-0.2, 3),  # Symbols 1 to 4
+        (1.2, 2.2), (2.2, 1.2), (3.2, 0.2)           # Symbols 5 to 7
     ]
     for i, (x, y) in enumerate(positions):
         ax.text(x, y, planet_symbols[PLadder[i]], ha='center', va='center', fontsize=24)
@@ -164,35 +132,32 @@ def chat_interface(query):
     """Process the user query and return text and plot."""
     if not query.startswith("PLadder "):
         return "Query must start with 'PLadder' followed by date, time, and location.", None
-    
     query_content = query.split(" ", 1)[1]
-    utc_dt, lat, lon, error = parse_query(query_content)
+    dt, location, error = parse_query(query_content)
+    if error:
+        return error, None
+    utc_dt, lat, lon, error = get_utc_time(dt, location)
     if error:
         return error, None
-    
     result = PLadder_ZSizes(utc_dt, lat, lon)
     if "error" in result:
         return result["error"], None
-    
     PLadder = result["PLadder"]
     ZSizes = result["ZSizes"]
     longitudes = result["longitudes"]
-    
     planet_list = "\n".join([f"{planet_ru[p]}: {lon_to_sign(longitudes[p])}" for p in PLadder])
     zones_text = "\n".join([f"Zone {i+1}: {size} ({cls})" for i, (size, cls) in enumerate(ZSizes)])
     coords_text = format_coords(lat, lon)
-    
     fig = plot_pladder(PLadder)
     buf = BytesIO()
     fig.savefig(buf, format='png', bbox_inches='tight')
     buf.seek(0)
     img = Image.open(buf)
     plt.close(fig)
-    
     text = f"Planetary Ladder:\n{planet_list}\n\nZone Sizes:\n{zones_text}\n\nCoordinates: {coords_text}"
     return text, img
 
-# Gradio UI with a single query field
+# Gradio UI
 with gr.Blocks() as interface:
     with gr.Row():
         with gr.Column(scale=2):
@@ -202,11 +167,6 @@ with gr.Blocks() as interface:
     with gr.Row():
         query_text = gr.Textbox(label="Query", placeholder="Example: PLadder 2023-10-10 12:00 New York")
         submit_button = gr.Button("Submit")
-    
-    submit_button.click(
-        fn=chat_interface,
-        inputs=query_text,
-        outputs=[output_text, output_image]
-    )
+    submit_button.click(fn=chat_interface, inputs=query_text, outputs=[output_text, output_image])
 
 interface.launch()