Update app.py

app.py

@@ -1,64 +1,350 @@
+import requests
+import json
 import gradio as gr
-from huggingface_hub import InferenceClient
-
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-
-
-def respond(
-    message,
-    history: list[tuple[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    messages = [{"role": "system", "content": system_message}]
-
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = message.choices[0].delta.content
-
-        response += token
-        yield response
-
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
+import logging
 
+logging.basicConfig(level=logging.ERROR)
+logger = logging.getLogger(__name__)
+
+# Clés API et informations
+OPENROUTER_API_KEY = "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"
+AIRTABLE_API_KEY = "patUUQ6NE9zUOqooM.ec8d096169d754852305c88c7966ad1f8a151f3bf015d39f80bb895bdad0e2f5"
+AIRTABLE_BASE_ID = "appht9RdYAQVd32Py"
+AIRTABLE_TABLE_NAME = "DescriptionsEtudiants"
+YOUR_SITE_URL = "votre-site.com"
+YOUR_APP_NAME = "MonChatbot"
+
+# ID de l'étudiant
+#student_id = 34
+current_request = None
+
+def getParams(x):
+    global current_request
+    params = current_request.query_params
+
+    if 'id' in params:
+        return params['id']
+    else:
+        return None
+    
+student_id = getParams(None)
+
+def get_user_info_by_id(student_id):
+    url = f"https://api.airtable.com/v0/{AIRTABLE_BASE_ID}/Inscription_Etudiants"
+    headers = {
+        "Authorization": f"Bearer {AIRTABLE_API_KEY}",
+        "Content-Type": "application/json"
+    }
+    
+    # Filtrer les enregistrements par ID_Etu
+    params = {
+        "filterByFormula": f"{{ID_Etu}} = '{student_id}'"
+    }
+
+    try:
+        response = requests.get(url, headers=headers, params=params)
+        
+        if response.status_code == 200:
+            data = response.json()
+            
+            if len(data['records']) > 0:
+                record = data['records'][0]  # On prend le premier enregistrement correspondant
+                user_name = record['fields'].get('Nom', 'Aucun nom trouvé')
+                user_email = record['fields'].get('Email', 'Aucun email trouvé')
+                return user_name, user_email
+            else:
+                return None, None
+        else:
+            logger.error(f"Erreur lors de la récupération des informations : {response.status_code} - {response.text}")
+            return None, None
+
+    except Exception as e:
+        logger.error(f"Erreur lors de la récupération des informations : {str(e)}")
+        return None, None
+
+
+def get_student_description(student_id):
+    url = f"https://api.airtable.com/v0/{AIRTABLE_BASE_ID}/{AIRTABLE_TABLE_NAME}"
+    headers = {
+        "Authorization": f"Bearer {AIRTABLE_API_KEY}",
+        "Content-Type": "application/json"
+    }
+
+    try:
+        response = requests.get(url, headers=headers)
+        if response.status_code == 200:
+            data = response.json()
+            if 'records' in data:
+                for record in data['records']:
+                    if record['fields'].get('ID_Etudiant') == student_id:
+                        return record['fields'].get('Description Compétences Etudiants', 'Pas de description trouvée.')
+            return "Aucun enregistrement trouvé pour cet étudiant."
+        else:
+            logger.error(f"Erreur lors de la récupération de la description : {response.status_code} - {response.text}")
+            return f"Erreur lors de la récupération : {response.status_code} - {response.text}"
+    except Exception as e:
+        logger.error(f"Erreur lors de la récupération : {str(e)}")
+        return "Erreur lors de la récupération."
+
+def update_student_description(student_id, new_description):
+    # Étape 1 : Récupérer tous les enregistrements
+    url = f"https://api.airtable.com/v0/{AIRTABLE_BASE_ID}/{AIRTABLE_TABLE_NAME}"
+    headers = {
+        "Authorization": f"Bearer {AIRTABLE_API_KEY}",
+        "Content-Type": "application/json"
+    }
+
+    try:
+        response = requests.get(url, headers=headers)
+        if response.status_code == 200:
+            data = response.json()
+            # Étape 2 : Trouver l'enregistrement correspondant à student_id
+            record_to_update = None
+            for record in data.get('records', []):
+                if 'fields' in record and record['fields'].get('ID_Etudiant') == student_id:
+                    record_to_update = record
+                    break
+            
+            if record_to_update:
+                # Étape 3 : Mettre à jour la description
+                record_id = record_to_update['id']
+                update_url = f"https://api.airtable.com/v0/{AIRTABLE_BASE_ID}/{AIRTABLE_TABLE_NAME}/{record_id}"
+                update_data = {
+                    "fields": {
+                        "Description Compétences Etudiants": new_description
+                    }
+                }
+                update_response = requests.patch(update_url, headers=headers, json=update_data)
+                
+                if update_response.status_code == 200:
+                    return "Description mise à jour avec succès."
+                else:
+                    logger.error(f"Erreur lors de la mise à jour : {update_response.status_code} - {update_response.text}")
+                    return "Erreur lors de la mise à jour."
+            else:
+                return "Aucun étudiant trouvé avec cet ID."
+        else:
+            logger.error(f"Erreur lors de la récupération des enregistrements : {response.status_code} - {response.text}")
+            return "Erreur lors de la récupération des enregistrements."
+    except Exception as e:
+        logger.error(f"Erreur lors de la mise à jour : {str(e)}")
+        return "Erreur lors de la mise à jour."
+
+
+def call_api_for_response_analysis(current_skills, user_response):
+    messages = [
+        {
+            "role": "system",
+            "content": "Tu es un expert en analyse de compétences. En fonction de la réponse de l'utilisateur, "
+                      "tu dois reformuler et mettre à jour les compétences actuelles. "
+                      "Retourne uniquement la nouvelle description des compétences mise à jour."
+        },
+        {
+            "role": "user",
+            "content": f"Compétences actuelles :\n{current_skills}\n\n"
+                      f"Réponse de l'utilisateur :\n{user_response}\n\n"
+                      "Reformule les compétences en prenant en compte la réponse de l'utilisateur."
+        }
+    ]
+
+    try:
+        api_response = requests.post(
+            url="https://openrouter.ai/api/v1/chat/completions",
+            headers={
+                "Authorization": f"Bearer {OPENROUTER_API_KEY}",
+                "Content-Type": "application/json"
+            },
+            data=json.dumps({
+                "model": "mistralai/pixtral-12b:free",
+                "messages": messages
+            })
+        )
+
+        if api_response.status_code == 200:
+            data = api_response.json()
+            return data['choices'][0]['message']['content']
+        else:
+            logger.error(f"Erreur lors de l'analyse de la réponse : {api_response.status_code} - {api_response.text}")
+            return "Erreur lors de l'analyse de la réponse."
+    
+    except Exception as e:
+        logger.error(f"Erreur lors de l'appel API: {str(e)}")
+        return "Erreur lors de l'appel API."
+
+def get_enterprise_descriptions():
+    url = f"https://api.airtable.com/v0/{AIRTABLE_BASE_ID}/Formulaire firm"
+    headers = {
+        "Authorization": f"Bearer {AIRTABLE_API_KEY}",
+        "Content-Type": "application/json"
+    }
+    
+    response = requests.get(url, headers=headers)
+    
+    if response.status_code == 200:
+        data = response.json()
+        firm_data = [
+            (
+                record['fields'].get('Recruteur / Entreprise'),
+                record['fields'].get('Compétences requises'),
+                record['fields'].get('ID_Offre')
+            ) 
+            for record in data['records']
+        ]
+        return firm_data
+    else:
+        logger.error(f"Erreur lors de la récupération des descriptions d'entreprises : {response.status_code} - {response.text}")
+        return []
+
+
+def compare_skills_ai(student_skills, enterprise_skills):
+    messages = [
+        {"role": "system", "content": "Vous êtes un expert en recrutement chargé d'évaluer la correspondance entre les compétences d'un étudiant et celles requises par une entreprise. Votre tâche est d'analyser ces compétences et de fournir une valeur de correspondance entre l'étudiant et les différentes entreprise, je veux simplement la note global pour chaque entreprise. Tenez compte des compétences similaires ou complémentaires, pas seulement des correspondances exactes."},
+        {"role": "user", "content": f"Compétences de l'étudiant :\n{student_skills}\n\nCompétences requises par l'entreprise :\n{enterprise_skills}\n\nVeuillez analyser ces compétences et fournir un chiffre entre 0 et 100 pour la correspondance entre l'etudiant et l'entreprise afin de voir le taux de compatibilité entre l'etudiants et les différentes entreprises. ne détaille rien, juste la note global sans le détail. Ecrit que et uniquement le score, par exemple : 100 et pas : Score : 100, juste 100. Sans tiret nin rien juste le nombre"}
+    ]
+
+    try:
+        response = requests.post(
+            url="https://openrouter.ai/api/v1/chat/completions",
+            headers={
+                "Authorization": f"Bearer {OPENROUTER_API_KEY}",
+                "HTTP-Referer": f"{YOUR_SITE_URL}",
+                "X-Title": f"{YOUR_APP_NAME}",
+                "Content-Type": "application/json"
+            },
+            data=json.dumps({
+                "model": "mistralai/pixtral-12b:free",
+                "messages": messages
+            })
+        )
+        
+        if response.status_code == 200:
+            data = response.json()
+            ai_analysis = data['choices'][0]['message']['content']
+            try:
+                score = int(ai_analysis.strip())
+                return score
+            except ValueError:
+                logger.error(f"Erreur lors de la conversion du score : la réponse était '{ai_analysis}'")
+                return "Erreur lors de l'analyse des compétences : score non valide."
+        else:
+            logger.error(f"Erreur lors de l'appel à l'API : {response.status_code} - {response.text}")
+            return "Erreur lors de l'analyse des compétences."
+    except Exception as e:
+        logger.error(f"Erreur lors de l'appel API: {str(e)}")
+        return f"Erreur lors de l'analyse des compétences : {str(e)}"
+
+def update_compatibility_table(student_id, skill_assessment, enterprise_skills, offer_id, compatibility_rate, student_name, student_mail):
+    url = f"https://api.airtable.com/v0/{AIRTABLE_BASE_ID}/TauxCompatibilité"
+    headers = {
+        "Authorization": f"Bearer {AIRTABLE_API_KEY}",
+        "Content-Type": "application/json"
+    }
+    
+    data = {
+        "fields": {
+            "ID_Etu": student_id,
+            "DescriptionEtu": skill_assessment,
+            "ID_Offre": offer_id,
+            "DescriptionOffre": enterprise_skills,
+            "Taux de compatibilité" : compatibility_rate,
+            "Nom": student_name, 
+            "EmailEtudiant": student_mail
+        }
+    }
+    
+    try:
+        response = requests.post(url, headers=headers, json=data)
+
+        if response.status_code == 200:
+            return "Données ajoutées avec succès !"
+        else:
+            logger.error(f"Erreur lors de l'ajout à la table de compatibilité : {response.status_code} - {response.text}")
+            return f"Erreur lors de l'ajout à la table de compatibilité : {response.status_code}"
+    except Exception as e:
+        logger.error(f"Erreur lors de l'ajout à Airtable : {str(e)}")
+        return f"Erreur lors de l'ajout à Airtable : {str(e)}"
+
+def delete_compatibility_records(student_id):
+    """
+    Supprime tous les enregistrements de la table TauxCompatibilité associés à un étudiant donné (ID_Etu).
+    """
+    url = f"https://api.airtable.com/v0/{AIRTABLE_BASE_ID}/TauxCompatibilité"
+    headers = {
+        "Authorization": f"Bearer {AIRTABLE_API_KEY}",
+        "Content-Type": "application/json"
+    }
+
+    try:
+        # Récupérer les enregistrements existants pour l'ID_Etu donné
+        response = requests.get(url, headers=headers)
+        response.raise_for_status()
+        records = response.json().get('records', [])
+
+        # Supprimer les enregistrements existants avec l'ID_Etu correspondant
+        for record in records:
+            if record['fields'].get('ID_Etu') == student_id:
+                delete_url = f"{url}/{record['id']}"
+                delete_response = requests.delete(delete_url, headers=headers)
+                delete_response.raise_for_status()  # Vérifier si la suppression a réussi
+
+        return "Suppression des enregistrements existants réussie."
+    
+    except Exception as e:
+        logger.error(f"Erreur lors de la suppression des enregistrements : {str(e)}")
+        return f"Erreur lors de la suppression des enregistrements : {str(e)}"
+
+
+def start_conversation():
+    description = get_student_description(student_id)
+    initial_message = f"Bienvenue ! Voici vos compétences :\n{description}\n\nQue souhaitez-vous modifier ou améliorer dans vos compétences ?"
+    return [[None, initial_message]], description
+
+def chatbot_conversation(message, history):
+    student_name, student_mail = get_user_info_by_id(student_id)
+    current_skills = get_student_description(student_id)
+    
+    # Analyse la réponse et obtient les compétences mises à jour
+    updated_skills = call_api_for_response_analysis(current_skills, message)
+
+    enterprise_descriptions = get_enterprise_descriptions()
+    results = []
+    delete_compatibility_records(student_id)
+    for enterprise_name, enterprise_desc, offer_id in enterprise_descriptions:
+        analysis = compare_skills_ai(updated_skills, enterprise_desc)
+        
+        add_response = update_compatibility_table(student_id, updated_skills, enterprise_desc, offer_id, analysis, student_name, student_mail)
+        
+        results.append(f"Entreprise : {enterprise_name}\n{add_response}")
+    
+    # Prépare la réponse pour le chatbot
+    response = "Voici la version mise à jour de vos compétences :\n\n" + updated_skills
+    history.append((message, response))
+    
+    return history, updated_skills
+
+def validate_update(updated_skills):
+    response = update_student_description(student_id, updated_skills)
+    return response
+
+# Création de l'interface
+with gr.Blocks() as demo:
+    chatbot = gr.Chatbot()
+    msg = gr.Textbox(label="Message")
+    skill_assessment_output = gr.Textbox(label="Compétences actuelles", interactive=False)
+    validate_button = gr.Button("Valider la mise à jour")  # Nouveau bouton pour valider
+    validation_output = gr.Textbox(label="Résultat de la mise à jour", interactive=False)  # Nouveau bloc pour afficher le résultat
+
+    msg.submit(fn=chatbot_conversation, 
+              inputs=[msg, chatbot], 
+              outputs=[chatbot, skill_assessment_output])
+    
+    # Action du bouton pour mettre à jour la description
+    validate_button.click(fn=validate_update, inputs=skill_assessment_output, outputs=validation_output)  # Utilisation du bloc validation_output
+
+    # Chargement initial du message de bienvenue
+    demo.load(start_conversation, 
+             inputs=None, 
+             outputs=[chatbot, skill_assessment_output])
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()