Update blog_generator.py

blog_generator.py

@@ -1,8 +1,9 @@
 import requests
+import aiohttp
 from typing import Dict, List
 import re
 import json
-from web_scraper import get_cover_image
+from web_scraper import get_cover_image, get_cover_image_async
 
 class BlogGenerator:
     def __init__(self, openai_key: str, openrouter_key: str, serpapi_key: str = None):
@@ -24,6 +25,20 @@ class BlogGenerator:
             print(f"Error in get_cover_image: {e}")
             return None
 
+    async def get_cover_image_async(self, title: str) -> str:
+        """Get a cover image URL for the blog post asynchronously"""
+        try:
+            # Use our custom image search function
+            image_url = await get_cover_image_async(title)
+            if not image_url:
+                print("No image found, trying with modified query...")
+                # Try again with a more generic query if specific title fails
+                image_url = await get_cover_image_async(title + " high quality cover image")
+            return image_url
+        except Exception as e:
+            print(f"Error in get_cover_image_async: {e}")
+            return None
+
     def create_detailed_plan(self, cluster_data: Dict, preliminary_plan: str, research: str) -> str:
         try:
             response = requests.post(
@@ -37,34 +52,34 @@ class BlogGenerator:
                     'model': 'google/gemini-2.0-flash-thinking-exp:free',
                     'messages': [{
                         'role': 'user',
-                        'content': f"""You are part of a team that creates world class blog posts. 
+                        'content': f"""You are part of a team that creates world class blog posts.
 
-For each new blog post project, you are provided with a list of keywords, a primary keyword, search intent, research findings, and a preliminary blog post plan. Here's a definition of each of the inputs: 
+For each new blog post project, you are provided with a list of keywords, a primary keyword, search intent, research findings, and a preliminary blog post plan. Here's a definition of each of the inputs:
 
-- Keywords: These are the keywords which the blog post is meant to rank for on SEO. They should be scattered throughout the blog post intelligently to help with SEO. 
+- Keywords: These are the keywords which the blog post is meant to rank for on SEO. They should be scattered throughout the blog post intelligently to help with SEO.
 
-- Search intent: The search intent recognises the intent of the user when searching up the keyword. Our goal is to optimise the blog post to be highly relevant and valuable to the user, as such the search intent should be satisfied within the blog post. 
+- Search intent: The search intent recognises the intent of the user when searching up the keyword. Our goal is to optimise the blog post to be highly relevant and valuable to the user, as such the search intent should be satisfied within the blog post.
 
-- Research findings: This is research found from very reputable resources in relation to the blog post. You must intelligently use this research to make your blog post more reputable. 
+- Research findings: This is research found from very reputable resources in relation to the blog post. You must intelligently use this research to make your blog post more reputable.
 
-- Preliminary plan: A very basic plan set out by your colleague to kick off the blog post. 
+- Preliminary plan: A very basic plan set out by your colleague to kick off the blog post.
 
-- Primary keyword: Out of the keywords, there is one keyword known as the primary keyword. The primary keyword is the keyword which has the highest SEO importance and as such must go in the title and first few sentences of the blog post. It is important that the blog post is highly relevant to the primary keyword, so that it could be placed naturally into the title and introduction sections. 
+- Primary keyword: Out of the keywords, there is one keyword known as the primary keyword. The primary keyword is the keyword which has the highest SEO importance and as such must go in the title and first few sentences of the blog post. It is important that the blog post is highly relevant to the primary keyword, so that it could be placed naturally into the title and introduction sections.
 
-Given the above info, you must create a detailed plan for the blog post. 
+Given the above info, you must create a detailed plan for the blog post.
 
-Your output must: 
+Your output must:
 
 - Include a plan for the blog post.
 - Be in dot point format.
-- In each part of the blog post, you must mention which keywords should be placed. 
-- All keywords must be placed inside the blog post. For each section, mention which keywords to include. The keyword placement must feel natural and must make sense. 
-- You must include all research points in the blog post. When including the research points, make sure to also include their source URL so that the copywriter can use them as hyperlinks. 
-- Your plan must satisfy the search intent and revolve directly around the given keywords. 
-- Your plan must be very detailed. 
-- Keep in mind the copywriter that will use your plan to write the blog post is not an expert in the topic of the blog post. So you should give them all the detail required so they can just turn it into nicely formatted paragraphs. For example, instead of saying "define X", you must have "define X as ...". 
-- The plan must have a flow that makes sense. 
-- Ensure the blog post will be highly detailed and satisfies the most important concepts regarding the topic. 
+- In each part of the blog post, you must mention which keywords should be placed.
+- All keywords must be placed inside the blog post. For each section, mention which keywords to include. The keyword placement must feel natural and must make sense.
+- You must include all research points in the blog post. When including the research points, make sure to also include their source URL so that the copywriter can use them as hyperlinks.
+- Your plan must satisfy the search intent and revolve directly around the given keywords.
+- Your plan must be very detailed.
+- Keep in mind the copywriter that will use your plan to write the blog post is not an expert in the topic of the blog post. So you should give them all the detail required so they can just turn it into nicely formatted paragraphs. For example, instead of saying "define X", you must have "define X as ...".
+- The plan must have a flow that makes sense.
+- Ensure the blog post will be highly detailed and satisfies the most important concepts regarding the topic.
 
 A new project has just come across your desk with the following details:
 
@@ -79,19 +94,59 @@ Create the detailed plan."""
                 },
                 timeout=60
             )
-            
+
             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:
             print(f"Error in create_detailed_plan: {e}")
             raise
 
+    async def create_detailed_plan_async(self, cluster_data: Dict, plan: str, research: str) -> str:
+        """Create a detailed plan for the blog post asynchronously"""
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    'https://openrouter.ai/api/v1/chat/completions',
+                    headers={
+                        'Authorization': f'Bearer {self.openrouter_key}',
+                        'HTTP-Referer': 'http://localhost:5001',
+                        'X-Title': 'Blog Generator'
+                    },
+                    json={
+                        'model': 'google/gemini-2.0-flash-thinking-exp:free',
+                        'messages': [{
+                            'role': 'user',
+                            'content': f"""Based on the preliminary plan and research, create a detailed outline for the blog post.
+
+Keywords: {cluster_data['Keywords']}
+Primary Keyword: {cluster_data['Primary Keyword']}
+Search Intent: {cluster_data['Intent']}
+
+Preliminary Plan:
+{plan}
+
+Research:
+{research}
+
+Create a detailed outline that incorporates the research findings and ensures all keywords are used naturally."""
+                        }]
+                    }
+                ) as response:
+                    if response.status != 200:
+                        raise Exception(f"OpenRouter API error: {await response.text()}")
+
+                    response_data = await response.json()
+                    return response_data['choices'][0]['message']['content']
+        except Exception as e:
+            print(f"Error in create_detailed_plan_async: {e}")
+            raise
+
     def write_blog_post(self, detailed_plan: str, cluster_data: Dict) -> str:
         try:
             response = requests.post(
@@ -141,19 +196,56 @@ Write the blog post."""
                 },
                 timeout=120
             )
-            
+
             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:
             print(f"Error in write_blog_post: {e}")
             raise
 
+    async def write_blog_post_async(self, detailed_plan: str, cluster_data: Dict) -> str:
+        """Write the blog post content asynchronously"""
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    'https://openrouter.ai/api/v1/chat/completions',
+                    headers={
+                        'Authorization': f'Bearer {self.openrouter_key}',
+                        'HTTP-Referer': 'http://localhost:5001',
+                        'X-Title': 'Blog Generator'
+                    },
+                    json={
+                        'model': 'google/gemini-2.0-flash-thinking-exp:free',
+                        'messages': [{
+                            'role': 'user',
+                            'content': f"""Write a comprehensive blog post based on the detailed plan.
+
+Keywords: {cluster_data['Keywords']}
+Primary Keyword: {cluster_data['Primary Keyword']}
+Search Intent: {cluster_data['Intent']}
+
+Detailed Plan:
+{detailed_plan}
+
+Write a high-quality blog post that naturally incorporates all keywords and satisfies the search intent."""
+                        }]
+                    }
+                ) as response:
+                    if response.status != 200:
+                        raise Exception(f"OpenRouter API error: {await response.text()}")
+
+                    response_data = await response.json()
+                    return response_data['choices'][0]['message']['content']
+        except Exception as e:
+            print(f"Error in write_blog_post_async: {e}")
+            raise
+
     def add_internal_links(self, blog_content: str, previous_posts: List[Dict]) -> str:
         try:
             response = requests.post(
@@ -206,30 +298,66 @@ Your output must be the complete blog post with new internal links added. Don't
                 },
                 timeout=120
             )
