Version 2.5.0

bot.py

@@ -0,0 +1,212 @@
+# Définir le client Discord et les gestionnaires d'événements.
+
+import discord
+from discord.ext import commands
+from config import CHATGPT_CHANNEL_ID, BOT_NAME, BOT_VERSION
+from logger import logger
+from history import load_conversation_history, conversation_history, add_to_conversation_history, save_conversation_history
+from openai_client import call_gpt4o_for_image_analysis, call_gpt4o_mini_with_analysis, call_openai_api
+from utils import has_text, read_text_file, encode_image_from_attachment
+from history import IMAGE_ANALYSIS_MARKER
+import json
+
+class MyDiscordClient(discord.Client):
+    def __init__(self, intents):
+        super().__init__(intents=intents)
+        self.last_analysis_index = None
+        self.messages_since_last_analysis = 0
+
+    async def close(self):
+        from openai_client import openai_client
+        if openai_client is not None:
+            await openai_client.close()
+        await super().close()
+
+# Initialiser les intents
+intents = discord.Intents.default()
+intents.message_content = True  # Activer l'intent pour les contenus de message
+
+# Initialiser le client Discord
+client_discord = MyDiscordClient(intents=intents)
+
+# Charger l'historique au démarrage
+load_conversation_history()
+
+@client_discord.event
+async def on_ready():
+    logger.info(f'{BOT_NAME} connecté en tant que {client_discord.user}')
+
+    if not conversation_history:
+        logger.info("Aucun historique trouvé. L'historique commence vide.")
+
+    try:
+        # Utiliser fetch_channel au lieu de get_channel
+        channel = await client_discord.fetch_channel(CHATGPT_CHANNEL_ID)
+        if channel:
+            embed = discord.Embed(
+                title="Bot Démarré",
+                description=f"🎉 {BOT_NAME} est en ligne ! Version {BOT_VERSION}",
+                color=0x00ff00  # Vert
+            )
+            await channel.send(embed=embed)
+            logger.info(f"Message de connexion envoyé dans le canal ID {CHATGPT_CHANNEL_ID}")
+    except discord.NotFound:
+        logger.error(f"Canal avec ID {CHATGPT_CHANNEL_ID} non trouvé.")
+    except discord.Forbidden:
+        logger.error(f"Permissions insuffisantes pour envoyer des messages dans le canal ID {CHATGPT_CHANNEL_ID}.")
+    except discord.HTTPException as e:
+        logger.error(f"Erreur lors de l'envoi du message de connexion : {e}")
+
+@client_discord.event
+async def on_message(message):
+    global conversation_history
+
+    # Vérifier si le message provient du canal autorisé
+    if message.channel.id != CHATGPT_CHANNEL_ID:
+        return
+
+    # Ignorer les messages du bot lui-même
+    if message.author == client_discord.user:
+        return
+
+    user_text = message.content.strip()
+    image_data = None
+    file_content = None
+    attachment_filename = None
+
+    # Vérifier si le message est la commande de réinitialisation
+    if user_text.lower() == "!reset_history":
+        # Vérifier si l'utilisateur a les permissions administratives
+        if not message.author.guild_permissions.administrator:
+            await message.channel.send("❌ Vous n'avez pas la permission d'utiliser cette commande.")
+            return
+
+        conversation_history.clear()
+        save_conversation_history()
+        await message.channel.send("✅ L'historique des conversations a été réinitialisé.")
+        logger.info(f"Historique des conversations réinitialisé par {message.author}.")
+        return  # Arrêter le traitement du message après la réinitialisation
+
+    # Extensions de fichiers autorisées
+    allowed_extensions = ['.txt', '.py', '.html', '.css', '.js']
+
+    # Variables pour stocker si le message contient une image et/ou un fichier
+    has_image = False
+    has_file = False
+
+    # Vérifier s'il y a une pièce jointe
+    if message.attachments:
+        for attachment in message.attachments:
+            # Vérifier si c'est un fichier avec une extension autorisée
+            if any(attachment.filename.endswith(ext) for ext in allowed_extensions):
+                file_content = await read_text_file(attachment)
+                attachment_filename = attachment.filename
+                break
+            # Vérifier si c'est une image
+            elif attachment.content_type in ['image/jpeg', 'image/png', 'image/gif', 'image/bmp', 'image/tiff']:
+                image_data = await encode_image_from_attachment(attachment, mode='high')
+                break
+
+    # Si une image est présente, la traiter
+    if image_data:
+        has_user_text = has_text(user_text)
+        user_text_to_use = user_text if has_user_text else None
+
+        # Étape 1 : Envoyer un message temporaire indiquant que l'image est en cours d'analyse
+        temp_msg = await message.channel.send(f"*{BOT_NAME} observe l'image...*")
+
+        try:
+            # Étape 2 : GPT-4o analyse l'image, potentiellement guidée par le texte de l'utilisateur
+            analysis = await call_gpt4o_for_image_analysis(image_data, user_text=user_text_to_use)
+
+            if analysis:
+                # Ajouter l'analyse à l'historique avant de réagir avec GPT-4o Mini
+                analysis_message = {
+                    "role": "system",
+                    "content": f"{IMAGE_ANALYSIS_MARKER}{analysis}"
+                }
+                await add_to_conversation_history(analysis_message)
+
+                # Étape 3 : GPT-4o Mini réagit à la question et à l'analyse
+                reply = await call_gpt4o_mini_with_analysis(
+                    analysis,
+                    message.author.name,
+                    user_text,
+                    has_text=has_user_text,
+                    conversation_history=conversation_history
+                )
+                if reply:
+                    # Étape 4 : Supprimer le message temporaire
+                    await temp_msg.delete()
+
+                    # Étape 5 : Envoyer la réponse finale
+                    await message.channel.send(reply)
+
+                    # Ajouter le message utilisateur à l'historique
+                    if has_user_text:
+                        user_message_content = f"{user_text} (a posté une image.)"
+                    else:
+                        user_message_content = (
+                            "Une image a été postée, mais elle n'est pas disponible pour analyse directe. "
+                            "Veuillez vous baser uniquement sur l'analyse fournie."
+                        )
+
+                    user_message = {
+                        "role": "user",
+                        "content": user_message_content
+                    }
+
+                    # Ajouter le message utilisateur à l'historique
+                    await add_to_conversation_history(user_message)
+
+                    # Ajouter le message assistant à l'historique
+                    assistant_message = {
+                        "role": "assistant",
+                        "content": reply
+                    }
+                    await add_to_conversation_history(assistant_message)
+                else:
+                    # Étape 4 : Supprimer le message temporaire en cas d'échec de génération de réponse
+                    await temp_msg.delete()
+                    await message.channel.send("Désolé, je n'ai pas pu générer une réponse.")
+            else:
+                # Étape 4 : Supprimer le message temporaire en cas d'échec d'analyse
+                await temp_msg.delete()
+                await message.channel.send("Désolé, je n'ai pas pu analyser l'image.")
+
+        except Exception as e:
+            # Étape 4 : Supprimer le message temporaire en cas d'erreur
+            await temp_msg.delete()
+            await message.channel.send("Une erreur est survenue lors du traitement de l'image.")
+            logger.error(f"Error during image processing: {e}")
+
+        # Après traitement de l'image, ne pas continuer
+        return
+
+    # Ajouter le contenu du fichier à la requête si présent
+    if file_content:
+        user_text += f"\nContenu du fichier {attachment_filename}:\n{file_content}"
+
+    # Vérifier si le texte n'est pas vide après ajout du contenu du fichier
+    if not has_text(user_text):
+        return  # Ne pas appeler l'API si le texte est vide
+
+    # Appeler l'API OpenAI
+    result = await call_openai_api(user_text, message.author.name, conversation_history, image_data)
+    if result:
+        reply = result.choices[0].message.content
+        await message.channel.send(reply)
+
+        # Ajouter le message utilisateur à l'historique
+        user_message = {
+            "role": "user",
+            "content": user_text
+        }
+        await add_to_conversation_history(user_message)
+
+        # Ajouter le message assistant à l'historique
+        assistant_message = {
+            "role": "assistant",
+            "content": reply
+        }
+        await add_to_conversation_history(assistant_message)

