django-lucy-assist 0.1.0__py3-none-any.whl

lucy_assist/tests/test_lucy_assist.py

@@ -0,0 +1,186 @@
+"""
+Tests pour Lucy Assist.
+"""
+from django.test import TestCase
+from django.urls import reverse
+
+from lucy_assist.models import Conversation, Message, ConfigurationLucyAssist
+from lucy_assist.tests.factories import (
+    ConfigurationLucyAssistFactory,
+    ConversationFactory,
+    MessageUtilisateurFactory,
+    MessageChatbotFactory,
+)
+from apps.utilisateur.tests.factories import UtilisateurAdminUnafFactory
+
+
+class TestConfigurationLucyAssist(TestCase):
+    """Tests pour le modèle ConfigurationLucyAssist."""
+
+    def setUp(self):
+        self.user = UtilisateurAdminUnafFactory()
+        self.client.force_login(self.user)
+
+    # -----------------------------------------------------------------
+    # CONFIGURATION SINGLETON
+    # -----------------------------------------------------------------
+    def test_configuration_singleton_ok(self):
+        """Vérifie que la configuration est un singleton."""
+        config1 = ConfigurationLucyAssist.get_config()
+        config2 = ConfigurationLucyAssist.get_config()
+
+        self.assertEqual(config1.pk, config2.pk)
+        self.assertEqual(config1.pk, 1)
+
+    def test_ajouter_tokens_ok(self):
+        """Vérifie l'ajout de tokens."""
+        config = ConfigurationLucyAssist.get_config()
+        initial_tokens = config.tokens_disponibles
+
+        tokens_ajoutes = config.ajouter_tokens(10)  # 10€
+
+        self.assertEqual(tokens_ajoutes, 1_000_000)
+        self.assertEqual(config.tokens_disponibles, initial_tokens + 1_000_000)
+
+    def test_get_questions_frequentes_default_ok(self):
+        """Vérifie les questions fréquentes par défaut."""
+        config = ConfigurationLucyAssist.get_config()
+        config.questions_frequentes = []
+        config.save()
+
+        questions = config.get_questions_frequentes()
+
+        self.assertIsInstance(questions, list)
+        self.assertGreater(len(questions), 0)
+
+
+class TestConversation(TestCase):
+    """Tests pour le modèle Conversation."""
+
+    def setUp(self):
+        self.user = UtilisateurAdminUnafFactory()
+        self.client.force_login(self.user)
+        ConfigurationLucyAssistFactory()
+
+    # -----------------------------------------------------------------
+    # CRÉATION
+    # -----------------------------------------------------------------
+    def test_create_conversation_ok(self):
+        """Vérifie la création d'une conversation."""
+        conversation = ConversationFactory(utilisateur=self.user)
+
+        self.assertIsNotNone(conversation.pk)
+        self.assertEqual(conversation.utilisateur, self.user)
+        self.assertTrue(conversation.is_active)
+
+    def test_generer_titre_ok(self):
+        """Vérifie la génération automatique du titre."""
+        conversation = ConversationFactory(utilisateur=self.user, titre=None)
+        MessageUtilisateurFactory(
+            conversation=conversation,
+            contenu="Comment créer un membre ?"
+        )
+
+        conversation.generer_titre()
+
+        self.assertIsNotNone(conversation.titre)
+        self.assertIn("Comment créer", conversation.titre)
+
+
+class TestMessage(TestCase):
+    """Tests pour le modèle Message."""
+
+    def setUp(self):
+        self.user = UtilisateurAdminUnafFactory()
+        self.client.force_login(self.user)
+        ConfigurationLucyAssistFactory()
+
+    # -----------------------------------------------------------------
+    # CRÉATION
+    # -----------------------------------------------------------------
+    def test_create_message_utilisateur_ok(self):
+        """Vérifie la création d'un message utilisateur."""
+        conversation = ConversationFactory(utilisateur=self.user)
+        message = MessageUtilisateurFactory(conversation=conversation)
+
+        self.assertIsNotNone(message.pk)
+        self.assertTrue(message.est_utilisateur)
+        self.assertFalse(message.est_chatbot)
+
+    def test_create_message_chatbot_ok(self):
+        """Vérifie la création d'un message chatbot."""
+        conversation = ConversationFactory(utilisateur=self.user)
+        message = MessageChatbotFactory(conversation=conversation)
+
+        self.assertIsNotNone(message.pk)
+        self.assertTrue(message.est_chatbot)
+        self.assertFalse(message.est_utilisateur)
+        self.assertGreater(message.tokens_utilises, 0)
+
+
+class TestAPIViews(TestCase):
+    """Tests pour les vues API Lucy Assist."""
+
+    def setUp(self):
+        self.user = UtilisateurAdminUnafFactory()
+        self.client.force_login(self.user)
+        self.config = ConfigurationLucyAssistFactory(tokens_disponibles=1_000_000)
+
+    # -----------------------------------------------------------------
+    # LISTE CONVERSATIONS
+    # -----------------------------------------------------------------
+    def test_conversation_list_ok(self):
+        """Vérifie que la liste des conversations est accessible."""
+        ConversationFactory(utilisateur=self.user)
+        ConversationFactory(utilisateur=self.user)
+
+        url = reverse("lucy_assist:api-conversations")
+        response = self.client.get(url)
+
+        self.assertEqual(response.status_code, 200)
+        data = response.json()
+        self.assertIn('conversations', data)
+        self.assertEqual(len(data['conversations']), 2)
+
+    # -----------------------------------------------------------------
+    # CRÉATION CONVERSATION
+    # -----------------------------------------------------------------
+    def test_conversation_create_ok(self):
+        """Vérifie la création d'une conversation via API."""
+        initial_count = Conversation.objects.count()
+
+        url = reverse("lucy_assist:api-conversations")
+        response = self.client.post(
+            url,
+            data={'page_contexte': '/membre/list'},
+            content_type='application/json'
+        )
+
+        self.assertEqual(response.status_code, 201)
+        self.assertEqual(Conversation.objects.count(), initial_count + 1)
+
+    # -----------------------------------------------------------------
+    # STATUT TOKENS
+    # -----------------------------------------------------------------
+    def test_token_status_ok(self):
+        """Vérifie le statut des tokens."""
+        url = reverse("lucy_assist:api-token-status")
+        response = self.client.get(url)
+
+        self.assertEqual(response.status_code, 200)
+        data = response.json()
+        self.assertIn('tokens_disponibles', data)
+        self.assertEqual(data['tokens_disponibles'], 1_000_000)
+
+    # -----------------------------------------------------------------
+    # SUGGESTIONS
+    # -----------------------------------------------------------------
+    def test_suggestions_ok(self):
+        """Vérifie les suggestions de questions."""
+        url = reverse("lucy_assist:api-suggestions")
+        response = self.client.get(url)
+
+        self.assertEqual(response.status_code, 200)
+        data = response.json()
+        self.assertIn('suggestions', data)
+        self.assertIsInstance(data['suggestions'], list)

