Update app.py

app.py

@@ -9,158 +9,200 @@ from timezonefinder import TimezoneFinder
 import pytz
 import swisseph as swe
 
+# Constants and Configuration
+swe.set_ephe_path(None)  # Initialize Swiss Ephemeris once at startup
 
 # Russian translations for planets
-planet_ru = {
-    'Sun': 'Солнце', 'Moon': 'Луна', 'Mercury': 'Меркурий', 'Venus': 'Венера',
-    'Mars': 'Марс', 'Jupiter': 'Юпитер', 'Saturn': 'Сатурн'
+PLANET_RU = {
+    'Sun': 'Солнце', 'Moon': 'Луна', 'Mercury': 'Меркурий', 
+    'Venus': 'Венера', 'Mars': 'Марс', 'Jupiter': 'Юпитер', 
+    'Saturn': 'Сатурн'
 }
 
 # Planet symbols for plotting
-planet_symbols = {
+PLANET_SYMBOLS = {
     'Sun': '☉', 'Moon': '☾', 'Mercury': '☿', 'Venus': '♀',
     'Mars': '♂', 'Jupiter': '♃', 'Saturn': '♄'
 }
 
+# Zodiac signs in Russian
+ZODIAC_SIGNS = [
+    "Овен", "Телец", "Близнецы", "Рак", "Лев", "Дева",
+    "Весы", "Скорпион", "Стрелец", "Козерог", "Водолей", "Рыбы"
+]
 
 def parse_query(query):
-    """Parse the query into date, time, and location."""
-    parts = query.split()
-    if len(parts) < 3:
-        return None, None, "Insufficient information."
-    date_str, time_str, *location_parts = parts
-    location = " ".join(location_parts)
+    """
+    Parse the query into date, time, and location.
+    Args:
+        query: String in format "PLadder YYYY-MM-DD HH:MM Location"
+    Returns:
+        tuple: (datetime, location, error_message)
+    """
+    if not query.startswith("PLadder "):
+        return None, None, "Query must start with 'PLadder'"
+    
     try:
+        _, date_str, time_str, *location_parts = query.split(maxsplit=3)
+        location = location_parts[0] if location_parts else ""
         dt = parser.parse(f"{date_str} {time_str}")
         return dt, location, None
-    except ValueError:
-        return None, None, "Invalid date or time format."
+    except ValueError as e:
+        return None, None, f"Invalid format: {str(e)}"
 
 def get_utc_time(dt, location):
-    """Convert local time to UTC using location's time zone."""
-    geolocator = Nominatim(user_agent="pladder")
+    """
+    Convert local time to UTC using location's time zone.
+    Args:
+        dt: Local datetime
+        location: String location
+    Returns:
+        tuple: (utc_dt, lat, lon, error_message)
+    """
+    geolocator = Nominatim(user_agent="pladder_app")
     try:
-        loc = geolocator.geocode(location)
+        loc = geolocator.geocode(location, timeout=10)
         if not loc:
-            return None, None, None, "Location not found."
+            return None, None, None, "Location not found"
+        
         lat, lon = loc.latitude, loc.longitude
-        tf = TimezoneFinder()
-        tz_str = tf.timezone_at(lng=lon, lat=lat)
+        tz_str = TimezoneFinder().timezone_at(lng=lon, lat=lat)
         if not tz_str:
-            return None, None, None, "Time zone not found."
+            return None, None, None, "Time zone not found"
+        
         tz = pytz.timezone(tz_str)
         local_dt = tz.localize(dt)
-        utc_dt = local_dt.astimezone(pytz.utc)
+        utc_dt = local_dt.astimezone(pytz.UTC)
         return utc_dt, lat, lon, None
+    
     except Exception as e:
-        return None, None, None, f"Error: {str(e)}"
+        return None, None, None, f"Geocoding error: {str(e)}"
 
 def format_coords(lat, lon):
-    """Format coordinates as degrees, minutes, seconds."""
-    def dms(value, pos, neg):
-        dir = pos if value >= 0 else neg
-        value = abs(value)
-        d = int(value)
-        m = int((value - d) * 60)
-        s = int(((value - d) * 60 - m) * 60)
-        return f"{d}°{m:02}'{s:02}\" {dir}"
+    """
+    Format coordinates as degrees, minutes, seconds.
+    Args:
+        lat: Latitude in degrees
+        lon: Longitude in degrees
+    Returns:
+        str: Formatted coordinates (e.g., "12°34'56" N, 98°45'32" E")
+    """
+    def dms(value, pos_dir, neg_dir):
+        direction = pos_dir if value >= 0 else neg_dir
+        abs_value = abs(value)
+        degrees = int(abs_value)
+        minutes = int((abs_value - degrees) * 60)
+        seconds = round(((abs_value - degrees) * 60 - minutes) * 60)
+        
+        # Handle rounding overflow
+        if seconds >= 60:
+            seconds -= 60
+            minutes += 1
+        if minutes >= 60:
+            minutes -= 60
+            degrees += 1
+            
+        return f"{degrees}°{minutes:02}'{seconds:02}\" {direction}"
+    
     return f"{dms(lat, 'N', 'S')}, {dms(lon, 'E', 'W')}"
 
-def lon_to_sign(lon):
-    """Convert longitude to zodiac sign format."""
-    signs = ["Овен", "Телец", "Близнецы", "Рак", "Лев", "Дева", 
-             "Весы", "Скорпион", "Стрелец", "Козерог", "Водолей", "Рыбы"]
-    sign_index = int(lon // 30)
-    degrees = int(lon % 30)
-    minutes = int((lon % 1) * 60)
-    return f"{signs[sign_index]} {degrees}°{minutes}'"
+def lon_to_sign(lon_deg):
+    """
+    Convert ecliptic longitude to zodiac sign with position.
+    Args:
+        lon_deg: Longitude in degrees (0-360)
+    Returns:
+        str: Formatted sign and position (e.g., "Лев 12°34'")
+    """
+    sign_idx = int(lon_deg // 30)
+    degrees_in_sign = lon_deg % 30
+    degrees = int(degrees_in_sign)
+    minutes = int((degrees_in_sign - degrees) * 60)
+    
+    # Handle rounding
+    if minutes >= 60:
+        minutes -= 60
+        degrees += 1
+    
+    return f"{ZODIAC_SIGNS[sign_idx]} {degrees}°{minutes:02}'"
 
 def PLadder_ZSizes(utc_dt, lat, lon):
-    """Calculate Planetary Ladder and Zone Sizes using Swiss Ephemeris."""
-    
-    # Updated time range check (Swiss Ephemeris supports -13000 to +17000)
+    """
+    Calculate Planetary Ladder and Zone Sizes using Swiss Ephemeris.
+    Args:
+        utc_dt: UTC datetime
+        lat: Latitude in degrees
+        lon: Longitude in degrees
+    Returns:
+        dict: Contains PLadder, ZSizes, and longitudes
+    """
+    # Validate date range
     if not -13000 <= utc_dt.year <= 17000:
-        return {"error": "Date out of Swiss Ephemeris range (-13,000–17,000 CE)."}
+        return {"error": "Date out of supported 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 = {
+    # Planet mapping with 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 (high precision)
+    # Calculate Julian Day with 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 (with light-time correction)
+    # Calculate planetary positions
     longitudes = {}
-    for planet, planet_id in planet_objects.items():
-        flags = swe.FLG_SWIEPH | swe.FLG_SPEED  # High-precision mode
+    for planet, planet_id in PLANET_OBJECTS.items():
+        flags = swe.FLG_SWIEPH | swe.FLG_SPEED
         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}\""
+        longitudes[planet] = lon
     
-    # Sort planets by longitude (for PLadder and ZSizes)
-    sorted_planets = sorted(
-        longitudes.items(),
-        key=lambda x: float(x[1].split('°')[0])  # Sort by degrees
-    )
+    # Sort planets by longitude
+    sorted_planets = sorted(longitudes.items(), key=lambda x: x[1])
     PLadder = [p for p, _ in sorted_planets]
-    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]]
-    )
+    sorted_lons = [lon for _, lon in sorted_planets]
     
-    # Classify zone sizes (with exact DMS)
-    bordering = (
-        [[PLadder[0]]] +
-        [[PLadder[i-1], PLadder[i]] for i in range(1, 7)] +
-        [[PLadder[6]]]
-    )
+    # Calculate zone sizes
+    zone_sizes = [sorted_lons[0]]  # First zone
+    zone_sizes.extend(sorted_lons[i+1] - sorted_lons[i] for i in range(6))  # Middle zones
+    zone_sizes.append(360 - sorted_lons[-1])  # Last zone
     
+    # Classify zone sizes
     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)
