Create app.py

app.py

@@ -0,0 +1,184 @@
+import gradio as gr
+from transformers import pipeline
+import re
+
+class PromptOptimizer:
+    def __init__(self):
+        self.complexity_patterns = {
+            'context': r'(contexte|situation|cadre)',
+            'specifics': r'(détails|spécifiquement|précisément)',
+            'requirements': r'(requis|nécessaire|obligatoire)',
+            'constraints': r'(contrainte|limite|restriction)'
+        }
+        
+    def analyze_prompt(self, prompt: str) -> dict:
+        """Analyse la structure et la qualité du prompt."""
+        metrics = {
+            'longueur': len(prompt),
+            'complexité': self._calculate_complexity(prompt),
+            'clarté': self._evaluate_clarity(prompt),
+            'structure': self._analyze_structure(prompt)
+        }
+        return metrics
+    
+    def optimize_prompt(self, prompt: str, mode: str = 'expert', complexity: int = 50) -> str:
+        """Optimise le prompt selon le mode et le niveau de complexité souhaités."""
+        # Analyse initiale
+        analysis = self.analyze_prompt(prompt)
+        
+        # Structure de base optimisée
+        template = {
+            'expert': """Instructions détaillées:
+{prompt}
+
+Paramètres d'exécution:
+- Niveau de détail requis: {complexity}%
+- Mode d'analyse: Expert
+- Format attendu: Structuré et exhaustif
+
+Exigences spécifiques:
+1. Analyse approfondie du contexte
+2. Identification des points clés
+3. Propositions d'optimisation
+4. Justification des choix
+
+Contraintes:
+- Réponse précise et argumentée
+- Exemples concrets
+- Solutions applicables""",
+            'creative': """Contexte créatif:
+{prompt}
+
+Paramètres d'inspiration:
+- Niveau d'innovation: {complexity}%
+- Approche: Créative
+- Style: Libre et innovant
+
+Axes de développement:
+1. Exploration des possibilités
+2. Innovation conceptuelle
+3. Associations créatives
+4. Perspectives uniques
+
+Encouragements:
+- Pensée latérale
+- Solutions originales
+- Concepts novateurs""",
+            'technical': """Spécifications techniques:
+{prompt}
+
+Paramètres techniques:
+- Niveau de précision: {complexity}%
+- Approche: Technique
+- Documentation: Détaillée
+
+Points d'attention:
+1. Faisabilité technique
+2. Optimisation des ressources
+3. Standards de qualité
+4. Tests et validation
+
+Exigences:
+- Documentation technique
+- Métriques de performance
+- Recommandations d'implémentation"""
+        }
+        
+        # Sélection et personnalisation du template
+        optimized = template[mode].format(
+            prompt=prompt,
+            complexity=complexity
+        )
+        
+        return optimized
+    
+    def _calculate_complexity(self, prompt: str) -> float:
+        """Calcule la complexité du prompt basée sur plusieurs facteurs."""
+        score = 0
+        # Vérifie la présence de patterns de complexité
+        for pattern in self.complexity_patterns.values():
+            if re.search(pattern, prompt.lower()):
+                score += 0.25
+                
+        # Analyse la structure des phrases
+        sentences = prompt.split('.')
+        avg_length = sum(len(s.split()) for s in sentences) / len(sentences)
+        score += min(avg_length / 20, 0.5)  # Normalise à max 0.5
+        
+        return min(score, 1.0)  # Score final entre 0 et 1
+    
+    def _evaluate_clarity(self, prompt: str) -> float:
+        """Évalue la clarté du prompt."""
+        clarity_score = 0
+        
+        # Vérifie la présence de marqueurs de structure
+        if re.search(r'(premièrement|ensuite|enfin)', prompt.lower()):
+            clarity_score += 0.3
+            
+        # Vérifie la ponctuation appropriée
+        if re.search(r'[.?!]', prompt):
+            clarity_score += 0.2
+            
+        # Vérifie la présence de mots de liaison
+        if re.search(r'(car|donc|ainsi|cependant)', prompt.lower()):
+            clarity_score += 0.3
+            
+        return min(clarity_score, 1.0)
+    
+    def _analyze_structure(self, prompt: str) -> dict:
+        """Analyse la structure du prompt."""
+        return {
+            'paragraphes': len(prompt.split('\n\n')),
+            'phrases': len(prompt.split('.')),
+            'mots': len(prompt.split())
+        }
+
+def create_interface():
+    optimizer = PromptOptimizer()
+    
+    def process_prompt(prompt, mode, complexity):
+        analysis = optimizer.analyze_prompt(prompt)
+        optimized = optimizer.optimize_prompt(prompt, mode, complexity)
+        return {
+            'analyse': analysis,
+            'prompt_optimisé': optimized
+        }
+    
+    # Interface Gradio
+    with gr.Blocks(theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# Optimiseur de Prompts IA")
+        
+        with gr.Row():
+            with gr.Column():
+                input_prompt = gr.Textbox(
+                    label="Prompt Initial",
+                    placeholder="Entrez votre prompt ici...",
+                    lines=5
+                )
+                mode = gr.Radio(
+                    choices=["expert", "creative", "technical"],
+                    label="Mode",
+                    value="expert"
+                )
+                complexity = gr.Slider(
+                    minimum=0,
+                    maximum=100,
+                    value=50,
+                    label="Niveau de Complexité"
+                )
+                optimize_btn = gr.Button("Optimiser")
+            
+            with gr.Column():
+                output = gr.JSON(label="Résultats")
+        
+        optimize_btn.click(
+            fn=process_prompt,
+            inputs=[input_prompt, mode, complexity],
+            outputs=[output]
+        )
+    
+    return demo
+
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch()