Update app.py

app.py

@@ -293,93 +293,127 @@ def api_francais():
     # Prompt utilisateur
     user_prompt = f"Sujet: {sujet}\nType: {choix}\nStyle: {style}"
 
-    def generate_stream():
-        try:
-            logger.info("Démarrage du streaming de génération...")
-            content_generated = False
-            chunk_count = 0
-            
-            for chunk in client.models.generate_content_stream(
-                model=model_name,
-                contents=[user_prompt],
-                config=config
-            ):
-                chunk_count += 1
-                
-                # Vérifier si la réponse a été bloquée
-                if hasattr(chunk, 'prompt_feedback') and chunk.prompt_feedback:
-                    logger.warning(f"Prompt feedback: {chunk.prompt_feedback}")
-                    if hasattr(chunk.prompt_feedback, 'block_reason'):
-                        yield "data: " + json.dumps({
-                            'type': 'error',
-                            'content': f'Contenu bloqué par les filtres de sécurité: {chunk.prompt_feedback.block_reason}'
-                        }) + "\n\n"
-                        return
-                
-                if not chunk.candidates:
-                    logger.warning(f"Chunk {chunk_count} sans candidats")
-                    continue
-                
-                candidate = chunk.candidates[0]
-                
-                # Vérifier le statut du candidat
-                if hasattr(candidate, 'finish_reason') and candidate.finish_reason:
-                    finish_reason = str(candidate.finish_reason)
-                    if finish_reason != 'STOP' and finish_reason != '0':
-                        logger.warning(f"Génération terminée avec raison: {finish_reason}")
-                        if 'SAFETY' in finish_reason:
-                            yield "data: " + json.dumps({
-                                'type': 'error',
-                                'content': 'Contenu bloqué par les filtres de sécurité.'
-                            }) + "\n\n"
-                            return
-                
-                if not hasattr(candidate, 'content') or not candidate.content:
-                    logger.warning(f"Chunk {chunk_count} sans contenu")
-                    continue
-                
-                if not hasattr(candidate.content, 'parts') or not candidate.content.parts:
-                    logger.warning(f"Chunk {chunk_count} sans parts")
-                    continue
-                    
-                for part in candidate.content.parts:
-                    if not hasattr(part, 'text') or not part.text:
-                        continue
-                    
-                    content_generated = True
-                    
-                    if hasattr(part, 'thought') and part.thought:
-                        # Pensées du modèle (mode deepthink)
-                        yield "data: " + json.dumps({
-                            'type': 'thought', 
-                            'content': part.text
-                        }) + "\n\n"
-                    else:
-                        # Réponse principale
-                        yield "data: " + json.dumps({
-                            'type': 'content', 
-                            'content': part.text
-                        }) + "\n\n"
-
-            logger.info(f"Fin du streaming. Chunks traités: {chunk_count}, Contenu généré: {content_generated}")
-            
-            if not content_generated:
-                logger.error("Aucun contenu n'a été généré!")
-                yield "data: " + json.dumps({
+    try:
+        logger.info("Démarrage de la génération...")
+        
+        # Génération sans streaming
+        response = client.models.generate_content(
+            model=model_name,
+            contents=[user_prompt],
+            config=config
+        )
+        
+        # Vérifier si la réponse a été bloquée
+        if hasattr(response, 'prompt_feedback') and response.prompt_feedback:
+            logger.warning(f"Prompt feedback: {response.prompt_feedback}")
+            if hasattr(response.prompt_feedback, 'block_reason'):
+                return Response(
+                    json.dumps({
+                        'type': 'error',
+                        'content': f'Contenu bloqué par les filtres de sécurité: {response.prompt_feedback.block_reason}'
+                    }),
+                    mimetype='application/json',
+                    status=400
+                )
+        
+        # Vérifier les candidats
+        if not response.candidates:
+            logger.error("Aucun candidat dans la réponse")
+            return Response(
+                json.dumps({
                     'type': 'error',
-                    'content': 'Aucun contenu généré. Le modèle n\'a pas produit de réponse.'
-                }) + "\n\n"
-            else:
-                yield "data: " + json.dumps({'type': 'done'}) + "\n\n"
-
-        except Exception as e:
-            logger.exception("Erreur pendant la génération de contenu.")
-            yield "data: " + json.dumps({
-                'type': 'error', 
+                    'content': 'Aucune réponse générée par le modèle.'
+                }),
+                mimetype='application/json',
+                status=500
+            )
+        
+        candidate = response.candidates[0]
+        
+        # Vérifier le statut du candidat
+        if hasattr(candidate, 'finish_reason') and candidate.finish_reason:
+            finish_reason = str(candidate.finish_reason)
+            if 'SAFETY' in finish_reason:
+                logger.warning(f"Contenu bloqué: {finish_reason}")
+                return Response(
+                    json.dumps({
+                        'type': 'error',
+                        'content': 'Contenu bloqué par les filtres de sécurité.'
+                    }),
+                    mimetype='application/json',
+                    status=400
+                )
+        
+        # Extraire le texte
+        if not hasattr(candidate, 'content') or not candidate.content:
+            logger.error("Pas de contenu dans le candidat")
+            return Response(
+                json.dumps({
+                    'type': 'error',
+                    'content': 'Aucun contenu généré.'
+                }),
+                mimetype='application/json',
+                status=500
+            )
+        
+        if not hasattr(candidate.content, 'parts') or not candidate.content.parts:
+            logger.error("Pas de parts dans le contenu")
+            return Response(
+                json.dumps({
+                    'type': 'error',
+                    'content': 'Aucun contenu généré.'
+                }),
+                mimetype='application/json',
+                status=500
+            )
+        
+        # Récupérer tout le texte
+        full_text = ""
+        thoughts = ""
+        
+        for part in candidate.content.parts:
+            if hasattr(part, 'text') and part.text:
+                if hasattr(part, 'thought') and part.thought and use_deepthink:
+                    thoughts += part.text + "\n"
+                else:
+                    full_text += part.text
+        
+        if not full_text:
+            logger.error("Aucun texte dans les parts")
+            return Response(
+                json.dumps({
+                    'type': 'error',
+                    'content': 'Aucun contenu textuel généré.'
+                }),
+                mimetype='application/json',
+                status=500
+            )
+        
+        logger.info(f"Génération réussie. Longueur: {len(full_text)} caractères")
+        
+        result = {
+            'type': 'success',
+            'content': full_text
+        }
+        
+        if thoughts and use_deepthink:
+            result['thoughts'] = thoughts
+        
+        return Response(
+            json.dumps(result),
+            mimetype='application/json'
+        )
+        
+    except Exception as e:
+        logger.exception("Erreur pendant la génération de contenu.")
+        return Response(
+            json.dumps({
+                'type': 'error',
                 'content': f'Erreur serveur pendant la génération: {str(e)}'
-            }) + "\n\n"
-
-    return Response(generate_stream(), mimetype='text/event-stream')
+            }),
+            mimetype='application/json',
+            status=500
+        )
 
 
 @app.route('/api/etude-texte', methods=['POST'])
