Update app.py

app.py

@@ -2,7 +2,6 @@ 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
@@ -21,12 +20,67 @@ planet_symbols = {
     'Mars': '♂', 'Jupiter': '♃', 'Saturn': '♄'
 }
 
-# Initialize geolocator and timezone finder
-geolocator = Nominatim(user_agent="pladder_app")
-tf = TimezoneFinder()
+def parse_query(query_content):
+    """Parse the query into UTC datetime, latitude, and longitude."""
+    parts = query_content.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
+    try:
+        local_dt = datetime.strptime(f"{date_str} {time_str}", "%Y-%m-%d %H:%M")
+    except ValueError:
+        return None, None, None, "Invalid date or time format."
+    
+    # Geocode location to get latitude and longitude
+    geolocator = Nominatim(user_agent="pladder_app")
+    try:
+        location = geolocator.geocode(location_str)
+        if location is None:
+            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:
+        tz_str = tf.timezone_at(lng=lon, lat=lat)
+        if tz_str is None:
+            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)
+        utc_dt = local_dt.astimezone(pytz.utc)
+    except Exception as e:
+        return None, None, None, f"Time conversion error: {str(e)}"
+    
+    return utc_dt, lat, lon, None
+
+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
+        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}"
 
-# Function to convert longitude to zodiac sign and degrees
 def lon_to_sign(lon):
+    """Convert longitude to zodiac sign with degrees and minutes."""
     signs = ["Овен", "Телец", "Близнецы", "Рак", "Лев", "Дева", 
              "Весы", "Скорпион", "Стрелец", "Козерог", "Водолей", "Рыбы"]
     sign_index = int(lon // 30)
@@ -34,16 +88,15 @@ def lon_to_sign(lon):
     minutes = int((lon % 1) * 60)
     return f"{signs[sign_index]} {degrees}°{minutes}'"
 
-# Function to calculate PLadder and zone sizes (unchanged)
-def PLadder_ZSizes(date_time_iso, lat, lon):
+def PLadder_ZSizes(utc_dt, lat, lon):
+    """Calculate Planetary Ladder and Zone Sizes."""
     try:
-        dt = datetime.fromisoformat(date_time_iso)
-        if not 1900 <= dt.year <= 2050:
-            return {"error": "Дата вне диапазона (1900–2050)."}
+        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=float(lat), longitude_degrees=float(lon))
+        observer = earth + Topos(latitude_degrees=lat, longitude_degrees=lon)
         
         planet_objects = {
             'Sun': planets['sun'], 'Moon': planets['moon'], 'Mercury': planets['mercury'],
@@ -52,7 +105,7 @@ def PLadder_ZSizes(date_time_iso, lat, lon):
         }
         
         ts = load.timescale()
-        t = ts.utc(dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second)
+        t = ts.from_datetime(utc_dt)
         
         longitudes = {}
         for planet, obj in planet_objects.items():
@@ -78,18 +131,27 @@ def PLadder_ZSizes(date_time_iso, lat, lon):
         
         return {'PLadder': PLadder, 'ZSizes': ZSizes, 'longitudes': longitudes}
     
-    except ValueError:
-        return {"error": "Неверный формат даты и времени."}
     except Exception as e:
-        return {"error": f"Ошибка: {str(e)}"}
+        return {"error": f"Calculation error: {str(e)}"}
 
-# Function to plot the planetary ladder (unchanged)
 def plot_pladder(PLadder):
+    """Plot the Planetary Ladder with adjusted symbol positions and horizontal lines."""
     fig, ax = plt.subplots()
-    ax.plot([0, 1.5, 3, 0], [0, 3, 0, 0], 'k-')  # Triangle
-    ax.plot([0, 3], [1, 1], 'k--')  # Horizontal lines
-    ax.plot([0, 3], [2, 2], 'k--')
-    positions = [(0.2, 0.2), (0.2, 1.2), (0.2, 2.2), (1.5, 3.2), (2.8, 2.2), (2.8, 1.2), (2.8, 0.2)]
+    # Triangle boundaries
+    ax.plot([0, 1.5, 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
+    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)
+    ]
     for i, (x, y) in enumerate(positions):
         ax.text(x, y, planet_symbols[PLadder[i]], ha='center', va='center', fontsize=24)
     ax.set_xlim(-0.5, 3.5)
