Update app.py

app.py

@@ -1,317 +1,328 @@
-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 gradio as gr
+from langchain_community.document_loaders import UnstructuredMarkdownLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_core.documents import Document
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_community.vectorstores import FAISS
+from langchain_community.llms import HuggingFaceHub
+from langchain.prompts import ChatPromptTemplate
+from dotenv import load_dotenv
 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,
+from datetime import datetime
+from skyfield.api import load
+import matplotlib.pyplot as plt
+
+# Load environment variables
+load_dotenv()
+
+DATA_PATH = ""  # Specify the path to your file
+PROMPT_TEMPLATE = """
+Ответь на вопрос, используя только следующий контекст:
+{context}
+---
+Ответь на вопрос на основе приведенного контекста: {question}
+"""
+
+# Global variable for status
+status_message = "Инициализация..."
+
+# Translation dictionaries
+classification_ru = {
+    'Swallowed': 'проглоченная',
+    'Tiny': 'сверхмалая',
+    'Small': 'малая',
+    'Normal': 'нормальная',
+    'Ideal': 'идеальная',
+    'Big': 'большая'
 }
 
-# Fertility phase coefficients for root crops
-FERTILITY_PHASE_COEFFS_ROOT = {
-    "New Moon": 0,
-    "Waxing Moon": 0.5,
-    "Full Moon": 0,
-    "Waning Moon": 1,
+planet_ru = {
+    'Sun': 'Солнце',
+    'Moon': 'Луна',
+    'Mercury': 'Меркурий',
+    'Venus': 'Венера',
+    'Mars': 'Марс',
+    'Jupiter': 'Юпитер',
+    'Saturn': 'Сатурн'
 }
 
-# Pruning phase coefficients
-PRUNING_PHASE_COEFFS = {
-    "New Moon": 0,
-    "Waxing Moon": 1,
-    "Full Moon": 0,
-    "Waning Moon": 0.5,
+planet_symbols = {
+    '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.
+def initialize_vectorstore():
+    """Initialize the FAISS vector store for document retrieval."""
+    global status_message
+    try:
+        status_message = "Загрузка и обработка документов..."
+        documents = load_documents()
+        chunks = split_text(documents)
+        
+        status_message = "Создание векторной базы..."
+        vectorstore = save_to_faiss(chunks)
+        
+        status_message = "База данных готова к использованию."
+        return vectorstore
+    except Exception as e:
+        status_message = f"Ошибка инициализации: {str(e)}"
+        raise
+
+def load_documents():
+    """Load documents from the specified file path."""
+    file_path = os.path.join(DATA_PATH, "pl250320252.md")
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"Файл {file_path} не найден")
+    loader = UnstructuredMarkdownLoader(file_path)
+    return loader.load()
+
+def split_text(documents: list[Document]):
+    """Split documents into chunks for vectorization."""
+    text_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=900,
+        chunk_overlap=300,
+        length_function=len,
+        add_start_index=True,
+    )
+    return text_splitter.split_documents(documents)
+
+def save_to_faiss(chunks: list[Document]):
+    """Save document chunks to a FAISS vector store."""
+    embeddings = HuggingFaceEmbeddings(
+        model_name="sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2",
+        model_kwargs={'device': 'cpu'},
+        encode_kwargs={'normalize_embeddings': True}
+    )
+    return FAISS.from_documents(chunks, embeddings)
+
+def process_query(query_text: str, vectorstore):
+    """Process a query using the RAG system."""
+    if vectorstore is None:
+        return "База данных не инициализирована", []
     
-    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
+    try:
+        results = vectorstore.similarity_search_with_relevance_scores(query_text, k=3)
+        global status_message
+        status_message += f"\nНайдено {len(results)} результатов"
+        
+        if not results:
+            return "Не найдено результатов.", []
+            
+        context_text = "\n\n---\n\n".join([
+            f"Релевантность: {score:.2f}\n{doc.page_content}" 
+            for doc, score in results
+        ])
+        
+        prompt_template = ChatPromptTemplate.from_template(PROMPT_TEMPLATE)
+        prompt = prompt_template.format(context=context_text, question=query_text)
         
-        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).
+        model = HuggingFaceHub(
+            repo_id="https://pflgm2locj2t89co.us-east-1.aws.endpoints.huggingface.cloud/",
+            task="text2text-generation",
+            model_kwargs={"temperature": 0.5, "max_length": 512}
+        )
+        response_text = model.predict(prompt)
         
-        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.
+        sources = list(set([doc.metadata.get("source", "") for doc, _ in results]))
+        return response_text, sources
+    except Exception as e:
+        return f"Ошибка обработки запроса: {str(e)}", []
+
+def PLadder_ZSizes(date_time_iso: str):
+    """
+    Calculate the planetary ladder and zone sizes for a given date and time.
+    
     Args:
-        date_time (str): ISO 8601 formatted datetime (YYYY-MM-DDTHH:MM:SS)
+        date_time_iso (str): Date and time in ISO format (e.g., '2023-10-10T12:00:00')
+    
     Returns:
-        dict: {
-            "zodiac_position": "Leo 15°30'",
-            "moon_phase": "Waxing Gibbous",
-            "fertility_above_ground": 2.0,
-            "fertility_root_crop": 1.5,
-            "pruning": 2.0
-        }
+        dict: Contains 'PLadder' (list of planets) and 'ZSizes' (list of zone sizes with classifications)
+              or an error message if unsuccessful
     """
     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