+        # Get bordering planets
+        if i == 0:
+            bord = [PLadder[0]]
+        elif i == len(zone_sizes)-1:
+            bord = [PLadder[-1]]
+        else:
+            bord = [PLadder[i-1], PLadder[i]]
         
-        # Exact DMS for zone size
+        # Determine zone classification
+        if any(p in ['Sun', 'Moon'] for p in bord):
+            X = 7
+        elif any(p in ['Mercury', 'Venus', 'Mars'] for p in bord):
+            X = 6
+        else:
+            X = 5
+            
+        # Format size and classification
         d = int(size)
         m = int((size - d) * 60)
-        s = round(((size - d) * 60 - m) * 60)
+        s = int(round(((size - d) * 60 - m) * 60))
+        
+        # Handle rounding overflow
         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
@@ -170,72 +212,135 @@ def PLadder_ZSizes(utc_dt, lat, lon):
             'Big'
         )
         
-        ZSizes.append((f"{d}°{m:02d}'{s:02d}\"", classification))
+        ZSizes.append((f"{d}°{m:02}'{s:02}\"", classification))
     
     return {
         'PLadder': PLadder,
         'ZSizes': ZSizes,
-        'longitudes': longitudes  # Now in DMS format (e.g., "12°59'55\"")
+        'longitudes': {k: v for k, v in longitudes.items()}  # Raw degrees
     }
 
 def plot_pladder(PLadder):
