How One Creator Automated Their Niche Blog and Now Earns on Autopilot

import requests
import json
import os
from datetime import datetime, timedelta

# --- Configuration ---
# Note: For Google Trends, you'd typically use a library like 'pytrends' or a paid API service
# that offers direct access to trending searches. This is a simplified example.
GOOGLE_TRENDS_API_ENDPOINT = "https://api.example.com/trends/daily?geo=US&category=sustainable-gardening" # Fictional
SERPAPI_API_KEY = os.getenv("SERPAPI_API_KEY")
SEARCH_ENGINE = "google"

def get_trending_topics(niche_category):
    """Fetches trending topics for a given niche."""
    # In a real scenario, this would use a robust Google Trends API wrapper
    # or a service that provides similar data.
    print(f"Fetching trending topics for: {niche_category}...")
    try:
        response = requests.get(GOOGLE_TRENDS_API_ENDPOINT)
        response.raise_for_status() # Raise an HTTPError for bad responses (4xx or 5xx)
        trending_data = response.json()
        return [item['query'] for item in trending_data.get('trends', [])]
    except requests.exceptions.RequestException as e:
        print(f"Error fetching trending topics: {e}")
        return []

def analyze_serp(keyword):
    """Uses SerpAPI to analyze SERP for a keyword and find related questions/keywords."""
    if not SERPAPI_API_KEY:
        print("SERPAPI_API_KEY not set. Skipping SERP analysis.")
        return {}

    params = {
        "engine": SEARCH_ENGINE,
        "q": keyword,
        "api_key": SERPAPI_API_KEY,
        "output": "json"
    }
    print(f"Analyzing SERP for: '{keyword}'...")
    try:
        response = requests.get("https://serpapi.com/search", params=params)
        response.raise_for_status()
        serp_data = response.json()

        related_questions = [q['question'] for q in serp_data.get('related_questions', [])]
        related_searches = [s['query'] for s in serp_data.get('related_searches', [])]
        
        return {
            "related_questions": related_questions,
            "related_searches": related_searches
        }
    except requests.exceptions.RequestException as e:
        print(f"Error analyzing SERP for '{keyword}': {e}")
        return {}

if __name__ == "__main__":
    niche = "sustainable urban gardening"
    
    # 1. Get trending topics
    hot_topics = get_trending_topics(niche)
    
    if hot_topics:
        print("\n--- Identified Hot Topics ---")
        for topic in hot_topics[:3]: # Just take top 3 for demo
            print(f"- {topic}")
            
            # 2. Analyze SERP for each hot topic
            serp_insights = analyze_serp(topic)
            if serp_insights:
                if serp_insights.get("related_questions"):
                    print("  Related Questions:")
                    for q in serp_insights["related_questions"][:2]:
                        print(f"    - {q}")
                if serp_insights.get("related_searches"):
                    print("  Related Searches:")
                    for s in serp_insights["related_searches"][:2]:
                        print(f"    - {s}")
            print("-" * 20)
    else:
        print("No hot topics found or error occurred.")

    # Example of a hardcoded target keyword for direct analysis
    print("\n--- Direct Keyword Analysis Example ---")
    direct_keyword = "hydroponic indoor herbs for beginners"
    serp_insights_direct = analyze_serp(direct_keyword)
    if serp_insights_direct:
        print(f"Insights for '{direct_keyword}':")
        if serp_insights_direct.get("related_questions"):
            print("  Related Questions:")
            for q in serp_insights_direct["related_questions"][:3]:
                print(f"    - {q}")
        if serp_insights_direct.get("related_searches"):
            print("  Related Searches:")
            for s in serp_insights_direct["related_searches"][:3]:
                print(f"    - {s}")

import os
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
from dotenv import load_dotenv

load_dotenv() # Load environment variables from .env file

# --- Configuration ---
# Ensure your OPENAI_API_KEY is set as an environment variable
# In 2025, assume 'text-davinci-005' might be GPT-5 or similar model name
LLM_MODEL = "gpt-5-turbo" # Hypothetical GPT-5 equivalent
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")

if not OPENAI_API_KEY:
    raise ValueError("OPENAI_API_KEY environment variable not set.")

# Initialize the LLM (Large Language Model)
llm = OpenAI(model_name=LLM_MODEL, openai_api_key=OPENAI_API_KEY, temperature=0.7)

