Update app.py

app.py

@@ -1,500 +1,153 @@
-from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, load_tool, tool
-import smolagents  # Added for aliasing
-# from smolagents.security import E2BSandbox 
-import datetime
-import pytz
-import yaml
-from skyfield.api import load, Topos, load_file
-from skyfield import almanac
-from tools.final_answer import FinalAnswerTool
-from Gradio_UI import GradioUI
-import os
-import base64
-
-# Add the alias before instrumentation
-smolagents.ApiModel = smolagents.HfApiModel
-
-LANGFUSE_PUBLIC_KEY="pk-lf-133099c7-8644-49e8-8f6e-ec8bd6d543fd"
-LF_SECRET_KEY = os.environ["LANGFUSE_SECRET_KEY"]
-LANGFUSE_AUTH=base64.b64encode(f"{LANGFUSE_PUBLIC_KEY}:{LF_SECRET_KEY}".encode()).decode()
-
-os.environ["OTEL_EXPORTER_OTLP_ENDPOINT"] = "https://cloud.langfuse.com/api/public/otel" # EU data region
-# os.environ["OTEL_EXPORTER_OTLP_ENDPOINT"] = "https://us.cloud.langfuse.com/api/public/otel" # US data region
-os.environ["OTEL_EXPORTER_OTLP_HEADERS"] = f"Authorization=Basic {LANGFUSE_AUTH}"
-
-from opentelemetry.sdk.trace import TracerProvider
-from openinference.instrumentation.smolagents import SmolagentsInstrumentor
-from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
-from opentelemetry.sdk.trace.export import SimpleSpanProcessor
-
-trace_provider = TracerProvider()
-trace_provider.add_span_processor(SimpleSpanProcessor(OTLPSpanExporter()))
-
-SmolagentsInstrumentor().instrument(tracer_provider=trace_provider)
-
-# Load ephemeris and timescale
-planets = load('https://naif.jpl.nasa.gov/pub/naif/generic_kernels/spk/planets/de440.bsp')
-ts = load.timescale()
-
-# Define Zodiac signs and their boundaries (0° to 360° ecliptic longitude)
-ZODIAC_SIGNS = [
-    ("Aries", 0, 30),
-    ("Taurus", 30, 60),
-    ("Gemini", 60, 90),
-    ("Cancer", 90, 120),
-    ("Leo", 120, 150),
-    ("Virgo"
-, 150, 180),
-    ("Libra", 180, 210),
-    ("Scorpio", 210, 240),
-    ("Sagittarius", 240, 270),
-    ("Capricorn", 270, 300),
-    ("Aquarius", 300, 330),
-    ("Pisces", 330, 360),
-]
-
-# Moon phase boundaries (0° to 360° phase angle) for display purposes
-MOON_PHASES = [
-    ("New Moon", 0, 45),
-    ("Waxing Crescent", 45, 90),
-    ("First Quarter", 90, 135),
-    ("Waxing Gibbous", 135, 180),
-    ("Full Moon", 180, 225),
-    ("Waning Gibbous", 225, 270),
-    ("Last Quarter", 270, 315),
-    ("Waning Crescent", 315, 360),
-]
-
-# Fertility sign coefficients (applicable to all plants)
-FERTILITY_SIGN_COEFFS = {
-    "Aries": 1,
-    "Taurus": 2,
-    "Gemini": 0,
-    "Cancer": 2,
-    "Leo": 1,
-    "Virgo": 0,
-    "Libra": 0.5,
-    "Scorpio": 1.5,
-    "Sagittarius": 1,
-    "Capricorn": 1,
-    "Aquarius": 0,
-    "Pisces": 2,
-}
-
-# Pruning sign coefficients (applicable to all plants)
-PRUNING_SIGN_COEFFS = {
-    "Aries": 1,
-    "Taurus": 0,
-    "Gemini": 2,
-    "Cancer": 0,
-    "Leo": 1,
-    "Virgo": 2,
-    "Libra": 1.5,
-    "Scorpio": 0.5,
-    "Sagittarius": 1,
-    "Capricorn": 1,
-    "Aquarius": 2,
-    "Pisces": 0,
-}
-
-# Fertility phase coefficients for above-ground plants
-FERTILITY_PHASE_COEFFS_ABOVE = {
-    "New Moon": 0,
-    "Waxing Moon": 1,
-    "Full Moon": 0,
-    "Waning Moon": 0.5,
-}
-
-# Fertility phase coefficients for root crops
-FERTILITY_PHASE_COEFFS_ROOT = {
-    "New Moon": 0,
-    "Waxing Moon": 0.5,
-    "Full Moon": 0,
-    "Waning Moon": 1,
-}
-
-# Pruning phase coefficients
-PRUNING_PHASE_COEFFS = {
-    "New Moon": 0,
-    "Waxing Moon": 1,
-    "Full Moon": 0,
-    "Waning Moon": 0.5,
-}
-
-# Translation dictionaries
-classification_ru = {
-    'Swallowed': 'проглоченная',
-    'Tiny': 'сверхмалая',
-    'Small': 'малая',
-    'Normal': 'нормальная',
-    'Ideal': 'идеальная',
-    'Big': 'большая'
-}
-
+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
+
+# Russian translations for planets
 planet_ru = {
-    'Sun': 'Солнце',
-    'Moon': 'Луна',
-    'Mercury': 'Меркурий',
-    'Venus': 'Венера',
-    'Mars': 'Марс',
-    'Jupiter': 'Юпитер',
-    'Saturn': 'Сатурн'
+    'Sun': 'Солнце', 'Moon': 'Луна', 'Mercury': 'Меркурий', 'Venus': 'Венера',
+    'Mars': 'Марс', 'Jupiter': 'Юпитер', 'Saturn': 'Сатурн'
 }
 
