Create app.py

app.py

@@ -0,0 +1,122 @@
+from flask import Flask, render_template, request, jsonify, Response, stream_with_context
+from google import genai
+import logging
+from pathlib import Path
+import sys
+from typing import Generator
+import json
+import os 
+
+
+api_key =  os.environ.get("GEMINI_API_KEY")
+
+#pi_key = "YOUR_API_KEY_HERE"
+
+# Configuration du logging
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(sys.stdout),
+        logging.FileHandler(Path('app.log'))
+    ]
+)
+logger = logging.getLogger(__name__)
+
+app = Flask(__name__)
+
+class GeminiClient:
+    def __init__(self, api_key: str):
+        self.client = None
+        self.init_client(api_key)
+        
+    def init_client(self, api_key: str) -> None:
+        try:
+            self.client = genai.Client(
+                api_key=api_key,
+                http_options={'api_version': 'v1alpha'}
+            )
+        except Exception as e:
+            logger.error(f"Erreur d'initialisation du client Gemini: {e}")
+            raise RuntimeError(f"Impossible d'initialiser le client Gemini: {e}")
+
+    def get_response(self, question: str, model_name: str) -> Generator:
+        if not self.client:
+            raise RuntimeError("Client Gemini non initialisé")
+            
+        try:
+            response = self.client.models.generate_content_stream(
+                model=model_name,
+                config={'thinking_config': {'include_thoughts': True}},
+                contents=[question]
+            )
+            return response
+        except Exception as e:
+            logger.error(f"Erreur lors de la génération de la réponse: {e}")
+            raise
+
+def stream_response(response: Generator):
+    thinking_text = ""
+    answer_text = ""
+    mode = 'starting'
+    
+    try:
+        for chunk in response:
+            if hasattr(chunk, 'candidates') and chunk.candidates:
+                content = chunk.candidates[0].content
+                
+                if hasattr(content, 'parts'):
+                    for part in content.parts:
+                        has_thought = hasattr(part, 'thought') and part.thought
+                        text = getattr(part, 'text', '')
+                        
+                        if not text:
+                            continue
+                            
+                        if has_thought:
+                            thinking_text += text
+                            yield json.dumps({
+                                'type': 'thinking',
+                                'content': thinking_text
+                            }) + '\n'
+                        else:
+                            answer_text += text
+                            yield json.dumps({
+                                'type': 'answer',
+                                'content': answer_text
+                            }) + '\n'
+                            
+    except Exception as e:
+        logger.error(f"Erreur dans le streaming de la réponse: {e}")
+        yield json.dumps({
+            'type': 'error',
+            'content': "Une erreur est survenue lors de l'analyse."
+        }) + '\n'
+
+
+gemini_client = GeminiClient(api_key)
+        
+@app.route('/')
+def home():
+    return render_template('index.html')
+
+
+
+@app.route('/ask', methods=['POST'])
+def ask():
+  # À remplacer par votre clé API
+    question = request.json.get('question')
+    model_name = "gemini-2.0-flash-thinking-exp-01-21"
+    
+    try:
+        response = gemini_client.get_response(question, model_name)
+        return Response(
+            stream_with_context(stream_response(response)),
+            mimetype='text/event-stream'
+        )
+    except Exception as e:
+        logger.error(f"Erreur lors de la génération: {e}", exc_info=True)
+        return jsonify({'error': "Une erreur est survenue. Veuillez réessayer."}), 500
+
+if __name__ == '__main__':
+    app.run(debug=True)