def generate_blog_post(topic: str, keywords: list, length: str = "medium"):
    """
    Generates a blog post draft using LangChain and a specified LLM.
    
    Args:
        topic (str): The main topic of the blog post.
        keywords (list): A list of keywords to naturally include.
        length (str): Desired length ('short', 'medium', 'long').
    
    Returns:
        str: The generated blog post content.
    """
    
    prompt_template = PromptTemplate(
        input_variables=["topic", "keywords", "length"],
        template="""You are an expert blogger specializing in {topic}.
        Your goal is to write a comprehensive, engaging, and SEO-optimized blog post.
        The post should be a {length} length article.
        
        Title: How to Grow {topic} at Home: A Beginner's Guide
        
        Focus on providing practical advice and easy-to-follow steps.
        Naturally incorporate the following keywords throughout the article: {keywords}.
        
        Structure:
        - Introduction (Hook, what reader will learn)
        - Section 1: Why {topic}
        - Section 2: Essential Tools & Materials
        - Section 3: Step-by-Step Growing Guide
        - Section 4: Common Problems & Solutions
        - Conclusion (Summary, call to action)
        
        Ensure a friendly, informative, and encouraging tone. Use Markdown for formatting.
        """
    )

    chain = LLMChain(llm=llm, prompt=prompt_template)
    
    print(f"Generating blog post on '{topic}' with keywords: {', '.join(keywords)}...")
    response = chain.run(topic=topic, keywords=", ".join(keywords), length=length)
    
    return response

if __name__ == "__main__":
    target_topic = "Indoor Hydroponic Herbs"
    target_keywords = ["hydroponic systems", "grow lights", "nutrient solution", "beginner hydroponics", "herb gardening indoor"]
    
    article_draft = generate_blog_post(target_topic, target_keywords, length="medium")
    
    print("\n--- Generated Article Draft ---")
    print(article_draft)
    
    # You would then save this to a file or pass it to the next stage
    with open("generated_article_draft.md", "w") as f:
        f.write(article_draft)
    print("\nDraft saved to generated_article_draft.md")

import os
from wordpress_xmlrpc import Client, WordPressPost
from wordpress_xmlrpc.methods.posts import NewPost, EditPost
from wordpress_xmlrpc.methods.media import UploadFile
from wordpress_xmlrpc.compat import xmlrpc_client
from dotenv import load_dotenv

load_dotenv() # Load environment variables

# --- Configuration ---
WP_URL = os.getenv("WP_URL") # e.g., "https://yourblog.com/xmlrpc.php"
WP_USERNAME = os.getenv("WP_USERNAME")
WP_PASSWORD = os.getenv("WP_PASSWORD")

if not all([WP_URL, WP_USERNAME, WP_PASSWORD]):
    raise ValueError("WordPress credentials (WP_URL, WP_USERNAME, WP_PASSWORD) not set as environment variables.")

def publish_article_to_wordpress(title: str, content: str, categories: list, tags: list, image_path: str = None):
    """
    Publishes an article to WordPress.
    
    Args:
        title (str): The title of the post.
        content (str): The HTML content of the post.
        categories (list): List of category names.
        tags (list): List of tag names.
        image_path (str): Optional path to a featured image.
    """
    try:
        client = Client(WP_URL, WP_USERNAME, WP_PASSWORD)
        
        post = WordPressPost()
        post.title = title
        post.content = content
        post.post_status = 'publish' # Use 'draft' for review first
        
        # Set categories and tags
        post.terms_names = {
            'category': categories,
            'post_tag': tags
        }

        # Upload featured image if provided
        if image_path and os.path.exists(image_path):
            print(f"Uploading featured image: {image_path}...")
            # Prepare metadata for the image upload
            data = {
                'name': os.path.basename(image_path),
                'type': 'image/jpeg', # Adjust type based on your image
            }
            with open(image_path, 'rb') as img:
                data['bits'] = xmlrpc_client.Binary(img.read())
            
            response = client.call(UploadFile(data))
            attachment_id = response['id']
            post.thumbnail = attachment_id
            print(f"Image uploaded. Attachment ID: {attachment_id}")
        else:
            print("No valid image path provided or file does not exist. Skipping featured image.")

        print(f"Publishing article: '{title}'...")
        post_id = client.call(NewPost(post))
        print(f"Article published successfully! Post ID: {post_id}")
        print(f"View post: {WP_URL.replace('/xmlrpc.php', '')}/?p={post_id}") # Basic link example
        
    except Exception as e:
        print(f"Error publishing to WordPress: {e}")

