diff --git a/lib/ai_writers/ai_blog_rewriter.py b/lib/ai_writers/ai_blog_rewriter.py
index 683fcf70..48faf139 100644
--- a/lib/ai_writers/ai_blog_rewriter.py
+++ b/lib/ai_writers/ai_blog_rewriter.py
@@ -1,100 +1,1139 @@
-"""AI-powered blog rewriter tool."""
+"""
+AI Blog Rewriter Module
+
+This module provides functionality to rewrite and update existing blog content
+with improved quality, factual accuracy, and SEO optimization.
+"""
import streamlit as st
-from bs4 import BeautifulSoup
import requests
-from transformers import pipeline
+from bs4 import BeautifulSoup
+import re
import time
-from exa_py import Exa
+import logging
+from typing import Dict, List, Tuple, Optional, Any
+import json
+import os
+from datetime import datetime
-# Load the LLM
-generator = pipeline('text-generation', model='gpt-3') # Example, adjust based on your model
+# Import required modules from the project
+from ..gpt_providers.text_generation.main_text_generation import llm_text_gen
+from ..gpt_providers.text_to_image_generation.main_generate_image_from_prompt import generate_image
+from ..web_research.exa_search import exa_search
+from ..web_research.tavily_search import tavily_search
-def main():
- st.markdown("AI Blog Content Refresher
", unsafe_allow_html=True)
- st.markdown("Keep your blog fresh and engaging with AI!
", unsafe_allow_html=True)
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
- # User Inputs
- with st.form("content_refresh_form"):
- url = st.text_input("Enter Blog Post URL", placeholder="https://www.example.com/blog-post")
- keywords = st.text_area("Enter Relevant Keywords", placeholder="Example: 'SEO best practices', 'digital marketing tips'")
- tone = st.selectbox("Choose Desired Tone", ["Formal", "Informal", "Engaging", "Informative"])
- target_audience = st.text_input("Target Audience", placeholder="e.g., tech enthusiasts, business owners")
- desired_length = st.slider("Desired Content Length (words)", min_value=300, max_value=1500, value=600, step=100)
+# Define constants
+MAX_TITLE_LENGTH = 70
+MAX_META_DESCRIPTION_LENGTH = 160
+REWRITE_MODES = {
+ "standard": "Standard rewrite with improved clarity and flow",
+ "seo_optimization": "Optimize for search engines with targeted keywords",
+ "simplification": "Simplify complex content for broader audience",
+ "expansion": "Expand with additional details and examples",
+ "fact_check": "Focus on fact-checking and updating information",
+ "tone_shift": "Change the tone while preserving content",
+ "modernization": "Update outdated content with current information"
+}
- submitted = st.form_submit_button("Refresh Content")
+# Define tone options
+TONE_OPTIONS = [
+ "Professional", "Conversational", "Academic", "Enthusiastic",
+ "Authoritative", "Friendly", "Technical", "Inspirational"
+]
- if submitted:
- st.markdown("Content Refresh for: "+url+"
", unsafe_allow_html=True)
- st.info(f"Refreshing your blog post...")
-
- # Fetch the existing content
- website_data = collect_website_data(url)
-
- # Get additional context from web research (using Metaphor API)
- web_research_context = get_web_research_context(keywords)
-
- # Generate the updated content
- updated_content = generate_updated_content(
- website_data, keywords, tone, target_audience, desired_length, web_research_context
+class BlogRewriter:
+ """Class to handle blog rewriting functionality."""
+
+ def __init__(self):
+ """Initialize the BlogRewriter class."""
+ self.original_content = {}
+ self.rewritten_content = {}
+ self.research_results = {}
+ self.content_analysis = {}
+ self.image_suggestions = []
+
+ def extract_content_from_url(self, url: str) -> Dict[str, Any]:
+ """
+ Extract content from a given URL.
+
+ Args:
+ url: The URL to extract content from
+
+ Returns:
+ Dictionary containing extracted content
+ """
+ logger.info(f"Extracting content from URL: {url}")
+
+ try:
+ headers = {
+ 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+ }
+ response = requests.get(url, headers=headers, timeout=15)
+ response.raise_for_status()
+
+ soup = BeautifulSoup(response.text, 'html.parser')
+
+ # Extract title
+ title = soup.title.string if soup.title else ""
+
+ # Extract meta description
+ meta_desc = ""
+ meta_tag = soup.find("meta", attrs={"name": "description"})
+ if meta_tag and "content" in meta_tag.attrs:
+ meta_desc = meta_tag["content"]
+
+ # Extract main content - this is a simplified approach
+ # In a real implementation, you'd want more sophisticated content extraction
+ content = ""
+ article_tag = soup.find("article")
+ if article_tag:
+ content = article_tag.get_text(separator="\\n\\n")
+ else:
+ # Try to find main content by looking for common content containers
+ main_content = soup.find(["main", "div", "section"], class_=re.compile(r"content|article|post|entry"))
+ if main_content:
+ # Remove navigation, sidebars, comments, etc.
+ for elem in main_content.find_all(["nav", "aside", "footer", "comments", "script", "style"]):
+ elem.decompose()
+ content = main_content.get_text(separator="\\n\\n")
+ else:
+ # Fallback to body content
+ body = soup.find("body")
+ if body:
+ content = body.get_text(separator="\\n\\n")
+
+ # Clean up the content
+ content = re.sub(r'\\n{3,}', '\\n\\n', content) # Remove excessive newlines
+ content = re.sub(r'\s{2,}', ' ', content) # Remove excessive spaces
+
+ # Extract headings for structure analysis
+ headings = []
+ for h in soup.find_all(["h1", "h2", "h3", "h4", "h5", "h6"]):
+ headings.append({
+ "level": int(h.name[1]),
+ "text": h.get_text().strip()
+ })
+
+ # Extract images
+ images = []
+ for img in soup.find_all("img"):
+ if img.get("src") and not img.get("src").startswith("data:"):
+ image_url = img.get("src")
+ if not image_url.startswith(("http://", "https://")):
+ # Convert relative URL to absolute
+ base_url = "/".join(url.split("/")[:3]) # Get domain
+ image_url = f"{base_url}/{image_url.lstrip('/')}"
+
+ alt_text = img.get("alt", "")
+ images.append({
+ "url": image_url,
+ "alt_text": alt_text
+ })
+
+ # Extract publish date if available
+ publish_date = None
+ date_meta = soup.find("meta", attrs={"property": "article:published_time"})
+ if date_meta and "content" in date_meta.attrs:
+ publish_date = date_meta["content"]
+ else:
+ # Try common date patterns in the HTML
+ date_elem = soup.find(["time", "span", "div"], class_=re.compile(r"date|time|publish"))
+ if date_elem and date_elem.get_text():
+ publish_date = date_elem.get_text().strip()
+
+ # Extract author if available
+ author = None
+ author_meta = soup.find("meta", attrs={"name": "author"})
+ if author_meta and "content" in author_meta.attrs:
+ author = author_meta["content"]
+ else:
+ # Try common author patterns in the HTML
+ author_elem = soup.find(["a", "span", "div"], class_=re.compile(r"author|byline"))
+ if author_elem and author_elem.get_text():
+ author = author_elem.get_text().strip()
+
+ return {
+ "title": title,
+ "meta_description": meta_desc,
+ "content": content,
+ "headings": headings,
+ "images": images,
+ "publish_date": publish_date,
+ "author": author,
+ "url": url
+ }
+
+ except Exception as e:
+ logger.error(f"Error extracting content from URL: {e}")
+ return {
+ "title": "",
+ "meta_description": "",
+ "content": "",
+ "headings": [],
+ "images": [],
+ "publish_date": None,
+ "author": None,
+ "url": url,
+ "error": str(e)
+ }
+
+ def analyze_content(self, content: Dict[str, Any]) -> Dict[str, Any]:
+ """
+ Analyze the extracted content to provide insights.
+
+ Args:
+ content: Dictionary containing extracted content
+
+ Returns:
+ Dictionary containing content analysis
+ """
+ logger.info("Analyzing content")
+
+ analysis = {}
+
+ # Basic metrics
+ text_content = content.get("content", "")
+ word_count = len(text_content.split())
+ sentence_count = len(re.split(r'[.!?]+', text_content))
+ paragraph_count = len(re.split(r'\\n\\n+', text_content))
+
+ analysis["metrics"] = {
+ "word_count": word_count,
+ "sentence_count": sentence_count,
+ "paragraph_count": paragraph_count,
+ "avg_words_per_sentence": round(word_count / max(sentence_count, 1), 1),
+ "avg_sentences_per_paragraph": round(sentence_count / max(paragraph_count, 1), 1)
+ }
+
+ # Heading structure analysis
+ headings = content.get("headings", [])
+ heading_structure = {}
+ for h in headings:
+ level = h["level"]
+ if level not in heading_structure:
+ heading_structure[level] = 0
+ heading_structure[level] += 1
+
+ analysis["heading_structure"] = heading_structure
+
+ # Content age analysis
+ publish_date = content.get("publish_date")
+ if publish_date:
+ try:
+ # Try to parse the date in various formats
+ if "T" in publish_date:
+ # ISO format
+ pub_date = datetime.fromisoformat(publish_date.replace("Z", "+00:00"))
+ else:
+ # Try common date formats
+ date_formats = [
+ "%Y-%m-%d", "%d-%m-%Y", "%B %d, %Y", "%b %d, %Y",
+ "%d %B %Y", "%d %b %Y", "%Y/%m/%d", "%d/%m/%Y"
+ ]
+ for fmt in date_formats:
+ try:
+ pub_date = datetime.strptime(publish_date, fmt)
+ break
+ except ValueError:
+ continue
+
+ # Calculate content age
+ now = datetime.now()
+ age_days = (now - pub_date).days
+ analysis["content_age"] = {
+ "days": age_days,
+ "months": round(age_days / 30, 1),
+ "years": round(age_days / 365, 1)
+ }
+ except Exception as e:
+ logger.warning(f"Could not parse publish date: {e}")
+ analysis["content_age"] = {"error": "Could not determine content age"}
+ else:
+ analysis["content_age"] = {"error": "No publish date found"}
+
+ # Image analysis
+ images = content.get("images", [])
+ analysis["images"] = {
+ "count": len(images),
+ "with_alt_text": sum(1 for img in images if img.get("alt_text"))
+ }
+
+ return analysis
+
+ def conduct_research(self, title: str, content: str, research_depth: str = "medium") -> Dict[str, Any]:
+ """
+ Conduct web research to find updated information related to the blog content.
+
+ Args:
+ title: Blog title
+ content: Blog content
+ research_depth: Depth of research (low, medium, high)
+
+ Returns:
+ Dictionary containing research results
+ """
+ logger.info(f"Conducting research with depth: {research_depth}")
+
+ # Extract key topics from the content
+ prompt = f"""
+ Extract 3-5 key topics or claims from this blog content that might need fact-checking or updating.
+ For each topic, provide a concise search query that would help find the most recent information.
+
+ Blog title: {title}
+
+ First 1000 characters of content:
+ {content[:1000]}...
+
+ Format your response as a JSON array of objects with 'topic' and 'query' fields.
+ """
+
+ try:
+ topics_json = llm_text_gen(prompt)
+ # Extract JSON from the response
+ topics_json = re.search(r'\[.*\]', topics_json, re.DOTALL)
+ if topics_json:
+ topics = json.loads(topics_json.group(0))
+ else:
+ # Fallback if JSON extraction fails
+ topics = [
+ {"topic": title, "query": title + " latest information"},
+ {"topic": "Updates on " + title, "query": title + " recent developments"}
+ ]
+ except Exception as e:
+ logger.error(f"Error extracting topics: {e}")
+ topics = [
+ {"topic": title, "query": title + " latest information"},
+ {"topic": "Updates on " + title, "query": title + " recent developments"}
+ ]
+
+ # Determine number of results based on research depth
+ num_results = {"low": 2, "medium": 3, "high": 5}.get(research_depth, 3)
+
+ research_results = {"topics": []}
+
+ # Conduct research for each topic
+ for topic in topics[:3]: # Limit to 3 topics to avoid excessive API calls
+ topic_results = {"topic": topic["topic"], "sources": []}
+
+ # Try Exa search first
+ try:
+ exa_results = exa_search(topic["query"], num_results=num_results)
+ if exa_results:
+ topic_results["sources"].extend(exa_results)
+ except Exception as e:
+ logger.warning(f"Exa search failed: {e}")
+
+ # If Exa didn't return enough results, try Tavily
+ if len(topic_results["sources"]) < num_results:
+ try:
+ tavily_results = tavily_search(topic["query"], num_results=num_results)
+ if tavily_results:
+ # Avoid duplicates
+ existing_urls = [s["url"] for s in topic_results["sources"]]
+ for result in tavily_results:
+ if result["url"] not in existing_urls:
+ topic_results["sources"].append(result)
+ existing_urls.append(result["url"])
+ except Exception as e:
+ logger.warning(f"Tavily search failed: {e}")
+
+ research_results["topics"].append(topic_results)
+
+ return research_results
+
+ def generate_rewrite_prompt(self, original_content: Dict[str, Any],
+ user_preferences: Dict[str, Any],
+ research_results: Dict[str, Any],
+ content_analysis: Dict[str, Any]) -> str:
+ """
+ Generate a prompt for the LLM to rewrite the blog.
+
+ Args:
+ original_content: Original blog content
+ user_preferences: User preferences for rewriting
+ research_results: Research results for updating content
+ content_analysis: Analysis of the original content
+
+ Returns:
+ Prompt string for the LLM
+ """
+ logger.info("Generating rewrite prompt")
+
+ # Extract key information
+ title = original_content.get("title", "")
+ content = original_content.get("content", "")
+
+ # Truncate content if it's too long
+ max_content_length = 6000 # Adjust based on your LLM's context window
+ if len(content) > max_content_length:
+ content_preview = content[:max_content_length] + "...\\n[Content truncated due to length]"
+ else:
+ content_preview = content
+
+ # Format research results
+ research_summary = ""
+ for topic in research_results.get("topics", []):
+ research_summary += f"\\n## {topic['topic']}\\n"
+ for i, source in enumerate(topic.get("sources", [])[:3]): # Limit to 3 sources per topic
+ research_summary += f"Source {i+1}: {source.get('title', 'Untitled')}\\n"
+ research_summary += f"URL: {source.get('url', 'No URL')}\\n"
+ research_summary += f"Content: {source.get('content', 'No content')[:300]}...\\n\\n"
+
+ # Build the prompt
+ prompt = f"""
+ # Blog Rewriting Task
+
+ ## Original Blog Information
+ Title: {title}
+ Word Count: {content_analysis.get('metrics', {}).get('word_count', 'Unknown')}
+ Estimated Age: {content_analysis.get('content_age', {}).get('months', 'Unknown')} months
+
+ ## Rewriting Instructions
+ Mode: {user_preferences.get('rewrite_mode', 'standard')}
+ Target Tone: {user_preferences.get('tone', 'Professional')}
+ Target Word Count: {user_preferences.get('target_word_count', 'Same as original')}
+ Focus Keywords: {', '.join(user_preferences.get('keywords', []))}
+
+ ## Special Instructions
+ {user_preferences.get('special_instructions', 'No special instructions')}
+
+ ## Recent Research Findings
+ {research_summary if research_summary else "No research results available."}
+
+ ## Original Content
+ {content_preview}
+
+ ## Your Task
+ Please rewrite this blog post according to the instructions above. The rewritten blog should:
+
+ 1. Maintain the core message and value of the original content
+ 2. Update any outdated information based on the research findings
+ 3. Adopt the requested tone and style
+ 4. Incorporate the focus keywords naturally
+ 5. Improve readability and engagement
+ 6. Maintain a logical structure with appropriate headings
+ 7. Include a compelling introduction and conclusion
+
+ ## Output Format
+ Please provide your response in the following JSON format:
+ ```json
+ {{
+ "title": "Rewritten title",
+ "meta_description": "SEO-optimized meta description (max 160 characters)",
+ "content": "Full rewritten content with proper markdown formatting",
+ "suggested_images": [
+ {{
+ "description": "Brief description of a suggested image",
+ "caption": "Suggested caption for the image",
+ "placement": "Where this image should be placed (e.g., 'After introduction', 'Before conclusion')"
+ }}
+ ]
+ }}
+ ```
+
+ Ensure the JSON is properly formatted and valid.
+ """
+
+ return prompt
+
+ def rewrite_blog(self, original_content: Dict[str, Any],
+ user_preferences: Dict[str, Any],
+ research_results: Dict[str, Any],
+ content_analysis: Dict[str, Any]) -> Dict[str, Any]:
+ """
+ Rewrite the blog based on original content, user preferences, and research.
+
+ Args:
+ original_content: Original blog content
+ user_preferences: User preferences for rewriting
+ research_results: Research results for updating content
+ content_analysis: Analysis of the original content
+
+ Returns:
+ Dictionary containing rewritten content
+ """
+ logger.info("Rewriting blog content")
+
+ # Generate the prompt
+ prompt = self.generate_rewrite_prompt(
+ original_content, user_preferences, research_results, content_analysis
)
+
+ # Call the LLM to rewrite the content
+ try:
+ response = llm_text_gen(prompt)
+
+ # Extract JSON from the response
+ json_match = re.search(r'```json\s*(.*?)\s*```', response, re.DOTALL)
+ if json_match:
+ json_str = json_match.group(1)
+ else:
+ json_str = response
+
+ # Clean up the JSON string
+ json_str = re.sub(r'```(json)?', '', json_str).strip()
+
+ # Parse the JSON
+ rewritten_content = json.loads(json_str)
+
+ # Validate the response structure
+ required_fields = ["title", "meta_description", "content"]
+ for field in required_fields:
+ if field not in rewritten_content:
+ rewritten_content[field] = original_content.get(field, "")
+
+ # Ensure suggested_images exists
+ if "suggested_images" not in rewritten_content:
+ rewritten_content["suggested_images"] = []
+
+ return rewritten_content
+
+ except Exception as e:
+ logger.error(f"Error rewriting blog: {e}")
+ return {
+ "title": original_content.get("title", ""),
+ "meta_description": original_content.get("meta_description", ""),
+ "content": original_content.get("content", ""),
+ "suggested_images": [],
+ "error": str(e)
+ }
+
+ def generate_image(self, image_prompt: str, style: str = "realistic") -> str:
+ """
+ Generate an image based on the prompt.
+
+ Args:
+ image_prompt: Prompt for image generation
+ style: Style of the image
+
+ Returns:
+ Path to the generated image
+ """
+ logger.info(f"Generating image with prompt: {image_prompt}")
+
+ try:
+ image_path = generate_image(image_prompt, style=style)
+ return image_path
+ except Exception as e:
+ logger.error(f"Error generating image: {e}")
+ return ""
- # Display Results
- st.subheader("Updated Blog Content")
- st.write(updated_content)
-def collect_website_data(url):
- # ... (Your web scraping function remains the same)
-
-def get_web_research_context(keywords):
- """Fetches web research context using Metaphor API."""
- METAPHOR_API_KEY = os.getenv('METAPHOR_API_KEY')
- if not METAPHOR_API_KEY:
- st.error("METAPHOR_API_KEY environment variable not set!")
- return None
-
- metaphor = Exa(METAPHOR_API_KEY)
- try:
- search_response = metaphor.search_and_contents(
- keywords,
- use_autoprompt=True,
- num_results=5
+def write_blog_rewriter():
+ """Main function to display the blog rewriter UI."""
+ st.title("AI Blog Rewriter & Updater")
+
+ # Create a container for the header section
+ with st.container():
+ st.markdown("""
+
+
Revitalize Your Content
+
Update, fact-check, and enhance your existing blog posts with AI assistance.
+ Our tool analyzes your content, researches the latest information, and rewrites your blog
+ to be more engaging, accurate, and SEO-friendly.
+
{st.session_state.rewritten_content['title']}
+ {st.session_state.rewritten_content['content']}
+
+
+ """
+
+ st.download_button(
+ "Download as HTML",
+ data=html_content,
+ file_name=f"{st.session_state.rewritten_content['title'].replace(' ', '_')}.html",
+ mime="text/html"
+ )
+
+ with col3:
+ # Create JSON version with all content and metadata
+ json_content = {
+ "title": st.session_state.rewritten_content["title"],
+ "meta_description": st.session_state.rewritten_content.get("meta_description", ""),
+ "content": st.session_state.rewritten_content["content"],
+ "suggested_images": st.session_state.rewritten_content.get("suggested_images", []),
+ "generated_images": [
+ {
+ "caption": img_data["caption"],
+ "placement": img_data["placement"],
+ "path": img_data["path"]
+ }
+ for img_key, img_data in st.session_state.generated_images.items()
+ ] if hasattr(st.session_state, "generated_images") else [],
+ "original_title": st.session_state.original_content.get("title", ""),
+ "original_url": st.session_state.original_content.get("url", ""),
+ "rewrite_date": datetime.now().isoformat()
+ }
+
+ st.download_button(
+ "Download as JSON",
+ data=json.dumps(json_content, indent=2),
+ file_name=f"{st.session_state.rewritten_content['title'].replace(' ', '_')}.json",
+ mime="application/json"
+ )
+
+ # Copy to clipboard buttons
+ st.subheader("Quick Copy")
+
+ col1, col2, col3 = st.columns(3)
+
+ with col1:
+ if st.button("Copy Title", key="copy_title"):
+ st.code(st.session_state.rewritten_content["title"])
+ st.success("Title copied to clipboard!")
+
+ with col2:
+ if st.button("Copy Meta Description", key="copy_meta"):
+ st.code(st.session_state.rewritten_content.get("meta_description", ""))
+ st.success("Meta description copied to clipboard!")
+
+ with col3:
+ if st.button("Copy Full Content", key="copy_content"):
+ st.success("Content copied to clipboard!")
+
+ # Comparison with original
+ with st.expander("Compare with Original", expanded=False):
+ comp_col1, comp_col2 = st.columns(2)
+
+ with comp_col1:
+ st.subheader("Original")
+ st.markdown(f"**Title:** {st.session_state.original_content.get('title', '')}")
+ if st.session_state.original_content.get("meta_description"):
+ st.markdown(f"**Meta Description:** {st.session_state.original_content['meta_description']}")
+ st.text_area(
+ "Original Content",
+ st.session_state.original_content.get("content", ""),
+ height=300,
+ disabled=True
+ )
+
+ with comp_col2:
+ st.subheader("Rewritten")
+ st.markdown(f"**Title:** {st.session_state.rewritten_content['title']}")
+ if st.session_state.rewritten_content.get("meta_description"):
+ st.markdown(f"**Meta Description:** {st.session_state.rewritten_content['meta_description']}")
+ st.text_area(
+ "Rewritten Content",
+ st.session_state.rewritten_content["content"],
+ height=300,
+ disabled=True
+ )
+
+ # Start over button
+ if st.button("Start Over", type="primary"):
+ # Reset session state
+ for key in ["original_content", "content_analysis", "research_results",
+ "rewritten_content", "generated_images", "current_step"]:
+ if key in st.session_state:
+ del st.session_state[key]
+
+ st.experimental_rerun()
if __name__ == "__main__":
- main()
+ write_blog_rewriter()
\ No newline at end of file
diff --git a/lib/ai_writers/ai_copywriter/copywriter_dashboard.py b/lib/ai_writers/ai_copywriter/copywriter_dashboard.py
index 24bdf95c..e04571dc 100644
--- a/lib/ai_writers/ai_copywriter/copywriter_dashboard.py
+++ b/lib/ai_writers/ai_copywriter/copywriter_dashboard.py
@@ -3,6 +3,9 @@ import importlib
import sys
import os
from pathlib import Path
+import time
+import json
+from typing import Dict, List, Callable, Optional, Tuple
# Add the parent directory to the path to allow importing from lib
current_dir = Path(__file__).parent
@@ -28,132 +31,449 @@ copywriter_modules = [
"4r_copywriter"
]
-# Dynamically import all copywriter modules
-for module_name in copywriter_modules:
+# Define formula categories for better organization
+formula_categories = {
+ "Emotional Appeal": ["ai_emotional_copywriter", "oath_copywriter"],
+ "Structured Framework": ["acca_copywriter", "app_copywriter", "star_copywriter", "quest_copywriter"],
+ "Sales Funnel": ["aidppc_copywriter", "aida_copywriter"],
+ "Problem-Solution": ["pas_copywriter"],
+ "Feature-Benefit": ["fab_copywriter"],
+ "Messaging Framework": ["4c_copywriter", "4r_copywriter"]
+}
+
+# Define formula metadata for better display and filtering
+formula_metadata = {
+ "ai_emotional_copywriter": {
+ "name": "Emotional Copywriter",
+ "icon": "🎭",
+ "description": "Create copy that resonates with your audience's emotions and drives action.",
+ "color": "#FF6B6B",
+ "difficulty": "Intermediate",
+ "best_for": ["Landing Pages", "Email", "Social Media"],
+ "tags": ["emotional", "persuasive", "engagement"]
+ },
+ "acca_copywriter": {
+ "name": "ACCA Copywriter",
+ "icon": "🎯",
+ "description": "Use the ACCA (Attention, Context, Content, Action) framework to create compelling copy.",
+ "color": "#4ECDC4",
+ "difficulty": "Beginner",
+ "best_for": ["Ads", "Email", "Landing Pages"],
+ "tags": ["structured", "conversion", "clear"]
+ },
+ "app_copywriter": {
+ "name": "APP Copywriter",
+ "icon": "🤝",
+ "description": "Implement the APP (Agree, Promise, Preview) formula to create persuasive copy.",
+ "color": "#45B7D1",
+ "difficulty": "Beginner",
+ "best_for": ["Blog Posts", "Sales Pages", "Email"],
+ "tags": ["persuasive", "agreement", "preview"]
+ },
+ "star_copywriter": {
+ "name": "STAR Copywriter",
+ "icon": "⭐",
+ "description": "Use the STAR (Situation, Task, Action, Result) framework to tell compelling stories.",
+ "color": "#FFD166",
+ "difficulty": "Intermediate",
+ "best_for": ["Case Studies", "Testimonials", "About Pages"],
+ "tags": ["storytelling", "results", "case-study"]
+ },
+ "oath_copywriter": {
+ "name": "OATH Copywriter",
+ "icon": "📜",
+ "description": "Apply the OATH (Oblivious, Apathetic, Thinking, Hurting) framework to target specific audience mindsets.",
+ "color": "#06D6A0",
+ "difficulty": "Advanced",
+ "best_for": ["Ads", "Landing Pages", "Email Sequences"],
+ "tags": ["audience", "mindset", "targeting"]
+ },
+ "quest_copywriter": {
+ "name": "QUEST Copywriter",
+ "icon": "🔍",
+ "description": "Use the QUEST (Question, Unpack, Emphasize, Solution, Transform) framework for narrative-driven copy.",
+ "color": "#118AB2",
+ "difficulty": "Intermediate",
+ "best_for": ["Long-form Content", "Sales Pages", "Video Scripts"],
+ "tags": ["narrative", "transformation", "solution"]
+ },
+ "aidppc_copywriter": {
+ "name": "AIDPPC Copywriter",
+ "icon": "💰",
+ "description": "Implement the AIDPPC (Attention, Interest, Desire, Proof, Persuasion, Call to Action) framework for PPC ads.",
+ "color": "#073B4C",
+ "difficulty": "Advanced",
+ "best_for": ["PPC Ads", "Social Ads", "Display Ads"],
+ "tags": ["advertising", "ppc", "conversion"]
+ },
+ "aida_copywriter": {
+ "name": "AIDA Copywriter",
+ "icon": "🎬",
+ "description": "Use the AIDA (Attention, Interest, Desire, Action) framework to guide customers through the sales funnel.",
+ "color": "#EF476F",
+ "difficulty": "Beginner",
+ "best_for": ["Sales Pages", "Email", "Product Descriptions"],
+ "tags": ["sales", "funnel", "conversion"]
+ },
+ "pas_copywriter": {
+ "name": "PAS Copywriter",
+ "icon": "🔧",
+ "description": "Apply the PAS (Problem, Agitate, Solution) formula to address pain points and offer solutions.",
+ "color": "#7209B7",
+ "difficulty": "Beginner",
+ "best_for": ["Ads", "Email", "Landing Pages"],
+ "tags": ["problem-solving", "pain-points", "solutions"]
+ },
+ "fab_copywriter": {
+ "name": "FAB Copywriter",
+ "icon": "💎",
+ "description": "Use the FAB (Features, Advantages, Benefits) framework to highlight product value.",
+ "color": "#3A0CA3",
+ "difficulty": "Beginner",
+ "best_for": ["Product Descriptions", "Sales Pages", "Brochures"],
+ "tags": ["product", "features", "benefits"]
+ },
+ "4c_copywriter": {
+ "name": "4C Copywriter",
+ "icon": "📝",
+ "description": "Implement the 4C (Clear, Concise, Credible, Compelling) framework for effective messaging.",
+ "color": "#4361EE",
+ "difficulty": "Intermediate",
+ "best_for": ["Brand Messaging", "Mission Statements", "Value Propositions"],
+ "tags": ["clarity", "concise", "credibility"]
+ },
+ "4r_copywriter": {
+ "name": "4R Copywriter",
+ "icon": "🔄",
+ "description": "Use the 4R (Relevance, Resonance, Response, Results) framework to connect with your audience.",
+ "color": "#F72585",
+ "difficulty": "Intermediate",
+ "best_for": ["Content Marketing", "Email", "Social Media"],
+ "tags": ["relevance", "resonance", "results"]
+ }
+}
+
+def load_user_preferences() -> Dict:
+ """Load user preferences from session state or initialize if not present."""
+ if "copywriter_preferences" not in st.session_state:
+ st.session_state.copywriter_preferences = {
+ "recent_formulas": [],
+ "favorite_formulas": [],
+ "comparison_formulas": [],
+ "view_mode": "grid" # or "list"
+ }
+ return st.session_state.copywriter_preferences
+
+def save_user_preferences(preferences: Dict) -> None:
+ """Save user preferences to session state."""
+ st.session_state.copywriter_preferences = preferences
+
+def add_recent_formula(module_name: str) -> None:
+ """Add a formula to the recent formulas list."""
+ preferences = load_user_preferences()
+
+ # Remove if already exists
+ if module_name in preferences["recent_formulas"]:
+ preferences["recent_formulas"].remove(module_name)
+
+ # Add to the beginning of the list
+ preferences["recent_formulas"].insert(0, module_name)
+
+ # Keep only the 5 most recent
+ preferences["recent_formulas"] = preferences["recent_formulas"][:5]
+
+ save_user_preferences(preferences)
+
+def toggle_favorite_formula(module_name: str) -> bool:
+ """Toggle a formula as favorite and return the new state."""
+ preferences = load_user_preferences()
+
+ if module_name in preferences["favorite_formulas"]:
+ preferences["favorite_formulas"].remove(module_name)
+ is_favorite = False
+ else:
+ preferences["favorite_formulas"].append(module_name)
+ is_favorite = True
+
+ save_user_preferences(preferences)
+ return is_favorite
+
+def is_favorite_formula(module_name: str) -> bool:
+ """Check if a formula is in the favorites list."""
+ preferences = load_user_preferences()
+ return module_name in preferences["favorite_formulas"]
+
+def add_to_comparison(module_name: str) -> None:
+ """Add a formula to the comparison list."""
+ preferences = load_user_preferences()
+
+ if module_name not in preferences["comparison_formulas"]:
+ preferences["comparison_formulas"].append(module_name)
+
+ # Keep only up to 3 formulas for comparison
+ preferences["comparison_formulas"] = preferences["comparison_formulas"][:3]
+
+ save_user_preferences(preferences)
+
+def remove_from_comparison(module_name: str) -> None:
+ """Remove a formula from the comparison list."""
+ preferences = load_user_preferences()
+
+ if module_name in preferences["comparison_formulas"]:
+ preferences["comparison_formulas"].remove(module_name)
+
+ save_user_preferences(preferences)
+
+def clear_comparison() -> None:
+ """Clear the comparison list."""
+ preferences = load_user_preferences()
+ preferences["comparison_formulas"] = []
+ save_user_preferences(preferences)
+
+def lazy_load_module(module_name: str) -> Optional[Callable]:
+ """Lazily load a module and return its input_section function."""
+ if module_name in input_sections:
+ return input_sections[module_name]
+
try:
module_path = f"lib.ai_writers.ai_copywriter.{module_name}"
module = importlib.import_module(module_path)
if hasattr(module, "input_section"):
input_sections[module_name] = module.input_section
+ return module.input_section
+ else:
+ st.warning(f"Module {module_name} does not have an input_section function.")
+ return None
except Exception as e:
- st.write(f"Debug: Error importing {module_name}: {str(e)}")
+ st.error(f"Error loading module {module_name}: {str(e)}")
+ return None
+
+def render_formula_card(module_name: str, index: int, view_mode: str = "grid") -> None:
+ """Render a formula card with its details."""
+ metadata = formula_metadata.get(module_name, {})
+
+ if not metadata:
+ return
+
+ is_favorite = is_favorite_formula(module_name)
+ favorite_icon = "★" if is_favorite else "☆"
+ favorite_tooltip = "Remove from favorites" if is_favorite else "Add to favorites"
+
+ if view_mode == "grid":
+ with st.container():
+ st.markdown(f"""
+
+
{favorite_icon}
+
{metadata["icon"]} {metadata["name"]}
+
{metadata["description"]}
+
+
+ {metadata["difficulty"]}
+
+
+
+
{metadata["icon"]} {metadata["name"]} {favorite_icon}
+
{metadata["description"]}
+
+
+ {metadata["difficulty"]}
+
+ Best for: {", ".join(metadata["best_for"][:2])}
+
+
-
{formula["icon"]} {formula["name"]}
-
{formula["description"]}
-