lucy_assist/urls.py

@@ -0,0 +1,36 @@
+"""
+URLs pour Lucy Assist.
+
+Ce module définit toutes les routes de l'application Lucy Assist,
+incluant les API REST et les vues de documentation.
+"""
+from django.urls import path
+
+from lucy_assist import views
+
+app_name = "lucy_assist"
+
+urlpatterns = [
+    # API - Conversations
+    path("api/conversations", views.ConversationListCreateView.as_view(), name="api-conversations"),
+    path("api/conversations/<int:pk>", views.ConversationDetailView.as_view(), name="api-conversation-detail"),
+
+    # API - Messages
+    path("api/conversations/<int:conversation_id>/messages", views.MessageCreateView.as_view(), name="api-messages"),
+    path("api/conversations/<int:conversation_id>/chat", views.ChatCompletionView.as_view(), name="api-chat"),
+
+    # API - Tokens
+    path("api/tokens/status", views.TokenStatusView.as_view(), name="api-token-status"),
+    path("api/tokens/buy", views.AcheterTokensView.as_view(), name="api-token-buy"),
+
+    # API - Utilitaires
+    path("api/suggestions", views.SuggestionsView.as_view(), name="api-suggestions"),
+    path("api/context", views.PageContextView.as_view(), name="api-context"),
+
+    # API - Cache (admin only)
+    path("api/cache/stats", views.CacheStatsView.as_view(), name="api-cache-stats"),
+    path("api/cache/invalidate", views.CacheInvalidateView.as_view(), name="api-cache-invalidate"),
+
+    # API - Feedback
+    path("api/feedback", views.FeedbackCreateView.as_view(), name="api-feedback"),
+]

lucy_assist/utils/__init__.py

@@ -0,0 +1,7 @@
+from .token_utils import TokenUtils
+from .message_utils import MessageUtils
+
+__all__ = [
+    'TokenUtils',
+    'MessageUtils',
+]