+        dt = datetime.fromisoformat(date_time_iso)
+        if dt.year < 1900 or dt.year > 2050:
+            return {"error": "Дата вне диапазона. Должна быть между 1900 и 2050 годами."}
+        
+        # Load ephemeris
+        planets = load('de421.bsp')
         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
+        
+        # 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']
         }
-
+        
+        # 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()
+            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))
+        
+        return {'PLadder': PLadder, 'ZSizes': ZSizes}
+    
+    except ValueError:
+        return {"error": "Неверный формат даты и времени. Используйте ISO формат, например, '2023-10-10T12:00:00'"}
     except Exception as e:
-        raise ValueError(f"Error in get_moon_info: {str(e)}")
+        return {"error": f"Ошибка при вычислении: {str(e)}"}
 
-@tool
-def get_current_time_in_timezone(timezone: str) -> str:
+def plot_pladder(PLadder):
     """
-    Returns the current local time in the specified timezone with description.
+    Plot the planetary ladder as a right triangle with planet symbols.
+    
     Args:
-        timezone (str): A string representing a valid timezone (e.g., 'UTC')
+        PLadder (list): List of planet names in order
+    
     Returns:
-        str: Formatted local time with timezone description
+        matplotlib.figure.Figure: The generated plot
     """
-    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:
+    fig, ax = plt.subplots()
+    # Draw triangle with vertices (0,0), (0,3), (3,0)
+    ax.plot([0, 0, 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, 3], [2, 2], 'k--')
+    # Define positions for planets 1 to 7
+    positions = [(0, 0), (0, 1), (0, 2), (0, 3), (1, 2), (2, 1), (3, 0)]
+    for i, pos in enumerate(positions):
+        symbol = planet_symbols[PLadder[i]]
+        ax.text(pos[0], pos[1], symbol, ha='center', va='center', fontsize=12)
+    ax.set_xlim(-0.5, 3.5)
+    ax.set_ylim(-0.5, 3.5)
+    ax.set_aspect('equal')
+    ax.axis('off')
+    return fig
+
+def chat_interface(query_text):
     """
-    Returns current local time in specified timezone as ISO 8601 string.
+    Handle user queries, either for planetary ladder or general RAG questions.
+    
     Args:
-        timezone (str): A string representing a valid timezone (e.g., 'UTC')
+        query_text (str): User's input query
+    
     Returns:
-        str: Datetime in ISO 8601 format (YYYY-MM-DDTHH:MM:SS)
+        tuple: (text response, plot figure or None)
     """
+    global status_message
     try:
-        tz = pytz.timezone(timezone)
-        now = datetime.datetime.now(tz)
-        return now.strftime("%Y-%m-%dT%H:%M:%S")
+        vectorstore = initialize_vectorstore()
+        
+        if query_text.startswith("PLadder "):
+            # Extract date and time from query
+            date_time_iso = query_text.split(" ", 1)[1]
+            result = PLadder_ZSizes(date_time_iso)
+            
+            if "error" in result:
+                return result["error"], None
+            
+            PLadder = result["PLadder"]
+            ZSizes = result["ZSizes"]
+            
+            # Translate to Russian
+            PLadder_ru = [planet_ru[p] for p in PLadder]
+            ZSizes_ru = [(size_str, classification_ru[classification]) for size_str, classification in ZSizes]
+            
+            # Prepare queries and get responses
+            responses = []
+            for i in range(7):
+                planet = PLadder_ru[i]
+                size_str, class_ru = ZSizes_ru[i]
+                query = f"Что значит {planet} на {i+1}-й ступени и {size_str} {class_ru} {i+1}-я зона?"
+                response, _ = process_query(query, vectorstore)
+                responses.append(f"Интерпретация для {i+1}-й ступени и {i+1}-й зоны: {response}")
+            
+            # Query for 8th zone
+            size_str, class_ru = ZSizes_ru[7]
+            query = f"Что значит {size_str} {class_ru} восьмая зона?"
+            response, _ = process_query(query, vectorstore)
+            responses.append(f"Интерпретация для 8-й зоны: {response}")
+            
+            # Generate plot
+            fig = plot_pladder(PLadder)
+            
+            # Compile response text
+            text = "Планетарная лестница: " + ", ".join(PLadder_ru) + "\n"
+            text += "Размеры зон:\n" + "\n".join([f"Зона {i+1}: {size_str} {class_ru}" 
+                                                  for i, (size_str, class_ru) in enumerate(ZSizes_ru)]) + "\n\n"
+            text += "\n".join(responses)
+            return text, fig
+        
+        else:
+            # Handle regular RAG query
+            response, sources = process_query(query_text, vectorstore)
+            full_response = f"{status_message}\n\nОтвет: {response}\n\nИсточники: {', '.join(sources) if sources else 'Нет источников'}"
+            return full_response, None
+    
     except Exception as e:
-        return f"Error: {str(e)}"
-
-# 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,
-)
-
-# 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, 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
+        return f"Критическая ошибка: {str(e)}", None
+
+# Define Gradio Interface
+interface = gr.Interface(
+    fn=chat_interface,
+    inputs=gr.Textbox(lines=2, placeholder="Введите ваш вопрос здесь..."),
+    outputs=[gr.Textbox(), gr.Image()],
+    title="Чат с документами",
+    description="Задайте вопрос, и я отвечу на основе загруженных документов. "
+                "Для запроса планетарной лестницы используйте формат: PLadder YYYY-MM-DDTHH:MM:SS"
 )
 
 if __name__ == "__main__":
-    GradioUI(agent).launch()
-
-# Change to your username and repo name
-# agent.push_to_hub('sergeyo7/Garden_Magus')
+    interface.launch()