second commit

APIs/geolocation.py

@@ -0,0 +1,62 @@
+import requests
+import re
+
+
+def get_geolocation(adresse, latitude, longitude):
+    """Return latitude, longitude & code INSEE from an adress. Latitude & longitude only if they are not specified in the function.
+
+    Args:
+        adresse (str): Adress or city for example
+
+    Returns:
+        Tuple(float, float, str): latitude, longitude & code INSEE
+    """
+    if latitude is not None and longitude is not None:
+        url = f"https://data.geopf.fr/geocodage/reverse?lon={longitude}&lat={latitude}&index=parcel"
+    else:
+        url = f"https://data.geopf.fr/geocodage/search?q={adresse}"
+
+    response = requests.get(url)
+    if response.status_code == 200:
+        data = response.json()["features"][0]
+        if 'parcel' in url:
+            properties = data["properties"]
+            code_insee = properties["departmentcode"] + \
+                properties["municipalitycode"]
+        else:
+            coordinates = data["geometry"]["coordinates"]
+            latitude, longitude = coordinates[1], coordinates[0]
+            code_insee = data["properties"]["citycode"]
+        return latitude, longitude, code_insee
+    return None, None, None
+
+
+def get_risques(code_insee):
+    """Get list of risks from a 'code INSEE'
+
+    Args:
+        code_insee (str): Code INSEE
+
+    Returns:
+        List[str]: List of risks
+    """
+    requete = f"https://georisques.gouv.fr/api/v1/gaspar/risques?code_insee={code_insee}"
+    response = requests.get(requete)
+    if response.status_code == 200:
+        risques = eval(response.content.decode().replace("null", "-1"))
+        if risques["results"] > 0:
+            risques = risques["data"]
+            risques = [r["libelle_risque_long"]
+                       for r in risques[0]["risques_detail"]]
+        else:
+            risques = []
+    else:
+        risques = None
+    return risques
+
+
+if __name__ == "__main__":
+    lon, lat, code_insee = get_geolocation(
+        "6 allée de chartres 91370 Verrieres le Buisson", None, None)
+
+    print(get_risques(code_insee))

APIs/meteo.py

@@ -0,0 +1,94 @@
+import openmeteo_requests
+import requests_cache
+import pandas as pd
+from retry_requests import retry
+
+
+# Setup the Open-Meteo API client with cache and retry on error
+cache_session = requests_cache.CachedSession('.cache', expire_after=3600)
+retry_session = retry(cache_session, retries=5, backoff_factor=0.2)
+openmeteo = openmeteo_requests.Client(session=retry_session)
+
+
+def get_info_meteo(latitude, longitude):
+    """Function that creates a Json file containing the weather data of the location
+    ARGS: 
+        latitude (Float) : latitude coordinate
+        longitude (Float): longitude coordinate
+
+    """
+
+    url = "https://api.open-meteo.com/v1/forecast"
+    params = {
+        "latitude": latitude,
+        "longitude": longitude,
+        "hourly": {"relative_humidity_2m", "soil_temperature_0cm", "soil_moisture_0_to_1cm"},
+        "daily": {"temperature_2m_max", "precipitation_sum", "wind_speed_10m_max", "sunshine_duration"},
+        "past_days": 30,
+        "forecast_days": 7
+
+    }
+
+    responses = openmeteo.weather_api(url, params=params)
+    response = responses[0]
+
+    # Hourly dataframe
+    hourly = response.Hourly()
+    hourly_relative_humidity_2m = hourly.Variables(0).ValuesAsNumpy()
+    hourly_soil_temperature_0cm = hourly.Variables(1).ValuesAsNumpy()
+    hourly_soil_moisture_0_to_1cm = hourly.Variables(2).ValuesAsNumpy()
+
+    hourly_data = {"date": pd.date_range(
+        start=pd.to_datetime(hourly.Time(), unit="s", utc=True),
+        end=pd.to_datetime(hourly.TimeEnd(), unit="s", utc=True),
+        freq=pd.Timedelta(seconds=hourly.Interval()),
+        inclusive="left"
+    )}
+
+    hourly_data["relative_humidity_2m_%"] = hourly_relative_humidity_2m
+    hourly_data["soil_temperature_0cm_C"] = hourly_soil_temperature_0cm
+    hourly_data["soil_moisture_0_to_1cm_m³"] = hourly_soil_moisture_0_to_1cm
+
+    hourly_dataframe = pd.DataFrame(data=hourly_data)
+
+    # Average hourly data per day
+    hourly_dataframe['day_date'] = hourly_dataframe['date'].dt.strftime(
+        '%Y-%m-%d')
+
+    tmp = hourly_dataframe.groupby('day_date')[
+        ['relative_humidity_2m_%', 'soil_temperature_0cm_C', 'soil_moisture_0_to_1cm_m³']].mean()
+
+    avg_hourly_dataframe = tmp.rename(columns={'relative_humidity_2m_%': 'avg_hourly_relative_humidity_2m_%',
+                                      'soil_temperature_0cm_C': 'avg_hourly_soil_temperature_0cm_C', 'soil_moisture_0_to_1cm_m³': 'avg_hourly_soil_moisture_0_to_1cm_m³'})
+
+    # Daily dataframe
+    daily = response.Daily()
+    daily_temperature_2m_max = daily.Variables(0).ValuesAsNumpy()
+    daily_precipitation_sum = daily.Variables(1).ValuesAsNumpy()
+    daily_wind_speed_10m_max = daily.Variables(2).ValuesAsNumpy()
+    daily_sunshine_duration = daily.Variables(3).ValuesAsNumpy()
+
+    daily_data = {"date": pd.date_range(
+        start=pd.to_datetime(daily.Time(), unit="s", utc=True),
+        end=pd.to_datetime(daily.TimeEnd(), unit="s", utc=True),
+        freq='D',
+        inclusive="left"
+    )}
+
+    daily_data["daily_temperature_2m_max_C"] = daily_temperature_2m_max
+    daily_data["daily_precipitation_sum_mm"] = daily_precipitation_sum
+    daily_data["daily_wind_speed_10m_max_km/h"] = daily_wind_speed_10m_max
+    daily_data["daily_sunshine_duration_sec"] = daily_sunshine_duration
+
+    daily_dataframe = pd.DataFrame(data=daily_data)
+
+    daily_dataframe['day_date'] = daily_dataframe['date'].dt.strftime(
+        '%Y-%m-%d')
+    total_df = pd.merge(daily_dataframe, avg_hourly_dataframe,
+                        on="day_date", how="left")
+
+    total_df['date'] = total_df['day_date']
+    total_df = total_df.drop('day_date', axis=1)
+
+    return total_df
+    #total_df.to_json("app/data/weather_data.json", orient='columns')

