This Blogger Uses One Python File + Google Trends to Run a Fully Automated Site

# trends_module.py
from pytrends.request import TrendReq
import pandas as pd
import json

def get_trending_searches(geo='US', num_results=5):
    """
    Fetches daily trending searches for a specific geography.
    Returns a list of dictionaries with search topics.
    """
    pytrends = TrendReq(hl='en-US', tz=360) # Or actual API key if official 2025 API emerged

    try:
        daily_trends = pytrends.trending_searches(pn=geo)
        # For simplicity, let's just get the top query from each trend
        trending_topics = []
        for index, row in daily_trends.iterrows():
            topic = row[0] # The main search term
            trending_topics.append({"topic": topic})
            if len(trending_topics) >= num_results:
                break
        return trending_topics
    except Exception as e:
        print(f"Error fetching trending searches: {e}")
        return []

# Example usage (within the main script or for testing)
# if __name__ == "__main__":
#     trends = get_trending_searches(geo='US', num_results=3)
#     print(json.dumps(trends, indent=2))

# serp_module.py
import requests
import os

SERPAPI_KEY = os.getenv("SERPAPI_KEY") # Load from environment variable for security

def get_top_search_results(query, num_results=3):
    """
    Fetches top organic search results for a given query using SerpAPI.
    Returns a list of URLs.
    """
    if not SERPAPI_KEY:
        print("SERPAPI_KEY not set in environment variables.")
        return []

    url = f"https://serpapi.com/search.json?engine=google&q={query}&api_key={SERPAPI_KEY}"
    try:
        response = requests.get(url)
        response.raise_for_status() # Raise an exception for HTTP errors
        data = response.json()
        top_links = [r['link'] for r in data.get('organic_results', [])[:num_results]]
        return top_links
    except requests.exceptions.RequestException as e:
        print(f"Error fetching SerpAPI results for '{query}': {e}")
        return []

# Example usage
# if __name__ == "__main__":
#     topic_example = "future of remote work 2025"
#     top_urls = get_top_search_results(topic_example)
#     print(f"Top 3 results for '{topic_example}': {top_urls}")

# content_module.py
import os
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
from langchain.output_parsers import StructuredOutputParser, ResponseSchema # For structured output
import json

# Ensure your OpenAI API key is set as an environment variable
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")

def generate_blog_post(topic, existing_urls=[]):
    """
    Generates a detailed, SEO-optimized blog post using GPT-5.
    Can take existing URLs for contextual inspiration (but not copying).
    """
    llm = OpenAI(model_name="gpt-5-turbo", temperature=0.7, max_tokens=2500)

    # Define the schema for the expected output, if you want structured data
    # For now, let's keep it simple for a full blog post
    
    prompt = PromptTemplate(
        input_variables=["topic", "existing_urls_info"],
        template="""You are a professional content writer specializing in SEO and engaging blog posts.
        Write a comprehensive, SEO-optimized blog post of approximately 1200-1500 words on the topic: "{topic}".
        
        Structure your post with:
        - A compelling title
        - An engaging introduction
        - 3-5 main sections with descriptive H2 headings
        - Relevant subheadings (H3) within sections
        - A strong conclusion with a call to action.
        
        Incorporate factual information and insights. Aim for a clear, energetic, and smart tone.
        
        Consider the following existing content for context and to identify unique angles, but do NOT plagiarize or directly copy:
        {existing_urls_info}
        
        Focus on providing unique value and insights relevant for 2025.
        """
    )
    
    # If existing_urls are provided, fetch snippets or titles from them for context
    # For simplicity, we'll just pass the URLs as information.
    urls_info = "\n".join([f"- {url}" for url in existing_urls]) if existing_urls else "No specific existing URLs provided."

    chain = LLMChain(llm=llm, prompt=prompt)
    
    try:
        blog_content = chain.run(topic=topic, existing_urls_info=urls_info)
        return blog_content
    except Exception as e:
        print(f"Error generating blog post for '{topic}': {e}")
        return None

# Example usage
# if __name__ == "__main__":
#     test_topic = "Impact of AI on Education 2025"
#     test_urls = ["https://www.edtechmagazine.com/ai-education", "https://openai.com/blog/ai-in-classroom"]
#     generated_post = generate_blog_post(test_topic, existing_urls=test_urls)
#     if generated_post:
#         print("--- Generated Post ---")
#         print(generated_post[:1000] + "...") # Print first 1000 chars for preview

# publish_module.py
from xmlrpc.client import ServerProxy
import os

WP_USERNAME = os.getenv("WP_USERNAME")
WP_APP_PASSWORD = os.getenv("WP_APP_PASSWORD") # Use application password!
WP_XMLRPC_URL = os.getenv("WP_XMLRPC_URL") # e.g., "https://yourdomain.com/xmlrpc.php"

