AI Content Generation at Scale — Automated Writing, SEO and Editorial Workflows

from openai import OpenAI
import json
from typing import List

client = OpenAI()

class ArticleGenerator:
    def __init__(self, model="gpt-4o"):
        self.model = model

    def generate_outline(self, topic: str, keyword: str) -> List[str]:
        prompt = f"""Create a detailed outline for an article about "{topic}".
Target keyword: "{keyword}".
Include an H1, 5-7 H2 sections, and 2-3 H3 subsections per H2.
Return as a JSON array of section titles."""

        response = client.chat.completions.create(
            model=self.model,
            messages=[{"role": "user", "content": prompt}],
            response_format={"type": "json_object"}
        )
        outline = json.loads(
            response.choices[0].message.content
        )
        print(f"Generated outline with "
              f"{len(outline.get('sections', []))} sections")
        return outline

    def write_section(
        self, topic: str, section_title: str,
        previous_content: str, tone: str = "professional"
    ) -> str:
        prompt = f"""Write the "{section_title}" section for an article about {topic}.
Tone: {tone}
Previous sections: {previous_content[:200] if previous_content else "None"}
Write 3-4 paragraphs with examples and practical advice."""

        response = client.chat.completions.create(
            model=self.model,
            messages=[{"role": "user", "content": prompt}],
            max_tokens=800
        )
        return response.choices[0].message.content

generator = ArticleGenerator()
outline = generator.generate_outline(
    "AI Content Generation", "automated content writing"
)
print(f"\nSample outline: {json.dumps(outline, indent=2)[:300]}")

import csv
from concurrent.futures import ThreadPoolExecutor