@@ -454,30 +488,54 @@ def api_etude_texte():
 
             logger.info("Démarrage de l'analyse d'images...")
             
-            for chunk in client.models.generate_content_stream(
+            # Génération sans streaming
+            response = client.models.generate_content(
                 model=STANDARD_MODEL_NAME,
                 contents=content,
                 config=config
-            ):
-                if not chunk.candidates:
-                    continue
-                    
-                for part in chunk.candidates[0].content.parts:
-                    if part.text:
-                        yield "data: " + json.dumps({
-                            'type': 'content', 
-                            'content': part.text
-                        }) + "\n\n"
-
-            logger.info("Fin de l'analyse d'images.")
-            yield "data: " + json.dumps({'type': 'done'}) + "\n\n"
+            )
+            
+            # Vérifier les erreurs
+            if not response.candidates:
+                raise ValueError("Aucun candidat dans la réponse")
+            
+            candidate = response.candidates[0]
+            
+            if not hasattr(candidate, 'content') or not candidate.content:
+                raise ValueError("Pas de contenu dans le candidat")
+            
+            if not hasattr(candidate.content, 'parts') or not candidate.content.parts:
+                raise ValueError("Pas de parts dans le contenu")
+            
+            # Récupérer le texte
+            full_text = ""
+            for part in candidate.content.parts:
+                if hasattr(part, 'text') and part.text:
+                    full_text += part.text
+            
+            if not full_text:
+                raise ValueError("Aucun texte généré")
+            
+            logger.info(f"Analyse réussie. Longueur: {len(full_text)} caractères")
+            
+            return Response(
+                json.dumps({
+                    'type': 'success',
+                    'content': full_text
+                }),
+                mimetype='application/json'
+            )
 
         except Exception as e:
             logger.exception("Erreur pendant l'analyse d'images.")
-            yield "data: " + json.dumps({
-                'type': 'error', 
-                'content': f"Erreur serveur pendant l'analyse: {str(e)}"
-            }) + "\n\n"
+            return Response(
+                json.dumps({
+                    'type': 'error',
+                    'content': f"Erreur serveur pendant l'analyse: {str(e)}"
+                }),
+                mimetype='application/json',
+                status=500
+            )
         
         finally:
             # Nettoyer les fichiers uploadés après traitement
@@ -485,7 +543,7 @@ def api_etude_texte():
                 file_manager.cleanup_file(file_id)
             logger.info("Fichiers temporaires nettoyés.")
 
-    return Response(generate_analysis(), mimetype='text/event-stream')
+    return generate_analysis()
 
 
 @app.route('/health')