-            
+
             if response.status_code != 200:
                 raise Exception(f"OpenAI 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:
             print(f"Error in add_internal_links: {e}")
             # If there's an error, return the original content
             return blog_content
 
+    async def add_internal_links_async(self, content: str, previous_posts: List[Dict]) -> str:
+        """Add internal links to the blog post content asynchronously"""
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    'https://openrouter.ai/api/v1/chat/completions',
+                    headers={
+                        'Authorization': f'Bearer {self.openrouter_key}',
+                        'HTTP-Referer': 'http://localhost:5001',
+                        'X-Title': 'Blog Generator'
+                    },
+                    json={
+                        'model': 'google/gemini-2.0-flash-thinking-exp:free',
+                        'messages': [{
+                            'role': 'user',
+                            'content': f"""Add relevant internal links to the blog post content.
+
+Current Content:
+{content}
+
+Previous Posts:
+{json.dumps(previous_posts, indent=2)}
+
+Add internal links where relevant, maintaining natural flow and readability."""
+                        }]
+                    }
+                ) as response:
+                    if response.status != 200:
+                        raise Exception(f"OpenRouter API error: {await response.text()}")
+
+                    response_data = await response.json()
+                    return response_data['choices'][0]['message']['content']
+        except Exception as e:
+            print(f"Error in add_internal_links_async: {e}")
+            raise
+
     def convert_to_html(self, blog_content: str, image_url: str = None) -> str:
         try:
             # First replace newlines with <br> tags
             formatted_content = blog_content.replace('\n', '<br>')