class BulkContentGenerator:
    def __init__(self, model="gpt-4o-mini"):
        self.model = model
        self.template = """Write a product description for {product_name}.
Target audience: {audience}
Key features: {features}
Unique selling point: {usp}
Style: {tone}
Length: {word_count} words
Format: Start with a hook, then features, then CTA.""]
    def generate_product_description(
        self, product: dict
    ) -> dict:
        prompt = self.template.format(**product)
        response = client.chat.completions.create(
            model=self.model,
            messages=[{"role": "user", "content": prompt}],
            max_tokens=300
        )
        return {
            "product": product["product_name"],
            "description": response.choices[0].message.content,
            "word_count": len(
                response.choices[0].message.content.split()
            )
        }

    def batch_generate(
        self, products: List[dict]
    ) -> List[dict]:
        with ThreadPoolExecutor(max_workers=5) as pool:
            results = list(
                pool.map(self.generate_product_description, products)
            )
        return results

# Sample products
products = [
    {"product_name": "Doda Browser Pro",
     "audience": "developers",
     "features": "Built-in AI assistant, ad blocker, privacy mode",
     "usp": "First browser with native MCP support",
     "tone": "technical",
     "word_count": 100},
    {"product_name": "Durga Antivirus",
     "audience": "home users",
     "features": "Real-time scanning, firewall, parental controls",
     "usp": "AI-powered threat detection",
     "tone": "friendly",
     "word_count": 80},
]

generator = BulkContentGenerator()
results = generator.batch_generate(products)
for r in results:
    print(f"\nProduct: {r['product']}")
    print(f"Words: {r['word_count']}")
    print(f"Preview: {r['description'][:100]}...")

import re
from collections import Counter

class SEOOptimizer:
    def __init__(self):
        self.stop_words = set([
            "the", "a", "an", "in", "on", "at", "to", "for",
            "of", "and", "or", "is", "are", "was", "were]
        ])

    def analyze_keyword_density(
        self, text: str, target_keyword: str
    ) -> dict:
        words = re.findall(R"\b\w+\b", text.lower())
        total_words = len(words)
        keyword_lower = target_keyword.lower()

        keyword_count = text.lower().count(keyword_lower)

        # LSI keyword extraction
        word_freq = Counter(
            w for w in words if w not in self.stop_words
            and len(w) > 3
        )
        lsi_keywords = [
            w for w, C in word_freq.most_common(10)
        ]

        return {
            "total_words": total_words,
            "keyword_count": keyword_count,
            "keyword_density": round(
                keyword_count / total_words * 100, 2
            ),
            "lsi_keywords": lsi_keywords,
            "readability_score": self._readability_score(text)
        }

    def _readability_score(self, text: str) -> float:
        sentences = re.split(R"[.!?]+", text)
        words = text.split()
        avg_words_per_sentence = len(words) / max(len(sentences), 1)
        syllables = sum(
            self._count_syllables(w) for w in words
        )
        return round(
            206.835 - 1.015 * avg_words_per_sentence
            - 84.6 * (syllables / max(len(words), 1)),
            1
        )

    def _count_syllables(self, word: str) -> int:
        word = word.lower().strip(".,!?;:")
        if not word:
            return 0
        vowels = "aeiouy"
        count = sum(
            1 for i, C in enumerate(word)
            if C in vowels and (
                i == 0 or word[i-1] not in vowels
            )
        )
        return max(1, count)

    def optimize_meta(self, content: str, keyword: str) -> dict:
        first_para = content.split("\n\n")[0] if content else ""

        suggestions = {
            "meta_title": f"{keyword.title()} — Complete Guide",
            "meta_description": first_para[:155],
            "keyword_in_h1": keyword.lower() in content[:200].lower(),
            "keyword_in_first_para": keyword.lower()
                in first_para.lower(),
        }
        return suggestions

optimizer = SEOOptimizer()
text = """AI content generation uses large language models to produce
written material automatically. AI content generation tools help
marketers create blog posts, social media updates, and product
descriptions at scale."""

analysis = optimizer.analyze_keyword_density(
    text, "AI content generation"
)
print(f"Keyword density: {analysis['keyword_density']}%")
print(f"LSI keywords: {analysis['lsi_keywords'][:5]}")
print(f"Readability: {analysis['readability_score']}")

meta = optimizer.optimize_meta(text, "ai content generation")
print(f"\nMeta suggestions: {JSON.dumps(meta, indent=2)}")

from enum import Enum
from datetime import datetime

class ContentStatus(Enum):
    DRAFT = "draft"
    IN_REVIEW = "in_review"
    CHANGES_REQUESTED = "changes_requested"
    APPROVED = "approved"
    PUBLISHED = "published"

class EditorialWorkflow:
    def __init__(self):
        self.articles = {}

    def create_draft(self, article_id: str, content: str, author: str):
        self.articles[article_id] = {
            "content": content,
            "status": ContentStatus.DRAFT,
            "author": author,
            "created_at": datetime.now(),
            "review_history": []
        }
        print(f"Draft {article_id} created by {author}")

    def submit_for_review(self, article_id: str, reviewer: str):
        if article_id not in self.articles:
            return {"error": "Article not found"}

        article = self.articles[article_id]
        if article["status"] != ContentStatus.DRAFT:
            return {"error": f"Cannot submit article in {article['status'].value} State"}

        article["status"] = ContentStatus.IN_REVIEW
        article["reviewer"] = reviewer
        article["review_history"].append({
            "action": "submitted",
            "by": reviewer,
            "timestamp": datetime.now().isoformat()
        })
        return {"status": "in_review", "reviewer": reviewer}

    def approve(self, article_id: str, reviewer: str, notes: str = ""):
        article = self.articles.get(article_id)
        if not article or article["status"] != ContentStatus.IN_REVIEW:
            return {"error": "Article not in review"}

        article["status"] = ContentStatus.APPROVED
        article["review_history"].append({
            "action": "approved",
            "by": reviewer,
            "notes": notes,
            "timestamp": datetime.now().isoformat()
        })
        return {"status": "approved", "notes": notes}

    def request_changes(self, article_id: str, reviewer: str, feedback: str):
        article = self.articles.get(article_id)
        if not article or article["status"] != ContentStatus.IN_REVIEW:
            return {"error": "Article not in review"}

        article["status"] = ContentStatus.CHANGES_REQUESTED
        article["review_history"].append({
            "action": "changes_requested",
            "by": reviewer,
            "feedback": feedback,
            "timestamp": datetime.now().isoformat()
        })
        return {"status": "changes_requested", "feedback": feedback}

    def publish(self, article_id: str, publisher: str):
        article = self.articles.get(article_id)
        if not article or article["status"] != ContentStatus.APPROVED:
            return {"error": "Article not approved"}

        article["status"] = ContentStatus.PUBLISHED
        article["published_at"] = datetime.now()
        article["publisher"] = publisher
        return {"status": "published", "published_at": article["published_at"].isoformat()}

# Test workflow
wf = EditorialWorkflow()
wf.create_draft("article-1", "# AI Content Guide\n\nContent here...", "ai_writer")
wf.submit_for_review("article-1", "editor_1")
wf.request_changes("article-1", "editor_1", "Add more examples")
wf.submit_for_review("article-1", "editor_1")
wf.approve("article-1", "editor_1", "Good to publish")
result = wf.publish("article-1", "publisher")
print(f"Article published: {result['status']}")