+# Planet symbols for plotting
 planet_symbols = {
-    'Sun': '☉',
-    'Moon': '☾',
-    'Mercury': '☿',
-    'Venus': '♀',
-    'Mars': '♂',
-    'Jupiter': '♃',
-    'Saturn': '♄'
+    'Sun': '☉', 'Moon': '☾', 'Mercury': '☿', 'Venus': '♀',
+    'Mars': '♂', 'Jupiter': '♃', 'Saturn': '♄'
 }
 
-
-
-@tool
-def get_moon_info(date_time: str) -> dict:
-    """
-    Returns Moon's Zodiac position, phase, and fertility and pruning indices for the given date/time.
-    
-    The fertility and pruning indices are calculated as sum of sign and phase fertility values of the Moon position. Moon sign fertility
-        amounts up to 2.0 value and phase fertility value could be 1.0 max.
-        It is observed that when Moon is in different Zodiac signs, the fertility of new plants and impact of pruning differs.
-        When Moon is in fertile sign the plant is in the active phase, when all processes are particularly intense, and any intervention 
-        such as pruning can be very traumatic for the plant. Here:
-            Most fertile signs: Taurus, Pisces, Cancer - Plants are in the active growth phase, juices and nutrients actively circulate 
-                in the plant, and it is best time for fertilizers, harvasting cutting, vaccination, rooting. 
-            Conditionally fertile: Scorpio
-            Neutral: Aries, Leo, Sagittarius, Capricorn
-            Conditionally sterile: Libra
-            Sterile: Gemini, Virgo, Aquarius
-        
-        Fertility indices ranges from 0.0 to 3.0 where proportionaly
-            0 - minimal expected fertility
-            3.0 - most favorable fertility for platining, 
-        and depends on type of plant (root crop or produce above ground).
-        
-        Pruning indices ranges from 0 to 3 where proportionaly:
-            0 - pruning is not recommended as it causes most damage to tree and can lead to:
-                    Increased sap production from the cut points
-                    Increased vulnerability to infections
-                    Delayed wound healing
-                    Possible weakening of the plant.
-                Instead of pruning into fertile signs, you can do:
-                    Crown formation
-                    Pinching the shoots
-                    Removing dead branches
-                    Sanitary treatment
-            1.0 - pruning is not recommended,
-            2.0 - allowed only minimum or sanitary pruning,
-            3.0 - most favorable time for pruning.
-
-    Args:
-        date_time (str): ISO 8601 formatted datetime (YYYY-MM-DDTHH:MM:SS)
-
-    Returns:
-        dict: {
-            "zodiac_position": "Leo 15°30'",
-            "moon_phase": "Waxing Gibbous",
-            "fertility_above_ground": 2.0,
-            "fertility_root_crop": 1.5,
-            "pruning": 2.0
-        }
-    """
-    try:
-        # Parse input datetime and localize to UTC
-        user_time = datetime.datetime.strptime(date_time, "%Y-%m-%dT%H:%M:%S")
-        user_time = pytz.utc.localize(user_time)
-
-        # Use loaded ephemeris and timescale
-        t = ts.from_datetime(user_time)
-
-        # Define celestial bodies
-        earth = planets['earth']
-        moon = planets['moon']
-        sun = planets['sun']
-
-# Calculate Moon's ecliptic longitude
-        astrometric = earth.at(t).observe(moon)
-        ecliptic_lat, ecliptic_lon, distance = astrometric.ecliptic_latlon()
-        lon_deg = ecliptic_lon.degrees % 360
-
-        # Calculate the phase angle using almanac.moon_phase
-        phase = almanac.moon_phase(planets, t)
-        phase_angle = phase.degrees
-
-        # Determine Zodiac sign and position
-        zodiac_sign = "Unknown"
-        position_degrees = 0
-        for sign, start, end in ZODIAC_SIGNS:
-            if start <= lon_deg < end:
-                zodiac_sign = sign
-                position_degrees = lon_deg - start
-                break
-
-        # Format position to degrees and minutes
-        degrees = int(position_degrees)
-        minutes = int((position_degrees % 1) * 60)
-        position_str = f"{zodiac_sign} {degrees}°{minutes:02}'"
-
-        # Determine moon phase for display
-        moon_phase = "Unknown"
-        for phase, start, end in MOON_PHASES:
-            if start <= phase_angle < end:
-                moon_phase = phase
-                break
-
-        # Determine phase category for indices with 15° orbis for New and Full Moon
-        if (phase_angle >= 345 or phase_angle < 15):
-            phase_category = "New Moon"  # 345° to 15° (30° total orbis)
-        elif 15 <= phase_angle < 165:
-            phase_category = "Waxing Moon"
-        elif 165 <= phase_angle < 195:
-            phase_category = "Full Moon"  # 165° to 195° (30° total orbis)
-        elif 195 <= phase_angle < 345:
-            phase_category = "Waning Moon"
-        else:
-            phase_category = "Unknown"
-
-        # Calculate fertility and pruning indices
-        if zodiac_sign in FERTILITY_SIGN_COEFFS and phase_category in FERTILITY_PHASE_COEFFS_ABOVE:
-            fertility_above_ground = FERTILITY_SIGN_COEFFS[zodiac_sign] + FERTILITY_PHASE_COEFFS_ABOVE[phase_category]
-            fertility_root_crop = FERTILITY_SIGN_COEFFS[zodiac_sign] + FERTILITY_PHASE_COEFFS_ROOT[phase_category]
-            pruning = PRUNING_SIGN_COEFFS[zodiac_sign] + PRUNING_PHASE_COEFFS[phase_category]
-        else:
-            fertility_above_ground = None
-            fertility_root_crop = None
-            pruning = None
-
-        return {
-            "zodiac_position": position_str,
-            "moon_phase": moon_phase,
-            "fertility_above_ground": fertility_above_ground,
-            "fertility_root_crop": fertility_root_crop,
-            "pruning": pruning
-        }
-
-    except Exception as e:
-        raise ValueError(f"Error in get_moon_info: {str(e)}")
-
-@tool
-def get_current_time_in_timezone(timezone: str) -> str:
-    """
-    Returns the current local time in the specified timezone with description.
-
-    Args:
-        timezone (str): A string representing a valid timezone (e.g., 'UTC')
-
-
-    Returns:
-        str: Formatted local time with timezone description
-    """
-    try:
-        tz = pytz.timezone(timezone)
-        now = datetime.datetime.now(tz)
-        return f"Local time in {timezone}: {now.strftime('%Y-%m-%d %H:%M:%S')}"
-    except Exception as e:
-        return f"Error: {str(e)}"
-
-@tool
-def get_current_time_raw(timezone: str) -> str:
-    """
-    Returns current local time in specified timezone as ISO 8601 string.
-
-    Args:
-        timezone (str): A string representing a valid timezone (e.g., 'UTC')
-
-    Returns:
-        str: Datetime in ISO 8601 format (YYYY-MM-DDTHH:MM:SS)
-    """
+# Parse date-time into ISO format
+def parse_date_time(date_time_str):
     try:
