Automating Blog Post Creation with Python and AI-Powered Tools

Automating Blog Post Creation with Python and AI-Powered Tools

In today’s fast-paced world, keeping up with trends, research, and revolutionary ideas can be a daunting task. Automating this process not only saves time but also ensures a steady flow of fresh content for blogs or newsletters. In this post, we will explore a Python-based system that pulls content from RSS feeds, analyzes the material using AI, and generates blog posts automatically. This system is ideal for anyone looking to harness the power of automation and AI to maintain an updated blog with minimal effort.

We will focus on an example where the goal is to generate blog content by analyzing RSS feeds and determining whether the articles are "revolutionary" or groundbreaking.

Step 1: Parsing RSS Feeds

RSS feeds provide a standardized way of accessing updates from various sources. Python's feedparser module is used to fetch articles from scientific journals or other specified sources. Each feed contains entries with metadata such as titles and summaries, which will serve as inputs for further analysis.

Here’s a simple function to parse and extract articles from an RSS feed:

import feedparser

def get_rss_articles(rss_urls):
    all_articles = []
    for rss_url in rss_urls:
        feed = feedparser.parse(rss_url)
        for entry in feed.entries:
            title = entry.title
            summary = entry.summary
            all_articles.append({"title": title, "summary": summary})
    return all_articles

This function collects articles by iterating over RSS feed URLs and extracting the title and summary for each article. These summaries will later be analyzed to determine their revolutionary potential.

Step 2: AI-Assisted Analysis of Revolutionary Content

Once the articles are collected, the next step involves evaluating whether the content is revolutionary. This is where AI steps in. Using GPT models, we can create a prompt that analyzes an article summary and responds with whether the ideas in the article are revolutionary.

The power of this approach lies in the flexibility of AI language models, which can process complex data and provide insightful responses based on human-like understanding of the content.

import openai

openai.api_key = 'your-api-key'

def generate_revolutionary_prompt(article_summary):
    prompt = f"""
        Read this article summary carefully: '{article_summary}'. 
        Analyze whether the ideas presented are revolutionary and if they are likely to have a significant impact on future decades. 
        Respond with 'yes' or 'no'. 
        Before responding 'yes', carefully consider if this discovery solves a major problem for humanity and will greatly improve the future of humanity, 
        otherwise, it is a 'no'.
    """
    return prompt

def is_revolutionary(article_summary):
    prompt = generate_revolutionary_prompt(article_summary)
    response = openai.Completion.create(
        model="gpt-4",
        prompt=prompt,
        max_tokens=50
    )
    return "yes" in response.choices[0].text.lower()

Here, the system creates a custom prompt for each article summary. By leveraging OpenAI’s API, the script sends this prompt and receives a response, determining whether the article is revolutionary or not. If the response is affirmative, we proceed to generate blog content.

Step 3: Generating Blog Content

If an article is deemed revolutionary, the script moves forward by generating a blog post. The generation of the blog content relies on a pre-built prompt template, where details like the title, summary, and justification are filled in dynamically.

Here’s a function that reads a template and fills in the article's data:

def generate_blog_post(revolutionary_article):
    with open('prompts/blog_template.txt', 'r') as file:
        template = file.read()

    return template.format(
        title_article=revolutionary_article['title'],
        summary=revolutionary_article['summary'],
        revolutionary_justification=revolutionary_article['revolutionary_justification']
    )

By maintaining the template in a separate file, this approach allows for easy customization of the blog post structure without changing the code itself. This decoupling of logic and content structure is a best practice in any scalable content generation system.

Step 4: Publishing the Generated Blog Post

Finally, once the content has been generated, it needs to be published. This script integrates with a Ghost blog using the Ghost Admin API, allowing for the automated posting of content directly onto the blog platform. It involves creating a signed token to authenticate API requests.

Here’s how the publishing mechanism works:

import requests
import jwt
from datetime import datetime, timezone

def publish_post(title, slug, content, status, tags, meta_title, meta_description):
    API_URL = 'your-ghost-api-url'
    ADMIN_API_KEY = 'your-admin-api-key'

    id, secret = ADMIN_API_KEY.split(':')

    iat = int(datetime.now().timestamp())
    header = {'alg': 'HS256', 'typ': 'JWT', 'kid': id}
    payload = {
        'iat': iat,
        'exp': iat + 5 * 60,
        'aud': '/admin/'
    }

    token = jwt.encode(payload, bytes.fromhex(secret), algorithm='HS256', headers=header)

    published_at = datetime.now(timezone.utc).isoformat(timespec='milliseconds')
    post_data = {
        "posts": [{
            "title": title,
            "slug": slug,
            "html": content,
            "status": status,
            "published_at": published_at,
            "tags": tags,
            "meta_title": meta_title,
            "meta_description": meta_description
        }]
    }

    url = f"{API_URL}/ghost/api/admin/posts/?source=html"
    headers = {'Authorization': f'Ghost {token}'}

    response = requests.post(url, json=post_data, headers=headers)
    if response.status_code == 201:
        print("Post published successfully!")
    else:
        print(f"Error: {response.status_code}, {response.text}")

This function creates a post by sending an authenticated request to the Ghost API. It includes parameters such as the post's title, slug, content, and other metadata. The jwt module is used to sign the token, ensuring that only authorized requests can publish posts.

Scheduling the Process

To automate this system fully, it’s possible to use the schedule module in Python to set up recurring tasks. The blog generation job can be scheduled to run at specified intervals, ensuring that the blog is continuously updated with minimal manual intervention.

import schedule
import time

def job():
    rss_urls = ['https://www.nature.com/nature.rss']
    articles = get_rss_articles(rss_urls)
    # Process articles and publish posts...

schedule.every(1).hours.do(job)

while True:
    schedule.run_pending()
    time.sleep(10)

In this example, the job function is scheduled to run every hour. You can easily modify the time intervals based on your requirements.

Conclusion

This Python-based system is an excellent example of how automation and AI can be combined to streamline content generation. By fetching and analyzing RSS feeds, generating blog posts, and publishing them automatically, the system takes the heavy lifting out of blog management. This approach saves time and ensures that your blog stays updated with fresh, revolutionary content.

While this example focuses on scientific content, the same principles can be applied to any field with available RSS feeds and a desire to automate content creation.

Read more