This Free Python Workflow Replaces Freelancers for 90% of Blog Content

# topic_research.py
import requests
import pandas as pd
from pytrends.request import TrendReq # pip install pytrends
import os

# --- Configuration ---
SERPAPI_API_KEY = os.environ.get("SERPAPI_API_KEY", "YOUR_SERPAPI_API_KEY") # Replace with your actual API key
# You'd typically pull these from a database or a seed list
CORE_TOPICS = ["AI Content Automation", "Python Blogging", "Monetization Strategies"]

def get_google_trends(keywords, timeframe='today 1-m'):
    """Fetches Google Trends interest over time."""
    pytrend = TrendReq(hl='en-US', tz=360)
    pytrend.build_payload(kw_list=keywords, cat=0, timeframe=timeframe, geo='', gprop='')
    data = pytrend.interest_over_time()
    if not data.empty:
        return data.mean().sort_values(ascending=False).index.tolist()
    return []

def get_serp_data(query):
    """Fetches SERP data using SerpAPI."""
    url = "https://serpapi.com/search"
    params = {
        "engine": "google",
        "q": query,
        "api_key": SERPAPI_API_KEY
    }
    response = requests.get(url, params=params)
    response.raise_for_status() # Raise an exception for bad status codes
    return response.json()

def identify_content_opportunities(core_topics):
    opportunities = []
    print("--- Initiating Content Opportunity Scan ---")

    for topic in core_topics:
        print(f"\nProcessing core topic: '{topic}'")
        trending_keywords = get_google_trends([topic])
        if trending_keywords:
            print(f"  Trending related terms: {', '.join(trending_keywords[:3])}...")
            main_query = trending_keywords[0] if trending_keywords else topic
        else:
            main_query = topic

        serp_data = get_serp_data(main_query + " blog post ideas")

        # Extract "People also ask" questions
        if 'qa_snippets' in serp_data:
            for qa in serp_data['qa_snippets']:
                opportunities.append({
                    'type': 'People Also Ask',
                    'query': main_query,
                    'title': qa['question'],
                    'snippet': qa['answer']
                })
        
        # Extract related searches
        if 'related_searches' in serp_data:
            for rs in serp_data['related_searches']:
                opportunities.append({
                    'type': 'Related Search',
                    'query': main_query,
                    'title': rs['query'],
                    'snippet': '' # No snippet for related searches
                })
        
        # Extract top results for title inspiration
        if 'organic_results' in serp_data:
            for i, result in enumerate(serp_data['organic_results'][:5]):
                opportunities.append({
                    'type': 'Top Organic Result',
                    'query': main_query,
                    'title': result.get('title', ''),
                    'snippet': result.get('snippet', '')
                })

    print("\n--- Content Opportunity Scan Complete ---")
    return pd.DataFrame(opportunities)

if __name__ == "__main__":
    content_ideas_df = identify_content_opportunities(CORE_TOPICS)
    print("\nIdentified Content Opportunities (first 5 rows):")
    print(content_ideas_df.head())
    content_ideas_df.to_csv("content_ideas.csv", index=False)
    print("\nSaved all opportunities to content_ideas.csv")

# article_generator.py
import openai # pip install openai
from langchain.prompts import PromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI # Ensure you have langchain-openai installed
import os

# --- Configuration ---
OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY", "YOUR_OPENAI_API_KEY") # Replace with your actual API key
GPT_MODEL = "gpt-5" # Assuming GPT-5 is available and stable in 2025

llm = ChatOpenAI(model=GPT_MODEL, temperature=0.7, openai_api_key=OPENAI_API_KEY)