-            
+
             # Add image URL to the prompt
             image_instruction = ""
             if image_url:
                 image_instruction = f"Add this image at the top of the post after the title: {image_url}"
-            
+
             response = requests.post(
                 # 'https://api.openai.com/v1/chat/completions',
                 # headers={
@@ -253,7 +381,7 @@ Your output must be the complete blog post with new internal links added. Don't
 The blog post should have:
 - Title
 {f"- Featured image: <img src='{image_url}' alt='Featured image' style='width: 100%; height: auto; margin: 20px 0;'>" if image_url else ""}
-- Estimated reading time 
+- Estimated reading time
 - Key takeaways
 - Table of contents
 - Body
@@ -275,10 +403,10 @@ Blog post content:
                 },
                 timeout=120
             )
-            
+
             if response.status_code != 200:
                 raise Exception(f"OpenAI API error: {response.text}")
-            
+
             response_data = response.json()
             if 'choices' not in response_data:
                 raise Exception(f"Unexpected API response format: {response_data}")
@@ -290,6 +418,41 @@ Blog post content:
             # If there's an error, return the original content
             return blog_content
 
+    async def convert_to_html_async(self, content: str, cover_image_url: str) -> str:
+        """Convert markdown content to HTML asynchronously"""
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    'https://openrouter.ai/api/v1/chat/completions',
+                    headers={
+                        'Authorization': f'Bearer {self.openrouter_key}',
+                        'HTTP-Referer': 'http://localhost:5001',
+                        'X-Title': 'Blog Generator'
+                    },
+                    json={
+                        'model': 'google/gemini-2.0-flash-thinking-exp:free',
+                        'messages': [{
+                            'role': 'user',
+                            'content': f"""Convert this markdown content to clean, semantic HTML.
+
+Markdown Content:
+{content}
+
+Cover Image URL: {cover_image_url}
+
+Convert to HTML with proper semantic structure and include the cover image."""
+                        }]
+                    }
+                ) as response:
+                    if response.status != 200:
+                        raise Exception(f"OpenRouter API error: {await response.text()}")
+
+                    response_data = await response.json()
+                    return response_data['choices'][0]['message']['content']
+        except Exception as e:
+            print(f"Error in convert_to_html_async: {e}")
+            raise
+
     def generate_metadata(self, blog_content: str, primary_keyword: str, cluster_data: Dict) -> Dict:
         try:
             # Generate slug