app.py

@@ -1,7 +1,35 @@
 import gradio as gr
+from utils import *
 
-def greet(name):
-    return "Hello " + name + "!!"
+with gr.Blocks() as demo:
+    with gr.Row():
+        with gr.Column():
+            lat = gr.Number(value=48.832408, label="Latitude",
+                            info="La latitude de votre élevage")
+            lon = gr.Number(value=2.28619, label="Longitude",
+                            info="La longitude de votre élevage")
+            address = gr.Textbox(
+                label="Address",
+                info="Dans le cas ou vous ne connaissez pas vos coordonnées GPS, rentrez votre adresse !")
+        with gr.Column():
+            type_elevage = gr.CheckboxGroup(choices=[
+                "Bovin",
+                "Ovin",
+                "Caprin",
+                "Porcin",
+                "Volailles",
+                "Equin"
+            ], label="Type d'élevage", info="Quel est votre type d'élevage?")
+        with gr.Column():
+            btn = gr.Button(value="Submit", size="sm")
 
-iface = gr.Interface(fn=greet, inputs="text", outputs="text")
-iface.launch()
+    with gr.Tab("Map"):
+        map = gr.HTML()
+
+    with gr.Tab("Weather data"):
+        fig = gr.Plot(label="Météo")
+
+    demo.load(show_map, [lat, lon, address], [map, fig])
+    btn.click(show_map, [lat, lon, address], [map, fig])
+
+demo.launch()

chatbot.py