def generate_blog_post(title, keywords, length_words=1000):
    """Generates a structured blog post using GPT-5 via LangChain."""

    # Step 1: Outline Generation
    outline_prompt = PromptTemplate.from_template(
        "You are an expert SEO and content strategist. Generate a detailed, SEO-friendly blog post outline for the title: '{title}'. "
        "Include a compelling introduction, 3-5 main sections with sub-headings, and a strong conclusion. "
        "Focus on integrating these keywords: {keywords}. Return only the outline in markdown format."
    )
    outline_chain = outline_prompt | llm | StrOutputParser()
    
    print(f"Generating outline for: {title}...")
    outline = outline_chain.invoke({"title": title, "keywords": ", ".join(keywords)})
    print("Outline generated successfully.\n")

    # Step 2: Content Generation for Each Section
    sections = outline.split('\n## ') # Split by main headings
    full_content = []
    
    # Process introduction and conclusion separately if needed, or iterate through all.
    # For simplicity, we'll iterate through all 'sections' assuming the outline starts with Intro.
    
    # Assuming the first part is intro before the first ## heading
    intro_segment = sections[0].split('\n###')[0] # get text before first sub-heading
    full_content.append(intro_segment) # Add the intro part
    
    print("Generating content for sections...")
    for i, section in enumerate(sections):
        if i == 0: # Skip the part that was already used as intro
            continue

        section_title_and_content = section.split('\n###', 1)
        section_title = '## ' + section_title_and_content[0].strip() # Re-add ## for proper heading structure
        
        # Extract potential sub-headings for more targeted content generation
        sub_headings_in_section = ['### ' + s.strip() for s in section_title_and_content[1].split('\n###') if s.strip()] if len(section_title_and_content) > 1 else []
        
        section_content_prompt = PromptTemplate.from_template(
            "You are a professional blog writer. Expand on the following blog section: '{section_title}'. "
            "The overall article is titled: '{article_title}'. "
            "Ensure the content is engaging, informative, and uses markdown formatting. "
            "Incorporate keywords: {keywords}. Aim for roughly {section_length} words for this section."
        )
        
        # Adjust section length dynamically or set a fixed value
        section_length = int(length_words / len(sections)) # Distribute words evenly
        
        # Combine section title and potentially some of its subheadings for a better prompt context
        combined_section_context = section_title
        if sub_headings_in_section:
            combined_section_context += '\n' + '\n'.join(sub_headings_in_section)
            
        section_content_chain = section_content_prompt | llm | StrOutputParser()
        
        content_segment = section_content_chain.invoke({
            "section_title": combined_section_context,
            "article_title": title,
            "keywords": ", ".join(keywords),
            "section_length": section_length
        })
        full_content.append(section_title + '\n' + content_segment)
        print(f"  Generated content for: {section_title.replace('## ', '')}")

    print("\nArticle generation complete.")
    return "\n\n".join(full_content)

if __name__ == "__main__":
    # Example usage:
    article_title = "Automating Your Content Pipeline with Python and AI in 2025"
    article_keywords = ["python content automation", "AI for bloggers", "monetization 2025", "GPT-5 workflows"]
    
    generated_article = generate_blog_post(article_title, article_keywords, length_words=1500)
    
    print("\n--- Generated Blog Post Preview ---")
    print(generated_article[:1000] + "...\n(Truncated for preview)")
    
    with open("generated_blog_post.md", "w") as f:
        f.write(generated_article)
    print("\nFull article saved to generated_blog_post.md")

# wordpress_publisher.py
import xmlrpc.client
import os

# --- Configuration ---
WORDPRESS_URL = "https://yourdomain.com/xmlrpc.php" # Replace with your WordPress XML-RPC URL
WORDPRESS_USERNAME = os.environ.get("WORDPRESS_USERNAME", "your_wordpress_username")
WORDPRESS_PASSWORD = os.environ.get("WORDPRESS_PASSWORD", "your_application_password") # Use an application password for security!

def publish_post_to_wordpress(title, content, categories=None, tags=None, status="publish"):
    """Publishes a new post to WordPress via XML-RPC."""
    server = xmlrpc.client.ServerProxy(WORDPRESS_URL)
    
    # WordPress's XML-RPC API method for new post:
    # wp.newPost(blog_id, username, password, content, publish)
    # blog_id is usually 0 or 1 for a single blog setup.
    
    data = {
        'post_type': 'post',
        'post_status': status,
        'post_title': title,
        'post_content': content,
        'post_author': 1, # ID of the author
        'terms_names': {
            'category': categories if categories else ['Uncategorized'],
            'post_tag': tags if tags else []
        }
    }

    try:
        post_id = server.wp.newPost(
            0, # blog_id (0 is often default for single site)
            WORDPRESS_USERNAME,
            WORDPRESS_PASSWORD,
            data
        )
        print(f"Successfully published post '{title}' with ID: {post_id}")
        return post_id
    except xmlrpc.client.Fault as err:
        print(f"Failed to publish post: {err.faultCode} - {err.faultString}")
        return None
    except Exception as e:
        print(f"An unexpected error occurred: {e}")
        return None

if __name__ == "__main__":
    # Load your generated article
    try:
        with open("generated_blog_post.md", "r") as f:
            article_content = f.read()
    except FileNotFoundError:
        print("Error: generated_blog_post.md not found. Please run article_generator.py first.")
        exit()

    # Assuming you extract title, categories, tags from the first part of the markdown
    # For a real workflow, you'd parse them from the generated content or a config file.
    post_title = "Automating Your Content Pipeline with Python and AI in 2025 (Automated Test)"
    post_categories = ["AI Blogging", "Automation"]
    post_tags = ["python-2025", "AI-2025", "WordPress-Automation"]

    # Limit content for quick test if it's too large, or publish full
    published_id = publish_post_to_wordpress(
        post_title,
        article_content,
        categories=post_categories,
        tags=post_tags,
        status="draft" # Publish as draft first for review!
    )
    if published_id:
        print(f"Check your WordPress dashboard for post ID: {published_id}")
    else:
        print("Post publishing failed.")