Update blog_generator.py

blog_generator.py

@@ -1,9 +1,8 @@
 import requests
-import aiohttp
 from typing import Dict, List
 import re
 import json
-from web_scraper import get_cover_image, get_cover_image_async
+from web_scraper import get_cover_image
 
 class BlogGenerator:
     def __init__(self, openai_key: str, openrouter_key: str, serpapi_key: str = None):
@@ -25,20 +24,6 @@ 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(
@@ -107,46 +92,6 @@ Create the detailed plan."""
             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(
@@ -209,43 +154,6 @@ Write the blog post."""
             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(
@@ -312,42 +220,6 @@ Your output must be the complete blog post with new internal links added. Don't
             # 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
@@ -418,41 +290,6 @@ 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
@@ -600,54 +437,4 @@ Your output must only be the meta description and nothing else."""
             }
         except Exception as e:
             print(f"Error in generate_metadata: {e}")
-            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