config.py

@@ -0,0 +1,34 @@
+# Gérer la configuration et les variables d'environnement.
+
+import os
+from dotenv import load_dotenv
+
+# Charger les variables d'environnement depuis le fichier .env
+load_dotenv()
+
+# Variables de configuration
+DISCORD_TOKEN = os.getenv('DISCORD_TOKEN')
+OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')
+DISCORD_CHANNEL_ID = os.getenv('DISCORD_CHANNEL_ID')
+PERSONALITY_PROMPT_FILE = os.getenv('PERSONALITY_PROMPT_FILE', 'personality_prompt.txt')
+CONVERSATION_HISTORY_FILE = os.getenv('CONVERSATION_HISTORY_FILE', 'conversation_history.json')
+BOT_NAME = os.getenv('BOT_NAME', 'ChatBot')
+BOT_VERSION = "2.5.0"
+
+# Vérifications des configurations essentielles
+if DISCORD_TOKEN is None or OPENAI_API_KEY is None or DISCORD_CHANNEL_ID is None:
+    raise ValueError("Les tokens ou l'ID du canal ne sont pas définis dans les variables d'environnement.")
+
+# Vérification de l'existence du fichier de prompt de personnalité
+if not os.path.isfile(PERSONALITY_PROMPT_FILE):
+    raise FileNotFoundError(f"Le fichier de prompt de personnalité '{PERSONALITY_PROMPT_FILE}' est introuvable.")
+
+# Lecture du prompt de personnalité
+with open(PERSONALITY_PROMPT_FILE, 'r', encoding='utf-8') as f:
+    PERSONALITY_PROMPT = f.read().strip()
+
+# Conversion de l'ID du canal Discord en entier
+try:
+    CHATGPT_CHANNEL_ID = int(DISCORD_CHANNEL_ID)
+except ValueError:
+    raise ValueError("L'ID du channel Discord est invalide. Assurez-vous qu'il s'agit d'un entier.")