@@ -324,14 +487,14 @@ Your output must be the slug and nothing else so that I can copy and paste your
                 },
                 timeout=60
             )
-            
+
             if slug_response.status_code != 200:
                 raise Exception(f"OpenAI API error: {slug_response.text}")
-            
+
             slug_data = slug_response.json()
             if 'choices' not in slug_data:
                 raise Exception(f"Unexpected API response format: {slug_data}")
-            
+
             slug = slug_data['choices'][0]['message']['content'].strip().lower()
 
             # Generate title
@@ -366,14 +529,14 @@ Your output must only be the blog post title and nothing else."""
                 },
                 timeout=60
             )
-            
+
             if title_response.status_code != 200:
                 raise Exception(f"OpenAI API error: {title_response.text}")
-            
+
             title_data = title_response.json()
             if 'choices' not in title_data:
                 raise Exception(f"Unexpected API response format: {title_data}")
-            
+
             title = title_data['choices'][0]['message']['content'].strip()
 
             # Generate meta description
@@ -416,14 +579,14 @@ Your output must only be the meta description and nothing else."""
                 },
                 timeout=60
             )
-            
+
             if meta_desc_response.status_code != 200:
                 raise Exception(f"OpenAI API error: {meta_desc_response.text}")
-            
+
             meta_desc_data = meta_desc_response.json()
             if 'choices' not in meta_desc_data:
                 raise Exception(f"Unexpected API response format: {meta_desc_data}")
-            
+
             meta_desc = meta_desc_data['choices'][0]['message']['content'].strip()
 
             # Validate the results
@@ -437,4 +600,54 @@ Your output must only be the meta description and nothing else."""
             }
         except Exception as e:
             print(f"Error in generate_metadata: {e}")
-            raise 
+            raise
+
+    async def generate_metadata_async(self, content: str, primary_keyword: str, cluster_data: Dict) -> Dict:
+        """Generate metadata for the blog post asynchronously"""
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    'https://openrouter.ai/api/v1/chat/completions',
+                    headers={
+                        'Authorization': f'Bearer {self.openrouter_key}',
+                        'HTTP-Referer': 'http://localhost:5001',
+                        'X-Title': 'Blog Generator'
+                    },
+                    json={
+                        'model': 'google/gemini-2.0-flash-thinking-exp:free',
+                        'messages': [{
+                            'role': 'user',
+                            'content': f"""Generate SEO metadata for this blog post.
+
+Content:
+{content}
+
+Primary Keyword: {primary_keyword}
+Keywords: {cluster_data['Keywords']}
+Search Intent: {cluster_data['Intent']}
+
+Generate a title, slug, and meta description optimized for SEO."""
+                        }]
+                    }
+                ) as response:
+                    if response.status != 200:
+                        raise Exception(f"OpenRouter API error: {await response.text()}")
+
+                    response_data = await response.json()
+                    metadata_text = response_data['choices'][0]['message']['content']
+
+                    # Parse the metadata text into a dictionary
+                    metadata = {}
+                    for line in metadata_text.split('\n'):
+                        if ':' in line:
+                            key, value = line.split(':', 1)
+                            metadata[key.strip().lower()] = value.strip()
+
+                    return {
+                        'title': metadata.get('title', ''),
+                        'slug': metadata.get('slug', ''),
+                        'meta_description': metadata.get('meta description', '')
+                    }
+        except Exception as e:
+            print(f"Error in generate_metadata_async: {e}")
+            raise