Update app.py

app.py

@@ -9,14 +9,14 @@ from timezonefinder import TimezoneFinder
 import pytz
 import swisseph as swe
 
-# Constants and Configuration
-swe.set_ephe_path(None)  # Initialize Swiss Ephemeris once at startup
+# Initialize Swiss Ephemeris
+swe.set_ephe_path(None)
 
 # Russian translations for planets
 PLANET_RU = {
-    'Sun': 'Солнце', 'Moon': 'Луна', 'Mercury': 'Меркурий', 
-    'Venus': 'Венера', 'Mars': 'Марс', 'Jupiter': 'Юпитер', 
-    'Saturn': 'Сатурн'
+    'Sun': 'Солнце', 'Moon': 'Луна', 'Mercury': 'Меркурий',
+    'Venus': 'Венера', 'Mars': 'Марс', 
+    'Jupiter': 'Юпитер', 'Saturn': 'Сатурн'
 }
 
 # Planet symbols for plotting
@@ -32,33 +32,23 @@ ZODIAC_SIGNS = [
 ]
 
 def parse_query(query):
-    """
-    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)
-    """
+    """Parse the query into date, time, and location."""
     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 ""
+        parts = query.split(maxsplit=3)
+        if len(parts) < 4:
+            return None, None, "Incomplete query (need date, time, and location)"
+        
+        _, date_str, time_str, location = parts
         dt = parser.parse(f"{date_str} {time_str}")
         return dt, location, None
     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.
-    Args:
-        dt: Local datetime
-        location: String location
-    Returns:
-        tuple: (utc_dt, lat, lon, error_message)
-    """
+    """Convert local time to UTC using location's time zone."""
     geolocator = Nominatim(user_agent="pladder_app")
     try:
         loc = geolocator.geocode(location, timeout=10)
@@ -74,25 +64,17 @@ def get_utc_time(dt, location):
         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"Geocoding error: {str(e)}"
+        return None, None, None, f"Error: {str(e)}"
 
 def format_coords(lat, lon):
-    """
-    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")
-    """
+    """Format coordinates as degrees, minutes, seconds."""
     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)
+        seconds = int(round(((abs_value - degrees) * 60 - minutes) * 60)
         
         # Handle rounding overflow
         if seconds >= 60:
@@ -109,34 +91,26 @@ def format_coords(lat, lon):
 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'")
+    Now includes seconds in the output.
     """
     sign_idx = int(lon_deg // 30)
     degrees_in_sign = lon_deg % 30
     degrees = int(degrees_in_sign)
     minutes = int((degrees_in_sign - degrees) * 60)
+    seconds = int(round(((degrees_in_sign - degrees) * 60 - minutes) * 60)
     
-    # Handle rounding
+    # Handle rounding overflow
+    if seconds >= 60:
+        seconds -= 60
+        minutes += 1
     if minutes >= 60:
         minutes -= 60
         degrees += 1
     
-    return f"{ZODIAC_SIGNS[sign_idx]} {degrees}°{minutes:02}'"
+    return f"{ZODIAC_SIGNS[sign_idx]} {degrees}°{minutes:02}'{seconds:02}\""
 
 def PLadder_ZSizes(utc_dt, lat, lon):
-    """
-    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
+    """Calculate Planetary Ladder and Zone Sizes using Swiss Ephemeris."""
     if not -13000 <= utc_dt.year <= 17000:
         return {"error": "Date out of supported range (-13,000–17,000 CE)"}
     
@@ -147,7 +121,7 @@ def PLadder_ZSizes(utc_dt, lat, lon):
         'Jupiter': swe.JUPITER, 'Saturn': swe.SATURN
     }
     
-    # Calculate Julian Day with high precision
+    # Calculate Julian Day
     jd_utc = swe.julday(
         utc_dt.year, utc_dt.month, utc_dt.day,
         utc_dt.hour + utc_dt.minute/60 + utc_dt.second/3600
@@ -190,7 +164,7 @@ def PLadder_ZSizes(utc_dt, lat, lon):
         else:
             X = 5
             
-        # Format size and classification
+        # Format size with seconds
         d = int(size)
         m = int((size - d) * 60)
         s = int(round(((size - d) * 60 - m) * 60))
@@ -217,29 +191,23 @@ def PLadder_ZSizes(utc_dt, lat, lon):
     return {
         'PLadder': PLadder,
         'ZSizes': ZSizes,
-        'longitudes': {k: v for k, v in longitudes.items()}  # Raw degrees
+        'longitudes': longitudes  # Raw degrees for calculations
     }
 
 def plot_pladder(PLadder):
-    """
-    Generate visualization of the planetary ladder.
-    Args:
-        PLadder: Ordered list of planets
-    Returns:
-        matplotlib Figure
-    """
-    fig, ax = plt.subplots(figsize=(8, 8))
+    """Generate the original version of the planetary ladder visualization."""
+    fig, ax = plt.subplots(figsize=(6, 6))
     
-    # Draw main triangle
+    # Draw the 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)
+    # Draw horizontal divisions (original style)
+    ax.plot([0.5, 2.5], [1, 1], 'k--')
+    ax.plot([1, 2], [2, 2], 'k--')
     
-    # Planet symbol positions
+    # Original planet symbol positions
     symbol_positions = [
-        (-0.2, 0.2), (0.3, 1.2), (0.8, 2.2), 
+        (-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)
     ]
     
@@ -247,25 +215,18 @@ def plot_pladder(PLadder):
     for (x, y), planet in zip(symbol_positions, PLadder):
         ax.text(x, y, PLANET_SYMBOLS[planet], 
                ha='center', va='center', 
-               fontsize=24, fontweight='bold')
+               fontsize=24)
     
-    # Configure plot appearance
+    # Configure plot appearance (original style)
     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):
-    """
-    Main processing function for the Gradio interface.
-    Args:
-        query: User input string
-    Returns:
-        tuple: (text_response, image)
-    """
+    """Process the user query and return text and plot."""
     # Parse input
     dt, location, error = parse_query(query)
     if error:
@@ -286,7 +247,7 @@ def chat_interface(query):
     ZSizes = result["ZSizes"]
     longitudes = result["longitudes"]
     
-    # Generate planet list text
+    # Generate planet list text with full DMS
     planet_list = "\n".join(
         f"{PLANET_RU[p]}: {lon_to_sign(longitudes[p])}"
         for p in PLadder
@@ -301,7 +262,7 @@ def chat_interface(query):
     # Generate coordinates text
     coords_text = format_coords(lat, lon)
     
-    # Create visualization
+    # Create visualization (original style)
     fig = plot_pladder(PLadder)
     buf = BytesIO()
     fig.savefig(buf, format='png', dpi=120, bbox_inches='tight')