history.py

@@ -0,0 +1,93 @@
+# Gérer le chargement et la sauvegarde de l'historique des conversations.
+
+import os
+import json
+from logger import logger
+from config import CONVERSATION_HISTORY_FILE, PERSONALITY_PROMPT
+
+# Variable globale pour l'historique des conversations
+conversation_history = []
+
+# Constantes pour les limites de l'historique
+STANDARD_HISTORY_LIMIT = 150
+IMAGE_ANALYSIS_HISTORY_LIMIT = 15
+IMAGE_ANALYSIS_MARKER = "__IMAGE_ANALYSIS__:"
+
+def load_conversation_history():
+    global conversation_history
+    if os.path.isfile(CONVERSATION_HISTORY_FILE):
+        try:
+            with open(CONVERSATION_HISTORY_FILE, 'r', encoding='utf-8') as f:
+                loaded_history = json.load(f)
+                # Exclure le PERSONALITY_PROMPT
+                filtered_history = [
+                    msg for msg in loaded_history
+                    if not (msg.get("role") == "system" and msg.get("content") == PERSONALITY_PROMPT)
+                ]
+                # Modifier la liste en place
+                conversation_history.clear()
+                conversation_history.extend(filtered_history)
+            logger.info(f"Historique chargé depuis {CONVERSATION_HISTORY_FILE} : {len(loaded_history)} messages, {len(conversation_history)} après filtrage.")
+        except Exception as e:
+            logger.error(f"Erreur lors du chargement de l'historique : {e}")
+            conversation_history = []
+    else:
+        logger.info(f"Aucun fichier d'historique trouvé. Un nouveau fichier sera créé à {CONVERSATION_HISTORY_FILE}")
+
+def save_conversation_history():
+    try:
+        with open(CONVERSATION_HISTORY_FILE, 'w', encoding='utf-8') as f:
+            json.dump(conversation_history, f, ensure_ascii=False, indent=4)
+    except Exception as e:
+        logger.error(f"Erreur lors de la sauvegarde de l'historique : {e}")
+
+async def add_to_conversation_history(new_message):
+    global conversation_history
+    # Ne pas ajouter le PERSONALITY_PROMPT à l'historique
+    if new_message.get("role") == "system" and new_message.get("content") == PERSONALITY_PROMPT:
+        logger.debug("PERSONALITY_PROMPT système non ajouté à l'historique.")
+        return
+
+    is_image_analysis = new_message.get("role") == "system" and new_message.get("content", "").startswith(IMAGE_ANALYSIS_MARKER)
+
+    if is_image_analysis:
+    	# Supprimer toutes les analyses d'images précédentes
+    	before_count = len(conversation_history)
+    	conversation_history = [
+    		msg for msg in conversation_history
+    		if not (msg.get("role") == "system" and msg.get("content", "").startswith(IMAGE_ANALYSIS_MARKER))
+    	]
+    	after_count = len(conversation_history)
+    	if before_count != after_count:
+    		logger.info("Les analyses d'images précédentes ont été supprimées avant d'ajouter la nouvelle analyse.")
+
+    # Ajouter le nouveau message
+    conversation_history.append(new_message)
+    logger.debug(f"Message ajouté à l'historique. Taille actuelle : {len(conversation_history)}")
+
+    # Si le message ajouté est une analyse d'image, rien de plus à faire
+    if is_image_analysis:
+    	pass
+    else:
+    	# Vérifier et supprimer les analyses d'images dépassées
+    	# Parcourir l'historique pour trouver les analyses d'images
+    	indices_to_remove = []
+    	for i, msg in enumerate(conversation_history):
+    		if msg.get("role") == "system" and msg.get("content", "").startswith(IMAGE_ANALYSIS_MARKER):
+    			# Calculer le nombre de messages après cette analyse
+    			messages_after = len(conversation_history) - i - 1
+    			if messages_after >= IMAGE_ANALYSIS_HISTORY_LIMIT:
+    				indices_to_remove.append(i)
+
+    	# Supprimer les analyses d'images identifiées
+    	for i in reversed(indices_to_remove):
+    		del conversation_history[i]
+    		logger.info(f"Analyse d'image à l'index {i} supprimée après {IMAGE_ANALYSIS_HISTORY_LIMIT} nouveaux messages.")
+
+    # Limiter l'historique à STANDARD_HISTORY_LIMIT messages
+    if len(conversation_history) > STANDARD_HISTORY_LIMIT:
+        excess_messages = len(conversation_history) - STANDARD_HISTORY_LIMIT
+        conversation_history = conversation_history[excess_messages:]
+        logger.debug(f"{excess_messages} messages les plus anciens ont été supprimés pour maintenir l'historique à {STANDARD_HISTORY_LIMIT} messages.")
+
+    save_conversation_history()