@@ -98,63 +160,28 @@ def plot_pladder(PLadder):
     ax.axis('off')
     return fig
 
-# Main interface function (reworked)
 def chat_interface(query):
-    # Check for valid command
+    """Process the user query and return text and plot."""
     if not query.startswith("PLadder "):
-        return "Запрос должен начинаться с 'PLadder' и содержать дату, время и местоположение.", None
+        return "Query must start with 'PLadder' followed by date, time, and location.", None
     
-    # Extract date, time, and location
-    query_rest = query[len("PLadder "):]
-    try:
-        parsed_dt, skipped = parser.parse(query_rest, fuzzy_with_tokens=True)
-        location = " ".join(skipped)
-        if not location:
-            return "Укажите местоположение (город или населённый пункт).", None
-    except ValueError:
-        return "Неверный формат даты и времени.", None
+    query_content = query.split(" ", 1)[1]
+    utc_dt, lat, lon, error = parse_query(query_content)
+    if error:
+        return error, None
     
-    # Geocode the location to get latitude and longitude
-    try:
-        location_data = geolocator.geocode(location)
-        if location_data:
-            lat = location_data.latitude
-            lon = location_data.longitude
-        else:
-            return f"Не удалось найти координаты для '{location}'.", None
-    except Exception as e:
-        return f"Ошибка геокодирования: {str(e)}", None
-    
-    # Determine time zone from coordinates
-    tz_name = tf.timezone_at(lng=lon, lat=lat)
-    if tz_name is None:
-        return f"Не удалось определить часовой пояс для '{location}'.", None
-    tz = pytz.timezone(tz_name)
-    
-    # Localize the parsed local time and convert to UTC
-    try:
-        timezone_aware_dt = tz.localize(parsed_dt)
-    except pytz.exceptions.AmbiguousTimeError:
-        # Handle ambiguous times (e.g., DST transitions) by defaulting to standard time
-        timezone_aware_dt = tz.localize(parsed_dt, is_dst=False)
-    utc_dt = timezone_aware_dt.astimezone(pytz.utc)
-    date_time_iso = utc_dt.isoformat()
-    
-    # Pass UTC time and coordinates to PLadder_ZSizes
-    result = PLadder_ZSizes(date_time_iso, str(lat), str(lon))
+    result = PLadder_ZSizes(utc_dt, lat, lon)
     if "error" in result:
         return result["error"], None
     
-    # Extract results
     PLadder = result["PLadder"]
     ZSizes = result["ZSizes"]
     longitudes = result["longitudes"]
     
-    # Format output text
     planet_list = "\n".join([f"{planet_ru[p]}: {lon_to_sign(longitudes[p])}" for p in PLadder])
-    zones_text = "\n".join([f"Зона {i+1}: {size} ({cls})" for i, (size, cls) in enumerate(ZSizes)])
+    zones_text = "\n".join([f"Zone {i+1}: {size} ({cls})" for i, (size, cls) in enumerate(ZSizes)])
+    coords_text = format_coords(lat, lon)
     
-    # Generate plot
     fig = plot_pladder(PLadder)
     buf = BytesIO()
     fig.savefig(buf, format='png', bbox_inches='tight')
@@ -162,19 +189,19 @@ def chat_interface(query):
     img = Image.open(buf)
     plt.close(fig)
     
-    # Combine text output
-    text = f"Планетарная лестница:\n{planet_list}\n\nРазмеры зон:\n{zones_text}"
+    text = f"Planetary Ladder:\n{planet_list}\n\nZone Sizes:\n{zones_text}\n\nCoordinates: {coords_text}"
     return text, img
 
-# Gradio UI (reworked for single query field)
+# Gradio UI with a single query field
 with gr.Blocks() as interface:
-    query_text = gr.Textbox(label="Запрос", placeholder="Пример: PLadder 2023-10-10 12:00 New York")
-    submit_button = gr.Button("Отправить")
     with gr.Row():
         with gr.Column(scale=2):
-            output_text = gr.Textbox(label="Ответ", lines=10)
+            output_text = gr.Textbox(label="Response", lines=10)
         with gr.Column(scale=1):
-            output_image = gr.Image(label="График планетарной лестницы")
+            output_image = gr.Image(label="Planetary Ladder Plot")
+    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,