-        tz = pytz.timezone(timezone)
-        now = datetime.datetime.now(tz)
-        return now.strftime("%Y-%m-%dT%H:%M:%S")
-    except Exception as e:
-        return f"Error: {str(e)}"
+        dt = parser.parse(date_time_str)
+        return dt.isoformat()
+    except ValueError:
+        return None
 
-# Model configuration
-final_answer = FinalAnswerTool()
-model = HfApiModel(
-    max_tokens=2096,
-    temperature=0.5,
-    model_id="https://pflgm2locj2t89co.us-east-1.aws.endpoints.huggingface.cloud/",
-    custom_role_conversions=None,
-)
+# Convert longitude to zodiac sign and degrees
+def lon_to_sign(lon):
+    signs = ["Овен", "Телец", "Близнецы", "Рак", "Лев", "Дева", 
+             "Весы", "Скорпион", "Стрелец", "Козерог", "Водолей", "Рыбы"]
+    sign_index = int(lon // 30)
+    degrees = int(lon % 30)
+    minutes = int((lon % 1) * 60)
+    return f"{signs[sign_index]} {degrees}°{minutes}'"
 
-# Function to calculate PLadder and zone sizes
-@tool
-def PLadder_ZSizes(date_time_iso: str):
-    """
-    Calculate the planetary ladder and zone sizes for a given date and time.
-    
-    Args:
-        date_time_iso (str): Date and time in ISO format (e.g., '2023-10-10T12:00:00')
-    
-    Returns:
-        dict: Contains 'PLadder' (list of planets) and 'ZSizes' (list of zone sizes with classifications)
-              or an error message if unsuccessful
-    """
+# Calculate PLadder and zone sizes
+def PLadder_ZSizes(date_time_iso, lat, lon):
     try:
         dt = datetime.fromisoformat(date_time_iso)
-        if dt.year < 1900 or dt.year > 2050:
-            return {"error": "Дата вне диапазона. Должна быть между 1900 и 2050 годами."}
+        if not 1900 <= dt.year <= 2050:
+            return {"error": "Дата вне диапазона (1900–2050)."}
         
-        # Load ephemeris
         planets = load('de421.bsp')
         earth = planets['earth']
+        observer = earth + Topos(latitude_degrees=float(lat), longitude_degrees=float(lon))
         
-        # Define planet objects
         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']
+            'Sun': planets['sun'], 'Moon': planets['moon'], 'Mercury': planets['mercury'],
+            'Venus': planets['venus'], 'Mars': planets['mars'], 
+            'Jupiter': planets['jupiter barycenter'], 'Saturn': planets['saturn barycenter']
         }
         