logger.py

@@ -0,0 +1,28 @@
+# Configurer et initialiser le système de journalisation (logging).
+
+import logging
+from config import BOT_NAME
+
+# Configuration du format de log
+log_format = '%(asctime)-13s : %(name)-15s : %(levelname)-8s : %(message)s'
+
+# Configuration de base du logger avec un fichier de log
+logging.basicConfig(
+    handlers=[logging.FileHandler("./chatbot.log", 'a', 'utf-8')],
+    format=log_format,
+    level=logging.INFO
+)
+
+# Configuration du logger pour la console
+console = logging.StreamHandler()
+console.setLevel(logging.INFO)
+console.setFormatter(logging.Formatter(log_format))
+
+# Création du logger principal
+logger = logging.getLogger(BOT_NAME)
+logger.setLevel(logging.INFO)
+logger.addHandler(console)
+
+# Configuration spécifique pour httpx
+httpx_logger = logging.getLogger('httpx')
+httpx_logger.setLevel(logging.WARNING)

main.py

@@ -0,0 +1,7 @@
+# Point d'entrée principal pour démarrer le bot Discord.
+
+from bot import client_discord
+from config import DISCORD_TOKEN
+
+# Démarrer le bot Discord
+client_discord.run(DISCORD_TOKEN)

openai_client.py

