Update app.py

app.py

@@ -1,4 +1,5 @@
-from flask import Flask, request, jsonify
+from flask import Flask, request, jsonify, Response, stream_with_context
+from flask_cors import CORS
 import os
 from dotenv import load_dotenv
 import requests
@@ -7,13 +8,34 @@ from csv_handler import CSVHandler
 import ssl
 import logging
 from web_scraper import research_topic
+import queue
+import threading
 
-# Set up logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+# Create a queue for log messages
+log_queue = queue.Queue()
+
+# Custom log handler that puts messages in the queue
+class QueueHandler(logging.Handler):
+    def emit(self, record):
+        log_entry = self.format(record)
+        log_queue.put(log_entry)
+
+# Set up logging with the custom handler
+logger = logging.getLogger()
+queue_handler = QueueHandler()
+queue_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
+logger.addHandler(queue_handler)
+logger.setLevel(logging.INFO)
 
 app = Flask(__name__)
-load_dotenv()
+# Enable CORS with specific settings
+CORS(app, resources={
+    r"/*": {
+        "origins": "*",
+        "methods": ["GET", "POST", "OPTIONS"],
+        "allow_headers": ["Content-Type", "Authorization"]
+    }
+})
 
 # Configuration
 OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')
@@ -75,16 +97,16 @@ Create the preliminary plan."""
             },
             timeout=60
         )
-        
+
         logger.info(f"OpenRouter API Response: {response.text}")
-        
+
         if response.status_code != 200:
             raise Exception(f"OpenRouter API error: {response.text}")
-            
+
         response_data = response.json()
         if 'choices' not in response_data:
             raise Exception(f"Unexpected API response format: {response_data}")
-            
+
         return response_data['choices'][0]['message']['content']
     except Exception as e:
         logger.error(f"Error in generate_preliminary_plan: {e}")
@@ -95,46 +117,46 @@ def do_research(plan, openrouter_key):
     try:
         # Extract key points from plan to create search queries
         plan_lines = [line.strip('* -').strip() for line in plan.split('\n') if line.strip()]
-        
+
         # Take only the first 3 points
         plan_lines = plan_lines[:3]
         logger.info(f"Researching top 3 points: {plan_lines}")
-        
+
         all_research = []
-        
+
         # Research each main point in the plan (limited to 3 points)
         for point in plan_lines:
             if not point:  # Skip empty lines
                 continue
-                
+
             # Get research results including both web content and AI analysis
             # Using 5 sites per point for more comprehensive research
             results = research_topic(point, num_sites=5, openrouter_key=openrouter_key)
-            
+
             if results['success']:
                 all_research.append({
                     'topic': point,
                     'analysis': results['analysis'],
                     'sources': results['sources']
                 })
-        
+
         # Format all research into a comprehensive markdown document
         formatted_research = "# Research Results\n\n"
-        
+
         for research in all_research:
             formatted_research += f"## {research['topic']}\n\n"
             formatted_research += f"{research['analysis']}\n\n"
             formatted_research += "### Sources Referenced\n\n"
-            
+
             for source in research['sources']:
                 formatted_research += f"- [{source['title']}]({source['source']})\n"
                 if source['meta_info']['description']:
                     formatted_research += f"  {source['meta_info']['description']}\n"
-            
+
             formatted_research += "\n---\n\n"
-        
+
         return formatted_research
-        
+
     except Exception as e:
         logger.error(f"Error in do_research: {e}")
         raise
@@ -143,20 +165,20 @@ def do_research(plan, openrouter_key):
 def generate_blog():
     try:
         logger.info("Starting blog generation process for multiple clusters...")
-        
+
         # Initialize handlers
         blog_gen = BlogGenerator(OPENAI_API_KEY, OPENROUTER_API_KEY)
         csv_handler = CSVHandler()
 
         generated_blogs = []
-        
+
         # Get all available clusters
         all_clusters = csv_handler.get_all_clusters()
-        
+
         for cluster_data in all_clusters:
             try:
                 logger.info(f"Processing cluster with primary keyword: {cluster_data['Primary Keyword']}")
-                
+
                 # 2. Generate preliminary plan
                 logger.info("Generating preliminary plan...")
                 plan = generate_preliminary_plan(cluster_data)
@@ -266,57 +288,57 @@ def generate_from_csv():
     try:
         if 'file' not in request.files:
             return jsonify({'error': 'No file uploaded'}), 400
-            
+
         file = request.files['file']
         if file.filename == '':
             return jsonify({'error': 'No file selected'}), 400
-            
+
         # Read and decode the CSV content
         csv_content = file.read().decode('utf-8')
-        
+
         # Initialize handlers
         blog_gen = BlogGenerator(OPENAI_API_KEY, OPENROUTER_API_KEY)
         csv_handler = CSVHandler()
-        
+
         # Process the uploaded CSV
         clusters = csv_handler.process_uploaded_csv(csv_content)
-        
+
         if not clusters:
             return jsonify({'error': 'No valid clusters found in CSV'}), 400
-            
+
         generated_blogs = []
-        
+
         # Process each cluster
         for cluster_data in clusters:
             try:
                 logger.info(f"Processing cluster with primary keyword: {cluster_data['Primary Keyword']}")
-                
+
                 # Generate preliminary plan
                 plan = generate_preliminary_plan(cluster_data)
-                
+
                 # Do research
                 research = do_research(plan, OPENROUTER_API_KEY)
-                
+
                 # Create detailed plan
                 detailed_plan = blog_gen.create_detailed_plan(cluster_data, plan, research)
-                
+
                 # Write blog post
                 blog_content = blog_gen.write_blog_post(detailed_plan, cluster_data)
-                
+
                 # Add internal links
                 previous_posts = csv_handler.get_previous_posts()
                 blog_content = blog_gen.add_internal_links(blog_content, previous_posts)
-                
+
                 # Convert to HTML
                 cover_image_url = blog_gen.get_cover_image(cluster_data['Primary Keyword'])
                 html_content = blog_gen.convert_to_html(blog_content, cover_image_url)
-                
+
                 # Generate metadata
                 metadata = blog_gen.generate_metadata(blog_content, cluster_data['Primary Keyword'], cluster_data)
-                
+
                 # Get cover image
                 cover_image_url = blog_gen.get_cover_image(metadata['title'])
-                
+
                 # Create blog post data
                 blog_post_data = {
                     'title': metadata['title'],
@@ -329,13 +351,13 @@ def generate_from_csv():
                     'research': research,
                     'detailed_plan': detailed_plan
                 }
-                
+
                 generated_blogs.append({
                     'status': 'success',
                     'message': f"Blog post generated successfully for {cluster_data['Primary Keyword']}",
                     'data': blog_post_data
                 })
-                
+
             except Exception as e:
                 logger.error(f"Error processing cluster {cluster_data['Primary Keyword']}: {e}")
                 generated_blogs.append({
@@ -343,53 +365,53 @@ def generate_from_csv():
                     'message': f"Failed to generate blog post for {cluster_data['Primary Keyword']}",
                     'error': str(e)
                 })
-        
+
         return jsonify({
             'status': 'success',
             'message': f'Generated {len(generated_blogs)} blog posts from uploaded CSV',
             'blogs': generated_blogs
         })
-        
+
     except Exception as e:
         logger.error(f"Error in generate_from_csv: {e}")
         return jsonify({'error': str(e)}), 500
-    
+
 
 @app.route('/generate-from-csv-text', methods=['POST'])
 def generate_from_csv_text():
     try:
         logger.info("Starting blog generation process for multiple clusters...")
-        
+
         # Get CSV content and OpenRouter API key from request JSON
         data = request.get_json()
         if not data or 'csv_content' not in data:
             return jsonify({'error': 'No CSV content provided'}), 400
         if 'openrouter_key' not in data:
             return jsonify({'error': 'OpenRouter API key is required'}), 400
-            
+
         csv_content = data['csv_content']
         openrouter_key = data['openrouter_key']
-        
+
         # Initialize handlers with the provided OpenRouter key
         blog_gen = BlogGenerator(OPENAI_API_KEY, openrouter_key)
         csv_handler = CSVHandler()
-        
+
         # Process the CSV text
         clusters = csv_handler.process_csv_text(csv_content)
-        
+
         if not clusters:
             return jsonify({'error': 'No valid clusters found in CSV'}), 400
-            
+
         generated_blogs = []
-        
+
         # Process each cluster
         for cluster_data in clusters:
             try:
                 logger.info(f"Processing cluster with primary keyword: {cluster_data['Primary Keyword']}")
-                
+
                 # Add OpenRouter key to cluster_data for use in functions
                 cluster_data['openrouter_key'] = openrouter_key
-                
+
                 # Generate preliminary plan
                 logger.info("Generating preliminary plan...")
                 plan = generate_preliminary_plan(cluster_data)
@@ -464,5 +486,26 @@ def generate_from_csv_text():
         logger.error(f"Error in generate_from_csv_text: {e}")
         return jsonify({'error': str(e)}), 500
 
+@app.route('/logs/stream')
+def stream_logs():
+    def generate():
+        while True:
+            try:
+                # Get log message from queue, timeout after 1 second
+                log_message = log_queue.get(timeout=1)
+                yield f"data: {log_message}\n\n"
+            except queue.Empty:
+                # Send a heartbeat to keep the connection alive
+                yield "data: heartbeat\n\n"
+            except GeneratorExit:
+                break
+
+    response = Response(stream_with_context(generate()), mimetype='text/event-stream')
+    response.headers['Cache-Control'] = 'no-cache'
+    response.headers['Connection'] = 'keep-alive'
+    response.headers['Access-Control-Allow-Origin'] = '*'
+    return response
+
 if __name__ == '__main__':
-    app.run(host='127.0.0.1', port=5001, debug=True) 
+    logger.info("Starting Flask API server...")
+    app.run(host='127.0.0.1', port=5001, debug=True, threaded=True)