-    fig, ax = plt.subplots()
-    # Plot the triangle
-    ax.plot([0, 1.5, 3, 0], [0, 3, 0, 0], 'k-')
-    # Plot horizontal lines within the triangle
-    ax.plot([0.5, 2.5], [1, 1], 'k--')
-    ax.plot([1, 2], [2, 2], 'k--')
-    # Define symbol positions outside the triangle
-    positions = [(-0.2,0.2), (0.3,1.2), (0.8,2.2), (1.5,3.2), (2.2,2.2), (2.7,1.2), (3.2,0.2)]
-    # Plot planet symbols
-    for i, (x, y) in enumerate(positions):
-        ax.text(x, y, planet_symbols[PLadder[i]], ha='center', va='center', fontsize=24)
-    # Set plot limits and aesthetics
+    """
+    Generate visualization of the planetary ladder.
+    Args:
+        PLadder: Ordered list of planets
+    Returns:
+        matplotlib Figure
+    """
+    fig, ax = plt.subplots(figsize=(8, 8))
+    
+    # Draw main triangle
+    ax.plot([0, 1.5, 3, 0], [0, 3, 0, 0], 'k-', linewidth=2)
+    
+    # Draw horizontal divisions
+    ax.plot([0.5, 2.5], [1, 1], 'k--', alpha=0.5)
+    ax.plot([1, 2], [2, 2], 'k--', alpha=0.5)
+    
+    # Planet symbol positions
+    symbol_positions = [
+        (-0.2, 0.2), (0.3, 1.2), (0.8, 2.2), 
+        (1.5, 3.2), (2.2, 2.2), (2.7, 1.2), (3.2, 0.2)
+    ]
+    
+    # Add planet symbols
+    for (x, y), planet in zip(symbol_positions, PLadder):
+        ax.text(x, y, PLANET_SYMBOLS[planet], 
+               ha='center', va='center', 
+               fontsize=24, fontweight='bold')
+    
+    # Configure plot appearance
     ax.set_xlim(-0.5, 3.5)
     ax.set_ylim(-0.5, 3.5)
     ax.set_aspect('equal')
     ax.axis('off')
+    plt.tight_layout()
+    
     return fig
 
 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]
-    dt, location, error = parse_query(query_content)
+    """
+    Main processing function for the Gradio interface.
+    Args:
+        query: User input string
+    Returns:
+        tuple: (text_response, image)
+    """
+    # Parse input
+    dt, location, error = parse_query(query)
     if error:
         return error, None
+    
+    # Get UTC time and coordinates
     utc_dt, lat, lon, error = get_utc_time(dt, location)
     if error:
         return error, None
+    
+    # Calculate planetary positions
     result = PLadder_ZSizes(utc_dt, lat, lon)
     if "error" in result:
         return result["error"], None
+    
+    # Format output
     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)])
+    
+    # Generate planet list text
+    planet_list = "\n".join(
+        f"{PLANET_RU[p]}: {lon_to_sign(longitudes[p])}"
+        for p in PLadder
+    )
+    
+    # Generate zone sizes text
+    zones_text = "\n".join(
+        f"Zone {i+1}: {size} ({cls})"
+        for i, (size, cls) in enumerate(ZSizes)
+    )
+    
+    # Generate coordinates text
     coords_text = format_coords(lat, lon)
+    
+    # Create visualization
     fig = plot_pladder(PLadder)
     buf = BytesIO()
-    fig.savefig(buf, format='png', bbox_inches='tight')
+    fig.savefig(buf, format='png', dpi=120, 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
+    
+    # Compose final output
+    output_text = (
+        f"Planetary Ladder:\n{planet_list}\n\n"
+        f"Zone Sizes:\n{zones_text}\n\n"
+        f"Coordinates: {coords_text}\n"
+        f"Calculation Time: {utc_dt.strftime('%Y-%m-%d %H:%M:%S UTC')}"
+    )
+    
+    return output_text, img
 
-# Gradio UI
-with gr.Blocks() as interface:
+# Gradio Interface
+with gr.Blocks(title="Planetary Ladder Calculator") as interface:
+    gr.Markdown("## Planetary Ladder Calculator")
     with gr.Row():
         with gr.Column(scale=2):
-            output_text = gr.Textbox(label="Response", lines=10)
+            output_text = gr.Textbox(label="Astrological Data", lines=12)
         with gr.Column(scale=1):
-            output_image = gr.Image(label="Planetary Ladder Plot")
+            output_image = gr.Image(label="Visualization")
+    with gr.Row():
+        query_text = gr.Textbox(
+            label="Input Query",
+            placeholder="Example: PLadder 2023-10-10 12:00 New York",
+            max_lines=1
+        )
     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 = gr.Button("Calculate", variant="primary")
+    
+    submit_button.click(
+        fn=chat_interface,
+        inputs=query_text,
+        outputs=[output_text, output_image]
+    )
 
-interface.launch()
+if __name__ == "__main__":
+    interface.launch()