@@ -0,0 +1,213 @@
+# Initialiser le client OpenAI et définir les fonctions d'interaction avec l'API OpenAI.
+
+from openai import AsyncOpenAI, OpenAIError
+from config import OPENAI_API_KEY, PERSONALITY_PROMPT
+from logger import logger
+from utils import calculate_cost
+from history import add_to_conversation_history
+
+# Initialiser le client OpenAI asynchrone
+openai_client = AsyncOpenAI(api_key=OPENAI_API_KEY)
+
+IMAGE_ANALYSIS_MARKER = "__IMAGE_ANALYSIS__:"
+
+async def call_gpt4o_for_image_analysis(image_data, user_text=None, detail='high'):
+    try:
+        # Préparer le prompt
+        if user_text:
+            prompt = (
+                "Tu es un expert en analyse d'images et de textes. "
+                "On te présente une image ou un texte qui pourrait contenir des informations importantes. "
+                f"Voici ce que l'on te décrit : \"{user_text}\". "
+                "Analyse chaque détail de manière méticuleuse. "
+                "Si l'image montre un environnement sans personnage, décris minutieusement les objets, leur disposition, les couleurs, textures, formes, et tout autre élément notable. "
+                "Si du texte est présent, analyse chaque mot attentivement : style, mise en page, ou tout détail subtil qui pourrait en révéler plus sur le contexte ou l'intention. "
+                "Si des personnages sont présents, décris-les avec précision : leur posture, apparence physique, vêtements, et fais une estimation de leurs mensurations (taille, tour de poitrine, taille, hanches, etc.). "
+                "Sois attentif aux expressions et aux petits détails dans leur attitude ou apparence qui pourraient donner des indications supplémentaires. "
+                "N'oublie aucun détail, car chaque aspect pourrait être révélateur dans cette analyse."
+            )
+        else:
+            prompt = (
+                "Tu es un expert en analyse d'images et de textes. "
+                "On te présente une image ou un texte qui pourrait contenir des informations importantes. "
+                "Analyse chaque détail de manière méticuleuse. "
+                "Si l'image montre un environnement sans personnage, décris minutieusement les objets, leur disposition, les couleurs, textures, formes, et tout autre élément notable. "
+                "Si du texte est présent, analyse chaque mot attentivement : style, mise en page, ou tout détail subtil qui pourrait en révéler plus sur le contexte ou l'intention. "
+                "Si des personnages sont présents, décris-les avec précision : leur posture, apparence physique, vêtements, et fais une estimation de leurs mensurations (taille, tour de poitrine, taille, hanches, etc.). "
+                "Sois attentif aux expressions et aux petits détails dans leur attitude ou apparence qui pourraient donner des indications supplémentaires. "
+                "N'oublie aucun détail, car chaque aspect pourrait être révélateur dans cette analyse."
+            )
+
+        message_to_send = {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": prompt},   
+                {
+                    "type": "image_url",
+                    "image_url": {
+                        "url": f"data:image/jpeg;base64,{image_data}",
+                        "detail": detail
+                    }
+                }
+            ]
+        }
+
+        # Appel à GPT-4o
+        response = await openai_client.chat.completions.create(
+            model="gpt-4o",
+            messages=[message_to_send],
+            max_tokens=4096
+        )
+
+        if response:
+            analysis = response.choices[0].message.content
+            logger.info(f"Analyse de l'image par GPT-4o : {analysis}")
+
+            # Calcul et affichage du coût
+            if hasattr(response, 'usage') and response.usage:
+                usage = {
+                    'prompt_tokens': response.usage.prompt_tokens,
+                    'completion_tokens': response.usage.completion_tokens
+                }
+                input_tokens, output_tokens, total_cost = calculate_cost(usage, model='gpt-4o')
+                logger.info(f"Coût de l'analyse de l'image : ${total_cost:.4f} / Input: {input_tokens} / Output: {output_tokens}")
+            else:
+                logger.warning("Informations d'utilisation non disponibles pour le calcul du coût.")
+
+            # Ajouter l'analyse à l'historique avec le marqueur
+            analysis_message = {
+            	"role": "system",
+            	"content": f"{IMAGE_ANALYSIS_MARKER}{analysis}"
+            }
+            await add_to_conversation_history(analysis_message)
+
+            return analysis
+        else:
+            return None 
+
+    except OpenAIError as e:
+        logger.error(f"Erreur lors de l'analyse de l'image avec GPT-4o: {e}")
+        return None
+
+async def call_gpt4o_mini_with_analysis(analysis_text, user_name, user_question, has_text, conversation_history):
+    try:
+        # Préparer le message avec le prompt de personnalité et l'analyse
+        messages = [
+            {"role": "system", "content": PERSONALITY_PROMPT},
+            {
+                "role": "system",
+                "content": f"L'analyse de l'image fournie est la suivante :\n{analysis_text}\n\n"
+            }
+        ]
+
+        if has_text:
+            # Préparer le message utilisateur avec le texte
+            user_message = {
+                "role": "user",
+                "content": (
+                    "Tu es Rika, une femme de 24 ans et membre à part entière du serveur Discord sur lequel tu te trouves. "
+                    f"{user_name} a posté un message contenant une image et a écrit avec : '{user_question}'.\n"
+                    "Réponds à l'utilisateur en te basant sur l'analyse, avec ta personnalité. "
+                    "Ne mentionne pas explicitement que l'analyse est pré-existante, fais comme si tu l'avais faite toi-même."
+                )
+            }
+        else:
+            # Préparer une instruction pour commenter l'image sans texte
+            user_message = {
+                "role": "user",
+                "content": (
+                    "Tu es Rika, une femme de 24 ans et membre à part entière du serveur Discord sur lequel tu te trouves. "
+                    f"{user_name} a partagé une image sans texte additionnel.\n"
+                    "Commente l'image en te basant sur l'analyse, avec ta personnalité. "
+                    "Ne mentionne pas que l'analyse a été fournie à l'avance, réagis comme si tu l'avais toi-même effectuée."
+                )
+            }
+
+        # Inclure l'historique de conversation
+        messages += conversation_history
+        messages.append(user_message)
+
+        # Appel à GPT-4o Mini pour répondre
+        response = await openai_client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=messages,
+            max_tokens=450
+        )
+
+        if response:
+            reply = response.choices[0].message.content
+
+            # Calculer et enregistrer le coût de la réponse de GPT-4o Mini
+            if hasattr(response, 'usage') and response.usage:
+                usage = {
+                    'prompt_tokens': response.usage.prompt_tokens,
+                    'completion_tokens': response.usage.completion_tokens
+                }
+                input_tokens, output_tokens, total_cost = calculate_cost(usage, model='gpt-4o-mini')
+                logger.info(f"Coût de la réponse de GPT-4o Mini : ${total_cost:.4f} / Input: {input_tokens} / Output: {output_tokens}")
+            else:
+                logger.warning("Informations d'utilisation non disponibles pour le calcul du coût de GPT-4o Mini.")
+
+            return reply
+        else:
+            return None
+
+    except OpenAIError as e:
+        logger.error(f"Erreur lors de la génération de réponse avec GPT-4o Mini: {e}")
+        return None
+
+async def call_openai_api(user_text, user_name, conversation_history, image_data=None, detail='high'):
+    try:
+        # Préparer le contenu pour l'appel API
+        message_to_send = {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": f"{user_name} dit : {user_text}"}
+            ]
+        }
+
+        # Inclure l'image dans l'appel API courant
+        if image_data:
+            message_to_send["content"].append({
+                "type": "image_url",
+                "image_url": {
+                    "url": f"data:image/jpeg;base64,{image_data}",
+                    "detail": detail
+                }
+            })
+
+        # Assembler les messages avec le prompt de personnalité en premier
+        messages = [
+            {"role": "system", "content": PERSONALITY_PROMPT}
+        ] + conversation_history + [message_to_send]
+
+        response = await openai_client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=messages,
+            max_tokens=400,
+            temperature=1.0
+        )
+
+        if response:
+            reply = response.choices[0].message.content
+
+            # Calculer et enregistrer le coût de la réponse de GPT-4o Mini
+            if hasattr(response, 'usage') and response.usage:
+                usage = {
+                    'prompt_tokens': response.usage.prompt_tokens,
+                    'completion_tokens': response.usage.completion_tokens
+                }
+                input_tokens, output_tokens, total_cost = calculate_cost(usage, model='gpt-4o-mini')
+                logger.info(f"Coût de la réponse : ${total_cost:.4f} / Input: {input_tokens} / Output: {output_tokens} / Total: {input_tokens + output_tokens}")
+            else:
+                logger.warning("Informations d'utilisation non disponibles pour le calcul du coût.")
+
+            return response
+        else:
+            return None
+
+    except OpenAIError as e:
+        logger.error(f"Error calling OpenAI API: {e}")
+    except Exception as e:
+        logger.error(f"Error calling OpenAI API: {e}")
+    return None

