Update modules/studentact/claude_recommendations.py

modules/studentact/claude_recommendations.py

@@ -1,122 +1,259 @@
 # modules/studentact/claude_recommendations.py
-
-import anthropic
 import os
+import anthropic
 import streamlit as st
 import logging
-from typing import Dict, Any
+import time
 import json
+from datetime import datetime, timezone
+
+# Local imports
+from ..utils.widget_utils import generate_unique_key
+from ..database.current_situation_mongo_db import store_current_situation_result
 
 logger = logging.getLogger(__name__)
 
-def generate_claude_recommendations(text: str, metrics: Dict[str, Any], text_type: str, lang_code: str):
-    """
-    Genera recomendaciones personalizadas utilizando la API de Claude.
-    
-    Args:
-        text: El texto original que se analizó
-        metrics: Métricas calculadas por el sistema
-        text_type: Tipo de texto (academic_article, student_essay, general_communication)
-        lang_code: Código del idioma
-        
-    Returns:
-        str: HTML formateado con recomendaciones personalizadas
-    """
-    # Diccionario para traducción de tipos de texto
-    text_type_names = {
+# Define text types
+TEXT_TYPES = {
+    'es': {
         'academic_article': 'artículo académico',
-        'student_essay': 'trabajo universitario',
+        'university_work': 'trabajo universitario',
         'general_communication': 'comunicación general'
+    },
+    'en': {
+        'academic_article': 'academic article',
+        'university_work': 'university work',
+        'general_communication': 'general communication'
+    },
+    'fr': {
+        'academic_article': 'article académique',
+        'university_work': 'travail universitaire',
+        'general_communication': 'communication générale'
     }
+}
+
+# Cache for recommendations to avoid redundant API calls
+recommendation_cache = {}
+
+def get_recommendation_cache_key(text, metrics, text_type, lang_code):
+    """
+    Generate a cache key for recommendations.
+    """
+    # Create a simple hash based on text content and metrics
+    text_hash = hash(text[:1000])  # Only use first 1000 chars for hashing
+    metrics_hash = hash(json.dumps(metrics, sort_keys=True))
+    return f"{text_hash}_{metrics_hash}_{text_type}_{lang_code}"
+
+def format_metrics_for_claude(metrics, lang_code, text_type):
+    """
+    Format metrics in a way that's readable for Claude
+    """
+    formatted_metrics = {}
+    for key, value in metrics.items():
+        if isinstance(value, (int, float)):
+            formatted_metrics[key] = round(value, 2)
+        else:
+            formatted_metrics[key] = value
     
-    # Identificar las áreas más débiles (ordenadas de peor a mejor)
-    areas = ['vocabulary', 'structure', 'cohesion', 'clarity']
-    scores = {area: metrics[area]['normalized_score'] for area in areas}
-    weak_areas = sorted(areas, key=lambda x: scores[x])
+    # Add context about what type of text this is
+    text_type_label = TEXT_TYPES.get(lang_code, {}).get(text_type, text_type)
+    formatted_metrics['text_type'] = text_type_label
     
+    return formatted_metrics
+
+def generate_claude_recommendations(text, metrics, text_type, lang_code):
+    """
+    Generate personalized recommendations using Claude API.
+    """
     try:
         api_key = os.environ.get("ANTHROPIC_API_KEY")
         if not api_key:
-            logger.warning("No se encontró ANTHROPIC_API_KEY en las variables de entorno")
-            return fallback_recommendations(weak_areas)
-            
-        client = anthropic.Anthropic(api_key=api_key)
+            logger.error("Claude API key not found in environment variables")
+            return get_fallback_recommendations(lang_code)
         
-        # Truncar el texto si es muy largo para evitar exceder límites de tokens
-        truncated_text = text[:1000] + "..." if len(text) > 1000 else text
+        # Check cache first
+        cache_key = get_recommendation_cache_key(text, metrics, text_type, lang_code)
+        if cache_key in recommendation_cache:
+            logger.info("Using cached recommendations")
+            return recommendation_cache[cache_key]
         
-        # Construir el prompt para Claude
-        prompt = f"""
-        Actúa como un asistente experto en escritura académica y comunicación.
+        # Format metrics for Claude
+        formatted_metrics = format_metrics_for_claude(metrics, lang_code, text_type)
         
-        Analiza el siguiente texto (clasificado como {text_type_names.get(text_type, text_type)}) y genera recomendaciones personalizadas para mejorarlo.
+        # Determine language for prompt
+        if lang_code == 'es':
+            system_prompt = """Eres un asistente especializado en análisis de textos académicos y comunicación escrita. 
+            Tu tarea es analizar el texto del usuario y proporcionar recomendaciones personalizadas.
+            Usa un tono constructivo y específico. Sé claro y directo con tus sugerencias.
+            """
+            user_prompt = f"""Por favor, analiza este texto de tipo '{formatted_metrics['text_type']}' 
+            y proporciona recomendaciones personalizadas para mejorarlo.
+            
+            MÉTRICAS DE ANÁLISIS:
+            {json.dumps(formatted_metrics, indent=2, ensure_ascii=False)}
+            
+            TEXTO A ANALIZAR:
+            {text[:2000]}  # Limitamos el texto para evitar exceder tokens
+            
+            Proporciona tu análisis con el siguiente formato:
+            1. Un resumen breve (2-3 frases) del análisis general 
+            2. 3-4 recomendaciones específicas y accionables (cada una de 1-2 frases)
+            3. Un ejemplo concreto de mejora tomado del propio texto del usuario
+            4. Una sugerencia sobre qué herramienta de AIdeaText usar (Análisis Morfosintáctico, Análisis Semántico o Análisis del Discurso)
+            
+            Tu respuesta debe ser concisa y no exceder los 300 palabras."""
+        else:
+            # Default to English
+            system_prompt = """You are an assistant specialized in analyzing academic texts and written communication.
+            Your task is to analyze the user's text and provide personalized recommendations.
+            Use a constructive and specific tone. Be clear and direct with your suggestions.
+            """
+            user_prompt = f"""Please analyze this text of type '{formatted_metrics['text_type']}' 
+            and provide personalized recommendations to improve it.
+            
+            ANALYSIS METRICS:
+            {json.dumps(formatted_metrics, indent=2, ensure_ascii=False)}
+            
+            TEXT TO ANALYZE:
+            {text[:2000]}  # Limiting text to avoid exceeding tokens
+            
+            Provide your analysis with the following format:
+            1. A brief summary (2-3 sentences) of the general analysis
+            2. 3-4 specific and actionable recommendations (each 1-2 sentences)
+            3. A concrete example of improvement taken from the user's own text
+            4. A suggestion about which AIdeaText tool to use (Morphosyntactic Analysis, Semantic Analysis or Discourse Analysis)
+            
+            Your response should be concise and not exceed 300 words."""
         
-        Las métricas de análisis del texto son:
-        - Vocabulario: {scores['vocabulary']:.2f}/1.00
-        - Estructura: {scores['structure']:.2f}/1.00
-        - Cohesión: {scores['cohesion']:.2f}/1.00
-        - Claridad: {scores['clarity']:.2f}/1.00
+        # Initialize Claude client
+        client = anthropic.Anthropic(api_key=api_key)
         
-        Áreas que necesitan mayor atención (de mayor a menor prioridad):
-        {', '.join([area for area in weak_areas[:2]])}
+        # Call Claude API
+        start_time = time.time()
+        response = client.messages.create(
+            model="claude-3-5-sonnet-20241022",
+            max_tokens=1024,
+            temperature=0.7,
+            system=system_prompt,
+            messages=[
+                {"role": "user", "content": user_prompt}
+            ]
+        )
+        logger.info(f"Claude API call completed in {time.time() - start_time:.2f} seconds")
         
-        Texto analizado:
-        "{truncated_text}"
+        # Extract recommendations
+        recommendations = response.content[0].text
         
-        Por favor, proporciona:
-        1. Un breve resumen del análisis (2-3 oraciones)
-        2. 3-4 recomendaciones específicas para mejorar el texto, identificando problemas concretos que has detectado
-        3. Un ejemplo concreto de cómo mejorar una frase del texto (si es posible)
+        # Cache the result
+        recommendation_cache[cache_key] = recommendations
         
-        Utiliza un tono profesional pero amigable, y estructura tus recomendaciones en HTML simple usando etiquetas <h4>, <p>, <ul>, <li>, y <strong>.
+        return recommendations
+    except Exception as e:
+        logger.error(f"Error generating recommendations with Claude: {str(e)}")
+        return get_fallback_recommendations(lang_code)
+
+def get_fallback_recommendations(lang_code):
+    """
+    Return fallback recommendations if Claude API fails
+    """
+    if lang_code == 'es':
+        return """
+        **Análisis General**
+        Tu texto presenta una estructura básica adecuada, pero hay áreas que pueden mejorarse para mayor claridad y cohesión.
+
+        **Recomendaciones**:
+        - Intenta variar tu vocabulario para evitar repeticiones innecesarias
+        - Considera revisar la longitud de tus oraciones para mantener un mejor ritmo
+        - Asegúrate de establecer conexiones claras entre las ideas principales
+        - Revisa la consistencia en el uso de tiempos verbales
+
+        **Herramienta recomendada**: 
+        Te sugerimos utilizar el Análisis Morfosintáctico para identificar patrones en tu estructura de oraciones.
         """
+    else:
+        return """
+        **General Analysis**
+        Your text presents an adequate basic structure, but there are areas that can be improved for better clarity and cohesion.
         
-        # Llamada a la API de Claude
-        try:
-            message = client.messages.create(
-                model="claude-3-5-sonnet-20241022",
-                max_tokens=1000,
-                temperature=0.3,
-                system="Eres un asistente experto en análisis textual que proporciona recomendaciones claras y útiles para mejorar textos.",
-                messages=[
-                    {"role": "user", "content": prompt}
-                ]
-            )
-            
-            # Obtener la respuesta
-            response = message.content[0].text
-            
-            # Guardar en caché para uso futuro
-            cache_key = f"claude_recommendations_{text_type}_{weak_areas[0]}"
-            st.session_state[cache_key] = response
-            
-            return response
-            
-        except Exception as api_error:
-            logger.error(f"Error en la llamada a la API de Claude: {str(api_error)}")
-            return fallback_recommendations(weak_areas)
+        **Recommendations**:
+        - Try to vary your vocabulary to avoid unnecessary repetition
+        - Consider reviewing the length of your sentences to maintain a better rhythm
+        - Make sure to establish clear connections between main ideas
+        - Check consistency in the use of verb tenses
         
-    except Exception as e:
-        logger.error(f"Error generando recomendaciones con Claude: {str(e)}")
-        return fallback_recommendations(weak_areas)
+        **Recommended tool**: 
+        We suggest using Morphosyntactic Analysis to identify patterns in your sentence structure.
+        """
 
-def fallback_recommendations(weak_areas):
-    """Recomendaciones de respaldo en caso de fallo con la API"""
-    area_names = {
-        'vocabulary': 'vocabulario',
-        'structure': 'estructura',
-        'cohesion': 'cohesión',
-        'clarity': 'claridad'
-    }
-    
-    return f"""
-    <h4>Recomendaciones para mejorar tu texto</h4>
-    <p>Hemos detectado que las áreas de <strong>{area_names.get(weak_areas[0], weak_areas[0])}</strong> y <strong>{area_names.get(weak_areas[1], weak_areas[1])}</strong> 
-    son las que más podrían beneficiarse de mejoras.</p>
-    <p>Para obtener recomendaciones más detalladas, utiliza el asistente virtual de Claude AI
-    ubicado en la esquina superior izquierda (presiona la flecha junto al logo).</p>
+def store_recommendations(username, text, metrics, text_type, recommendations):
+    """
+    Store the recommendations in the database
     """
+    try:
+        result_data = {
+            'username': username,
+            'timestamp': datetime.now(timezone.utc).isoformat(),
+            'text': text,
+            'metrics': metrics,
+            'text_type': text_type,
+            'recommendations': recommendations,
+            'analysis_type': 'current_situation_claude'
+        }
+        
+        result = store_current_situation_result(result_data)
+        logger.info(f"Recommendations stored with ID: {result}")
+        return True
+    except Exception as e:
+        logger.error(f"Error storing recommendations: {str(e)}")
+        return False
 
 def display_personalized_recommendations(text, metrics, text_type, lang_code, t):
     """
-    Muestra recomendaciones personalizadas
+    Display personalized recommendations based on text analysis
+    """
+    try:
+        # Generate recommendations
+        recommendations = generate_claude_recommendations(text, metrics, text_type, lang_code)
+        
+        # Format and display recommendations in a nice container
+        st.markdown("### 📝 " + t.get('recommendations_title', 'Personalized Recommendations'))
+        
+        with st.container():
+            st.markdown(f"""
+            <div style="padding: 20px; border-radius: 10px; 
+                background-color: #f8f9fa; margin-bottom: 20px;">
+                {recommendations}
+            </div>
+            """, unsafe_allow_html=True)
+            
+            # Add prompt to use assistant
+            st.info("💡 **" + t.get('assistant_prompt', 'For further improvement:') + "** " + 
+                   t.get('assistant_message', 'Open the virtual assistant (powered by Claude AI) in the upper left corner by clicking the arrow next to the logo.'))
+            
+            # Add save button
+            col1, col2, col3 = st.columns([1,1,1])
+            with col2:
+                if st.button(
+                    t.get('save_button', 'Save Analysis'),
+                    key=generate_unique_key("claude_recommendations", "save"),
+                    type="primary",
+                    use_container_width=True
+                ):
+                    if 'username' in st.session_state:
+                        success = store_recommendations(
+                            st.session_state.username,
+                            text,
+                            metrics,
+                            text_type,
+                            recommendations
+                        )
+                        if success:
+                            st.success(t.get('save_success', 'Analysis saved successfully'))
+                        else:
+                            st.error(t.get('save_error', 'Error saving analysis'))
+                    else:
+                        st.error(t.get('login_required', 'Please log in to save analysis'))
+    
+    except Exception as e:
+        logger.error(f"Error displaying recommendations: {str(e)}")
+        st.error(t.get('recommendations_error', 'Error generating recommendations. Please try again later.'))