@@ -0,0 +1,126 @@
+import os
+import gradio as gr
+
+from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
+
+from llama_index.readers.web import SimpleWebPageReader
+
+from llama_index.llms.mistralai import MistralAI
+from llama_index.embeddings.mistralai import MistralAIEmbedding
+
+from llama_index.core import Settings
+from llama_index.core.query_engine import RetrieverQueryEngine
+
+from dotenv import load_dotenv
+
+def print_conversation(chat_history):
+    """
+    Fonction de vérification. 
+
+    Args:
+        chat_history (List[List[str]]): historique d'échanges avec le chatbot
+    """
+    for question, response in chat_history:
+        print('Question :', end = '\n')
+        print(question, end = '\n')
+        print('Response :', end = '\n')
+        print(response, end = '\n\n')
+
+def main(
+            query_engine, 
+            elevage,
+            temperature,
+            humidite,
+            meteo
+        ):
+    """
+    Fonction qui crée le bloc du chatbot avec gradio.
+    Couplage entre le 
+
+    Args:
+        query_engine (_type_): index de recherche vectorielle.
+        elevage (str): 
+        temperature (str): 
+        humidite (str): 
+        meteo (str): 
+
+    Returns:
+        None
+    """
+
+    title = "Gaia Mistral Chat RAG URL Demo"
+    description = "Example of an assistant with Gradio, RAG from url and Mistral AI via its API"
+    placeholder = "Vous pouvez me posez une question sur ce contexte, appuyer sur Entrée pour valider"
+
+    with gr.Blocks() as demo:
+        
+        chatbot = gr.Chatbot()
+        msg = gr.Textbox(placeholder = placeholder)
+        clear = gr.ClearButton([msg, chatbot])
+
+        def respond(message, chat_history):
+            
+            global_message = f"""
+            Tu es un chatbot qui réponds en français, commence et qui dois aider à déterminer les risques parasitaires d'élevage en fonction des conditions météo, voici les conditions météo :
+            
+            - élevage : {elevage}
+            - température moyenne : {temperature}
+            - humidité moyenne : {humidite}
+            - météo : {meteo}
+            
+            {message}
+            
+            Donne-moi ensuite les solutions de prévention et de traitement pour chacun d'eux indépendamment du tableau.
+            Tu dois impérativement répondre en français.
+            """
+
+            response = query_engine.query(global_message)
+            chat_history.append((message, str(response)))
+
+            print_conversation(chat_history)
+            return '', chat_history
+        
+        msg.submit(respond, [msg, chatbot], [msg, chatbot])
+
+    demo.title = title
+    demo.launch()
+
+if __name__ == "__main__":
+
+    #### Loading de la clef Mistral
+    load_dotenv()
+    env_api_key = os.getenv('MISTRAL_API_KEY')
+    
+    ### Type du modèle
+    llm_model = 'mistral-small-2312'
+
+    ### Config modèle
+    Settings.llm = MistralAI(
+        max_tokens = 1024,
+        api_key = env_api_key
+    )
+
+    Settings.embed_model = MistralAIEmbedding(
+        model_name="mistral-embed", 
+        api_key=env_api_key
+    )
+
+    ### Mise en place de l'index
+    documents = SimpleDirectoryReader("documents").load_data()
+    index = VectorStoreIndex.from_documents(documents)
+    query_engine = index.as_query_engine(similarity_top_k=15)
+
+    ### Précision du type d'élevage et des conditions météo 
+    elevage = 'bovin'
+    temperature = '15°C'
+    humidite = '40%'
+    meteo = 'pluvieux'
+    
+    ### Lancement du Gradio
+    main(
+        query_engine,
+        elevage,
+        temperature,
+        humidite,
+        meteo
+    )

requirements.txt

@@ -0,0 +1,8 @@
+mistralai
+faiss-cpu
+numpy
+html2text
+llama-index==0.10.10
+llama-index-llms-mistralai
+llama-index-embeddings-mistralai
+llama-index-llms-huggingface

utils.py

@@ -0,0 +1,45 @@
+import pandas as pd
+import folium
+from folium import IFrame
+import plotly.graph_objects as go
+from APIs.geolocation import get_geolocation, get_risques
+from APIs.meteo import get_info_meteo
+
+
+def get_and_plot_meteo(lat, lon):
+    df = get_info_meteo(lat, lon)
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=df['date'], y=df['daily_temperature_2m_max_C'],
+                  name="Température °C", mode="lines+markers"))
+    fig.add_trace(go.Scatter(x=df['date'], y=df['avg_hourly_relative_humidity_2m_%'],
+                  name="Humidité moyenne en %", mode="lines+markers", yaxis="y2"))
+    fig.update_layout(
+        title="Température maximale et humidité moyenne journalière",
+        xaxis_title="Date",
+        yaxis_title="Température (°C)",
+        yaxis2=dict(
+            title="Humidity (%)",
+            overlaying="y",
+            side="right"
+        )
+    )
+    return fig
+
+
+def show_map(lat, lon, address):
+    if address:
+        lat_tmp, lon_tmp, code_insee = get_geolocation(address, None, None)
+        risques = get_risques(code_insee=code_insee)
+        if lat_tmp or lon_tmp:
+            lat, lon = lat_tmp, lon_tmp
+        else:
+            return "Adress not found. Please enter a valid address", ""
+    if lat and lon:
+        lat_tmp, lon_tmp, code_insee = get_geolocation(None, lat, lon)
+        risques = get_risques(code_insee=code_insee)
+        # Create a map centered at the input coordinates
+        location_map = folium.Map(location=[lat, lon], zoom_start=14)
+        folium.Marker([lat, lon], popup=risques).add_to(location_map)
+        map_html = location_map._repr_html_()
+        fig = get_and_plot_meteo(lat, lon)
+    return map_html, fig