lucy_assist/utils/log_utils.py

@@ -0,0 +1,59 @@
+"""
+Utilitaire de logging pour Lucy Assist.
+Version simplifiée et autonome.
+"""
+import inspect
+import logging
+import os
+
+from django.conf import settings
+
+logger = logging.getLogger("lucy_assist")
+
+
+class LogUtils:
+    """
+    Classe générique de gestion des logs pour Lucy Assist.
+    Format: lucy_assist [$className.$methodName] - $message
+    """
+
+    @staticmethod
+    def _get_caller_info():
+        """Récupère les informations sur l'appelant."""
+        try:
+            frame = inspect.stack()[2]
+            class_name = frame[0].f_locals.get("self", None)
+            if class_name:
+                class_name = class_name.__class__.__name__
+            else:
+                # Méthode statique ou fonction
+                class_name = frame[0].f_globals.get('__name__', 'unknown').split('.')[-1]
+
+            method_name = frame[3]
+            return f"{class_name}.{method_name}"
+        except Exception:
+            return "unknown"
+
+    @staticmethod
+    def info(msg=None):
+        """Log un message de niveau INFO."""
+        caller = LogUtils._get_caller_info()
+        logger.info(f"lucy_assist [{caller}] - {msg}")
+
+    @staticmethod
+    def warning(msg=None):
+        """Log un message de niveau WARNING."""
+        caller = LogUtils._get_caller_info()
+        logger.warning(f"lucy_assist [{caller}] - {msg}")
+
+    @staticmethod
+    def debug(msg=None):
+        """Log un message de niveau DEBUG."""
+        caller = LogUtils._get_caller_info()
+        logger.debug(f"lucy_assist [{caller}] - {msg}")
+
+    @staticmethod
+    def error(msg=None):
+        """Log un message de niveau ERROR."""
+        caller = LogUtils._get_caller_info()
+        logger.error(f"lucy_assist [{caller}] - {msg}")

lucy_assist/utils/message_utils.py

@@ -0,0 +1,130 @@
+"""
+Utilitaires pour le formatage des messages Lucy Assist.
+Sans impact sur la base de données.
+"""
+import re
+from typing import List, Dict
+
+
+class MessageUtils:
+    """Utilitaires de formatage et transformation des messages."""
+
+    @staticmethod
+    def tronquer_texte(texte: str, max_length: int = 50, suffix: str = "...") -> str:
+        """
+        Tronque un texte à une longueur maximale.
+
+        Args:
+            texte: Texte à tronquer
+            max_length: Longueur maximale
+            suffix: Suffixe à ajouter si tronqué
+
+        Returns:
+            Texte tronqué
+        """
+        if not texte:
+            return ""
+        if len(texte) <= max_length:
+            return texte
+        return texte[:max_length - len(suffix)] + suffix
+
+    @staticmethod
+    def formater_messages_pour_claude(messages: List) -> List[Dict]:
+        """
+        Formate les messages pour l'API Claude.
+
+        Args:
+            messages: Liste de messages (objets Message)
+
+        Returns:
+            Liste de dicts formatés pour Claude
+        """
+        from lucy_assist.constantes import LucyAssistConstantes
+
+        formatted = []
+        for msg in messages:
+            role = "user" if msg.repondant == LucyAssistConstantes.Repondant.UTILISATEUR else "assistant"
+            formatted.append({
+                "role": role,
+                "content": msg.contenu
+            })
+        return formatted
+
+    @staticmethod
+    def extraire_json_de_reponse(texte: str) -> dict:
+        """
+        Extrait un objet JSON d'une réponse texte.
+
+        Args:
+            texte: Texte contenant potentiellement du JSON
+
+        Returns:
+            Dict extrait ou dict vide
+        """
+        import json
+
+        try:
+            # Chercher un bloc JSON dans le texte
+            json_match = re.search(r'\{[^{}]*\}', texte, re.DOTALL)
+            if json_match:
+                return json.loads(json_match.group())
+        except (json.JSONDecodeError, AttributeError):
+            pass
+
+        return {}
+
+    @staticmethod
+    def nettoyer_message(message: str) -> str:
+        """
+        Nettoie un message utilisateur.
+
+        Args:
+            message: Message brut
+
+        Returns:
+            Message nettoyé
+        """
+        if not message:
+            return ""
+
+        # Supprimer les espaces multiples
+        message = re.sub(r'\s+', ' ', message)
+
+        # Trim
+        message = message.strip()
+
+        return message
+
+    @staticmethod
+    def markdown_to_html_basic(texte: str) -> str:
+        """
+        Conversion basique de Markdown vers HTML.
+
+        Args:
+            texte: Texte en markdown
+
+        Returns:
+            Texte en HTML
+        """
+        if not texte:
+            return ""
+
+        # Échapper le HTML
+        texte = texte.replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;')
+
+        # Gras
+        texte = re.sub(r'\*\*(.*?)\*\*', r'<strong>\1</strong>', texte)
+
+        # Italique
+        texte = re.sub(r'\*(.*?)\*', r'<em>\1</em>', texte)
+
+        # Code inline
+        texte = re.sub(r'`(.*?)`', r'<code>\1</code>', texte)
+
+        # Liens
+        texte = re.sub(r'\[([^\]]+)\]\(([^)]+)\)', r'<a href="\2" target="_blank">\1</a>', texte)
+
+        # Sauts de ligne
+        texte = texte.replace('\n', '<br>')
+
+        return texte