requirements.txt

@@ -1,7 +1,6 @@
 discord.py==2.4.0
 python-dotenv==1.0.1
 Pillow==10.4.0
-emoji==2.12.1
 tiktoken==0.7.0
-openai==1.47.0
-httpx==0.27.2
+openai==1.48.0
+httpx==0.24.0

utils.py

@@ -0,0 +1,112 @@
+# Contenir les fonctions utilitaires auxiliaires.
+
+import re
+import os
+import base64
+from io import BytesIO
+from PIL import Image
+from logger import logger
+import tiktoken
+
+def has_text(text):
+    """
+    Détermine si le texte fourni est non vide après suppression des espaces.
+    """
+    return bool(text.strip())
+
+def resize_image(image_bytes, mode='high', attachment_filename=None):
+    try:
+        with Image.open(BytesIO(image_bytes)) as img:
+            original_format = img.format  # Stocker le format original
+
+            if mode == 'high':
+                # Redimensionner pour le mode haute fidélité
+                img.thumbnail((2000, 2000))
+                if min(img.size) < 768:
+                    scale = 768 / min(img.size)
+                    new_size = tuple(int(x * scale) for x in img.size)
+                    img = img.resize(new_size, Image.Resampling.LANCZOS)
+            elif mode == 'low':
+                # Redimensionner pour le mode basse fidélité
+                img = img.resize((512, 512))
+
+            buffer = BytesIO()
+
+            img_format = img.format
+            if not img_format:
+                if attachment_filename:
+                    _, ext = os.path.splitext(attachment_filename)
+                    ext = ext.lower()
+                    format_mapping = {
+                        '.jpg': 'JPEG',
+                        '.jpeg': 'JPEG',
+                        '.png': 'PNG',
+                        '.gif': 'GIF',
+                        '.bmp': 'BMP',
+                        '.tiff': 'TIFF'
+                    }
+                    img_format = format_mapping.get(ext, 'PNG')
+                else:
+                    img_format = 'PNG'
+
+            img.save(buffer, format=img_format)
+            return buffer.getvalue()
+    except Exception as e:
+        logger.error(f"Error resizing image: {e}")
+        raise
+
+def extract_text_from_message(message):
+    content = message.get("content", "")
+    if isinstance(content, list):
+        # Extraire le texte de chaque élément de la liste
+        texts = []
+        for part in content:
+            if isinstance(part, dict):
+                text = part.get("text", "")
+                if text:
+                    texts.append(text)
+        return ' '.join(texts)
+    elif isinstance(content, str):
+        return content
+    else:
+        return ""
+
+def calculate_cost(usage, model='gpt-4o-mini'):
+    input_tokens = usage.get('prompt_tokens', 0)
+    output_tokens = usage.get('completion_tokens', 0)
+
+    # Définir les tarifs par modèle
+    model_costs = {
+        'gpt-4o': {
+            'input_rate': 5.00 / 1_000_000,    # 5$ pour 1M tokens d'entrée
+            'output_rate': 15.00 / 1_000_000  # 15$ pour 1M tokens de sortie
+        },
+        'gpt-4o-mini': {
+            'input_rate': 0.150 / 1_000_000,   # 0.150$ pour 1M tokens d'entrée
+            'output_rate': 0.600 / 1_000_000   # 0.600$ pour 1M tokens de sortie
+        }
+    }
+
+    # Obtenir les tarifs du modèle spécifié
+    if model not in model_costs:
+        logger.warning(f"Modèle inconnu '{model}'. Utilisation des tarifs par défaut pour 'gpt-4o-mini'.")
+        model = 'gpt-4o-mini'
+
+    input_rate = model_costs[model]['input_rate']
+    output_rate = model_costs[model]['output_rate']
+
+    # Calculer les coûts
+    input_cost = input_tokens * input_rate
+    output_cost = output_tokens * output_rate
+    total_cost = input_cost + output_cost
+
+    return input_tokens, output_tokens, total_cost
+
+async def read_text_file(attachment):
+    file_bytes = await attachment.read()
+    return file_bytes.decode('utf-8')
+
+async def encode_image_from_attachment(attachment, mode='high'):
+    image_data = await attachment.read()
+    resized_image = resize_image(image_data, mode=mode, attachment_filename=attachment.filename)
+    return base64.b64encode(resized_image).decode('utf-8')