def publish_post_to_wordpress(title, content, categories=[], tags=[], status="publish"):
    """
    Publishes a new post to a WordPress site using XML-RPC.
    """
    if not all([WP_USERNAME, WP_APP_PASSWORD, WP_XMLRPC_URL]):
        print("WordPress credentials or URL not fully set in environment variables.")
        return None

    server = ServerProxy(WP_XMLRPC_URL)
    
    post = {
        'post_type': 'post',
        'post_status': status,
        'post_title': title,
        'post_content': content,
        'post_categories': [{'slug': cat} for cat in categories if cat],
        'mt_keywords': ','.join(tags)
    }

    try:
        # The blog ID is usually 1 for a single WordPress installation
        post_id = server.wp.newPost(
            1,
            WP_USERNAME,
            WP_APP_PASSWORD,
            post
        )
        print(f"Successfully published post '{title}' with ID: {post_id}")
        return post_id
    except Exception as e:
        print(f"Error publishing post '{title}': {e}")
        # Common errors: invalid credentials, XML-RPC disabled, incorrect URL
        return None

# Example usage
# if __name__ == "__main__":
#     test_title = "The Future of AI Ethics in 2025"
#     test_content = "This is placeholder content generated by AI about AI ethics..."
#     test_categories = ["AI", "Tech Ethics"]
#     test_tags = ["AI 2025", "Ethics", "Future Tech"]
#     
#     # For actual use, set these as environment variables or load from secure config
#     os.environ["WP_USERNAME"] = "your_test_user"
#     os.environ["WP_APP_PASSWORD"] = "your_test_app_password"
#     os.environ["WP_XMLRPC_URL"] = "http://localhost/wordpress/xmlrpc.php" # Replace with your actual URL
#     
#     # post_id = publish_post_to_wordpress(test_title, test_content, test_categories, test_tags)
#     # if post_id:
#     #     print(f"Check your WordPress site for post ID {post_id}")

# auto_content_bot.py
import os
import json
from datetime import datetime

# Import our custom modules
from trends_module import get_trending_searches
from serp_module import get_top_search_results
from content_module import generate_blog_post
from publish_module import publish_post_to_wordpress

# --- Configuration ---
# Set environment variables for API keys and WP credentials:
# export OPENAI_API_KEY="sk-..."
# export SERPAPI_KEY="your_serpapi_key"
# export WP_USERNAME="your_wp_user"
# export WP_APP_PASSWORD="your_wp_app_password"
# export WP_XMLRPC_URL="https://yourdomain.com/xmlrpc.php"

# General script settings
TRENDS_GEO = 'US'
NUM_TRENDS_TO_PROCESS = 1 # Process one trending topic per run for now
NUM_SERP_RESULTS_FOR_CONTEXT = 3
DEFAULT_CATEGORIES = ["AI Blogging 2025", "Automation"]
POST_STATUS = "publish" # Or "draft" for manual review

def main():
    print(f"--- Auto Content Bot initiated at {datetime.now()} ---")

    # 1. Get Trending Searches
    print(f"Fetching {NUM_TRENDS_TO_PROCESS} trending searches from Google Trends...")
    trending_topics = get_trending_searches(geo=TRENDS_GEO, num_results=NUM_TRENDS_TO_PROCESS)

    if not trending_topics:
        print("No trending topics found or error occurred. Exiting.")
        return

    for trend in trending_topics:
        topic = trend['topic']
        print(f"\nProcessing trending topic: '{topic}'")

        # 2. Get Top Search Results for Context
        print(f"Fetching top {NUM_SERP_RESULTS_FOR_CONTEXT} SERP results for context...")
        top_urls = get_top_search_results(topic, num_results=NUM_SERP_RESULTS_FOR_CONTEXT)
        if top_urls:
            print(f"Found existing URLs: {top_urls}")
        else:
            print("No existing URLs found or error occurred with SerpAPI.")

        # 3. Generate Blog Post Content
        print("Generating blog post content with GPT-5...")
        blog_content = generate_blog_post(topic, existing_urls=top_urls)

        if not blog_content:
            print(f"Could not generate content for '{topic}'. Skipping publishing.")
            continue

        # Extract title (assuming it's the first line for simplicity or parse it)
        # More robust: use LangChain's structured output parser for title, content, tags, categories
        lines = blog_content.strip().split('\n')
        post_title = lines[0].replace('Title: ', '').strip() if lines and lines[0].startswith('Title:') else f"Automated Post: {topic}"
        
        # Ensure tags are relevant, maybe extract from content or hardcode general ones
        post_tags = [t.strip().replace(' ', '-') for t in topic.split()] + ["2025", "AI", "Automation"]
        
        # 4. Publish to WordPress
        print(f"Attempting to publish post '{post_title}' to WordPress...")
        post_id = publish_post_to_wordpress(post_title, blog_content, DEFAULT_CATEGORIES, post_tags, POST_STATUS)

        if post_id:
            print(f"Successfully automated post for '{topic}'. Post ID: {post_id}")
        else:
            print(f"Failed to publish post for '{topic}'. Check logs for details.")

    print(f"--- Auto Content Bot finished at {datetime.now()} ---")

if __name__ == "__main__":
    main()

# To run the script daily at 3 AM UTC and log output
0 3 * * * /usr/bin/python3 /path/to/your/auto_content_bot.py >> /path/to/your/logs/auto_content.log 2>&1