lucy_assist/utils/token_utils.py

@@ -0,0 +1,87 @@
+"""
+Utilitaires pour la gestion des tokens Lucy Assist.
+Sans impact sur la base de données.
+"""
+
+
+class TokenUtils:
+    """Utilitaires de calcul et formatage des tokens."""
+
+    PRIX_PAR_MILLION = 10.0
+    TOKENS_PAR_CONVERSATION = 2000
+
+    @staticmethod
+    def calculer_tokens_pour_montant(montant_euros: float, prix_par_million: float = None) -> int:
+        """
+        Calcule le nombre de tokens pour un montant en euros.
+
+        Args:
+            montant_euros: Montant en euros
+            prix_par_million: Prix par million de tokens (défaut: 10€)
+
+        Returns:
+            Nombre de tokens
+        """
+        prix = prix_par_million or TokenUtils.PRIX_PAR_MILLION
+        return int((montant_euros / prix) * 1_000_000)
+
+    @staticmethod
+    def calculer_montant_pour_tokens(tokens: int, prix_par_million: float = None) -> float:
+        """
+        Calcule le montant en euros pour un nombre de tokens.
+
+        Args:
+            tokens: Nombre de tokens
+            prix_par_million: Prix par million de tokens (défaut: 10€)
+
+        Returns:
+            Montant en euros
+        """
+        prix = prix_par_million or TokenUtils.PRIX_PAR_MILLION
+        return (tokens / 1_000_000) * prix
+
+    @staticmethod
+    def estimer_conversations(tokens: int, tokens_par_conversation: int = None) -> int:
+        """
+        Estime le nombre de conversations possibles.
+
+        Args:
+            tokens: Nombre de tokens disponibles
+            tokens_par_conversation: Tokens moyens par conversation (défaut: 2000)
+
+        Returns:
+            Nombre de conversations estimées
+        """
+        tpc = tokens_par_conversation or TokenUtils.TOKENS_PAR_CONVERSATION
+        return int(tokens / tpc) if tpc > 0 else 0
+
+    @staticmethod
+    def formater_tokens(tokens: int) -> str:
+        """
+        Formate un nombre de tokens pour l'affichage.
+
+        Args:
+            tokens: Nombre de tokens
+
+        Returns:
+            String formatée (ex: "1.5M", "500K", "1234")
+        """
+        if tokens >= 1_000_000:
+            return f"{tokens / 1_000_000:.1f}M"
+        elif tokens >= 1_000:
+            return f"{tokens / 1_000:.0f}K"
+        return str(tokens)
+
+    @staticmethod
+    def tokens_suffisants(tokens_disponibles: int, tokens_requis: int = 2000) -> bool:
+        """
+        Vérifie si suffisamment de tokens sont disponibles.
+
+        Args:
+            tokens_disponibles: Tokens actuellement disponibles
+            tokens_requis: Tokens minimum requis
+
+        Returns:
+            True si suffisant
+        """
+        return tokens_disponibles >= tokens_requis

lucy_assist/views/__init__.py

@@ -0,0 +1,13 @@
+from .api_views import (
+    ConversationListCreateView,
+    ConversationDetailView,
+    MessageCreateView,
+    ChatCompletionView,
+    TokenStatusView,
+    AcheterTokensView,
+    SuggestionsView,
+    PageContextView,
+    CacheStatsView,
+    CacheInvalidateView,
+    FeedbackCreateView,
+)