if __name__ == "__main__":
    # In a real scenario, this content would come from the AI generation step
    article_title = "How to Grow Indoor Hydroponic Herbs for Beginners"
    article_content = """
    <h1>How to Grow Indoor Hydroponic Herbs at Home: A Beginner's Guide</h1>
    <p>Are you dreaming of fresh basil, crisp mint, or aromatic rosemary available right from your kitchen, no soil required? Welcome to the exciting world of indoor hydroponic herbs!...</p>
    <p>... (truncated for brevity, imagine the full HTML content from the AI draft) ...</p>
    <h2>Conclusion</h2>
    <p>Setting up your indoor hydroponic herbs garden is a rewarding journey.</p>
    """
    
    article_categories = ["Hydroponics", "Gardening Tips", "Beginner Guides"]
    article_tags = ["hydroponic herbs", "indoor gardening", "sustainable", "DIY"]
    
    # Create a dummy image file for demonstration
    dummy_image_path = "featured_image.jpg"
    try:
        from PIL import Image
        img = Image.new('RGB', (600, 400), color = 'red')
        img.save(dummy_image_path)
        print(f"Created dummy image at: {dummy_image_path}")
    except ImportError:
        print("Pillow not installed. Cannot create dummy image. Skipping image upload.")
        dummy_image_path = None
    
    publish_article_to_wordpress(article_title, article_content, article_categories, article_tags, dummy_image_path)

    # Clean up dummy image
    if dummy_image_path and os.path.exists(dummy_image_path):
        os.remove(dummy_image_path)
        print(f"Removed dummy image: {dummy_image_path}")

#!/bin/bash

# Path to your Python environment and scripts
PYTHON_ENV="/home/alex/my_automation_env/bin/python"
BASE_DIR="/home/alex/blog_automation"
LOG_FILE="${BASE_DIR}/automation.log"

# Export API keys and other sensitive data (handled by .env loading in Python scripts)
# For cron, you might need to explicitly source your .bashrc or provide full paths
# export OPENAI_API_KEY="sk-..."
# export SERPAPI_API_KEY="your_serpapi_key"
# export WP_URL="https://yourblog.com/xmlrpc.php"
# export WP_USERNAME="your_wp_user"
# export WP_PASSWORD="your_wp_password"

echo "Starting daily blog automation at $(date)" >> $LOG_FILE

# Step 1: Run keyword research
echo "Running keyword research..." >> $LOG_FILE
$PYTHON_ENV "${BASE_DIR}/keyword_research.py" >> $LOG_FILE 2>&1

# Check if keyword research generated new topics (this is a simplified check)
# In a real scenario, you'd have a database or file to track new topics
if [ -s "${BASE_DIR}/new_topics.txt" ]; then # Checks if file exists and is not empty
    NEW_TOPIC=$(head -n 1 "${BASE_DIR}/new_topics.txt") # Get the first topic
    echo "Found new topic: $NEW_TOPIC" >> $LOG_FILE

    # Step 2: Generate article draft (passing the topic)
    echo "Generating article draft for: '$NEW_TOPIC'..." >> $LOG_FILE
    # This assumes generate_blog_post.py saves to a known file and can take topic as argument
    # For simplicity, we'll use the hardcoded topic from the previous python example,
    # but in real life, you'd pass the $NEW_TOPIC to the script.
    $PYTHON_ENV "${BASE_DIR}/generate_blog_post.py" "$NEW_TOPIC" >> $LOG_FILE 2>&1

    # Check if article draft was created
    if [ -s "${BASE_DIR}/generated_article_draft.md" ]; then
        echo "Article draft created. Processing for publication..." >> $LOG_FILE
        # Assume an intermediate script converts MD to HTML and prepares for publishing
        # Example: markdown_to_html_converter.py
        # $PYTHON_ENV "${BASE_DIR}/markdown_to_html_converter.py" "${BASE_DIR}/generated_article_draft.md" > "${BASE_DIR}/final_article.html"

        # Step 3: Publish to WordPress
        # In this simplified flow, publish_to_wordpress.py would read the generated article.
        echo "Publishing article to WordPress..." >> $LOG_FILE
        $PYTHON_ENV "${BASE_DIR}/publish_to_wordpress.py" >> $LOG_FILE 2>&1

        # Clean up temporary files
        rm "${BASE_DIR}/generated_article_draft.md"
        # rm "${BASE_DIR}/final_article.html" # if applicable
        rm "${BASE_DIR}/new_topics.txt" # Clear topic list for next run
        echo "Cleanup complete." >> $LOG_FILE
    else
        echo "Article draft not created or is empty. Skipping publishing." >> $LOG_FILE
    fi
else
    echo "No new topics found for today. Skipping content generation." >> $LOG_FILE
fi

echo "Daily blog automation finished at $(date)" >> $LOG_FILE