-        # Create time object
         ts = load.timescale()
         t = ts.utc(dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second)
         
-        # Compute ecliptic longitudes
         longitudes = {}
-        for planet in planet_objects:
-            apparent = earth.at(t).observe(planet_objects[planet]).apparent()
-            _, lon, _ = apparent.ecliptic_latlon()
+        for planet, obj in planet_objects.items():
+            astrometric = observer.at(t).observe(obj)
+            _, lon, _ = astrometric.apparent().ecliptic_latlon()
             longitudes[planet] = lon.degrees
         
-        # Sort planets by longitude to form PLadder
         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]
         
-        # Calculate zone sizes
         zone_sizes = [sorted_lons[0]] + [sorted_lons[i+1] - sorted_lons[i] for i in range(6)] + [360 - sorted_lons[6]]
-        
-        # Determine bordering planets for classification
         bordering = [[PLadder[0]]] + [[PLadder[i-1], PLadder[i]] for i in range(1, 7)] + [[PLadder[6]]]
         
-        # Classify each zone
         ZSizes = []
         for i, size in enumerate(zone_sizes):
             bord = bordering[i]
-            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
-            
-            if size <= 1:
-                classification = 'Swallowed'
-            elif size <= X:
-                classification = 'Tiny'
-            elif size <= 40:
-                classification = 'Small'
-            elif size < 60:
-                if 50 <= size <= 52:
-                    classification = 'Ideal'
-                else:
-                    classification = 'Normal'
-            else:
-                classification = 'Big'
-            
-            # Convert size to degrees and minutes
-            d = int(size)
-            m = int((size - d) * 60)
-            size_str = f"{d}°{m}'"
-            ZSizes.append((size_str, classification))
+            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}
+        return {'PLadder': PLadder, 'ZSizes': ZSizes, 'longitudes': longitudes}
     
     except ValueError:
-        return {"error": "Неверный формат даты и времени. Используйте ISO формат, например, '2023-10-10T12:00:00'"}
+        return {"error": "Неверный формат даты и времени."}
     except Exception as e:
-        return {"error": f"Ошибка при вычислении: {str(e)}"}
+        return {"error": f"Ошибка: {str(e)}"}
 
-
-# Function to parse date and time into ISO format
-def parse_date_time(date_time_str):
-    try:
-        dt = parser.parse(date_time_str)
-        return dt.isoformat()
-    except ValueError:
-        return None
-
-# Function to convert longitude to zodiac sign and degrees
-def lon_to_sign(lon):
-    signs = ["Овен", "Телец", "Близнецы", "Рак", "Лев", "Дева", 
-             "Весы", "Скорпион", "Стрелец", "Козерог", "Водолей", "Рыбы"]
-    sign_index = int(lon // 30)
-    sign = signs[sign_index]
-    degrees = int(lon % 30)
-    minutes = int((lon % 1) * 60)
-    return f"{sign} {degrees}°{minutes}'"
-
-
-@tool
+# Plot the planetary ladder
 def plot_pladder(PLadder):
-    """
-    Plot the planetary ladder as a right triangle with planet symbols.
-    
-    Args:
-        PLadder (list): List of planet names in order
-    
-    Returns:
-        matplotlib.figure.Figure: The generated plot
-    """
     fig, ax = plt.subplots()
-    # Plot triangle with right angle on top: vertices at (0,0), (1.5,3), (3,0)
-    ax.plot([0, 1.5, 3, 0], [0, 3, 0, 0], 'k-')
-    # Draw horizontal lines dividing height into three equal parts
-    ax.plot([0, 3], [1, 1], 'k--')
+    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--')
-    # Define positions for planets 1 to 7, adjusted to avoid overlap
     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)]
-    for i, pos in enumerate(positions):
-        symbol = planet_symbols[PLadder[i]]
-        ax.text(pos[0], pos[1], symbol, ha='center', va='center', fontsize=24)  # Doubled font size
+    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)
     ax.set_ylim(-0.5, 3.5)
     ax.set_aspect('equal')
     ax.axis('off')
     return fig
 
+# Main interface function
+def chat_interface(query, lat, lon):
+    if not query.startswith("PLadder "):
+        return "Запрос должен начинаться с 'PLadder' и содержать дату/время.", None
+    
+    date_time_str = query.split(" ", 1)[1]
+    date_time_iso = parse_date_time(date_time_str)
+    if not date_time_iso:
+        return "Неверный формат даты и времени.", None
+    
+    result = PLadder_ZSizes(date_time_iso, 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"Зона {i+1}: {size} ({cls})" for i, (size, cls) in enumerate(ZSizes)])
+    
+    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"Планетарная лестница:\n{planet_list}\n\nРазмеры зон:\n{zones_text}"
+    return text, img
+
+# Gradio UI
+with gr.Blocks() as interface:
+    with gr.Row():
+        with gr.Column(scale=2):
+            output_text = gr.Textbox(label="Ответ", lines=10)
+        with gr.Column(scale=1):
+            output_image = gr.Image(label="График планетарной лестницы")
+    with gr.Row():
+        with gr.Column(scale=1):
+            query_text = gr.Textbox(label="Запрос", placeholder="Пример: PLadder 2023-10-10 12:00")
+            location_lat = gr.Textbox(label="Широта", placeholder="Пример: 37.7749")
+            location_lon = gr.Textbox(label="Долгота", placeholder="Пример: -122.4194")
+            submit_button = gr.Button("Отправить")
+    
+    submit_button.click(
+        fn=chat_interface,
+        inputs=[query_text, location_lat, location_lon],
+        outputs=[output_text, output_image]
+    )
 
-
-# Load image tool from Hub
-image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)
-
-# Load prompt templates
-with open("prompts.yaml", 'r') as stream:
-    prompt_templates = yaml.safe_load(stream)
-
-# Initialize agent with all tools
-agent = CodeAgent(
-    model=model,
-    tools=[final_answer, get_moon_info, get_current_time_in_timezone, get_current_time_raw, plot_pladder, PLadder_ZSizes, image_generation_tool],
-    max_steps=6,
-    verbosity_level=1,
-    prompt_templates=prompt_templates
-#    execution_env=E2BSandbox(  
-#        allowed_imports=["numpy", "pandas"], # Explicitly permitted packages  
-#        blocked_imports=["subprocess"], # Prevent system access  
-#    ),  
-#    safe_mode=True, # Enable safe code execution  
-#    timeout=10, # Seconds before execution timeout  
-#    max_memory=512, # MB memory limit  
-#    file_system_access=False, # Disable disk write access  
-#    network_access=False, # Block network operations  
-#    max_code_iterations=100, # Prevent infinite loops
-)
-
-if __name__ == "__main__":
-    GradioUI(agent).launch()
-
-# Change to your username and repo name
-# agent.push_to_hub('sergeyo7/Garden_Magus')
+interface.launch()