app.py

import gradio as gr
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
import nltk
from datetime import datetime, timedelta
import requests
from bs4 import BeautifulSoup

# Download required NLTK data
try:
    nltk.data.find('tokenizers/punkt')
except LookupError:
    nltk.download('punkt')

# Global variables to cache models
CACHED_MODELS = {}

# Initialize models and tokenizers
def load_models():
    global CACHED_MODELS
    
    if CACHED_MODELS:
        return (
            CACHED_MODELS['generator_tokenizer'],
            CACHED_MODELS['generator'],
            CACHED_MODELS['sentiment_analyzer'],
            CACHED_MODELS['content_checker']
        )
    
    try:
        # Use GPT-2 instead of DistilGPT-2
        generator_model = "gpt2"
        generator_tokenizer = AutoTokenizer.from_pretrained(generator_model)
        generator = AutoModelForCausalLM.from_pretrained(generator_model)
        
        # Sentiment analysis
        sentiment_analyzer = pipeline(
            "sentiment-analysis",
            model="finiteautomata/bertweet-base-sentiment-analysis"
        )
        
        # Content safety checker
        content_checker = pipeline(
            "text-classification",
            model="facebook/roberta-hate-speech-dynabench-r4-target"
        )
        
        # Cache the models
        CACHED_MODELS['generator_tokenizer'] = generator_tokenizer
        CACHED_MODELS['generator'] = generator
        CACHED_MODELS['sentiment_analyzer'] = sentiment_analyzer
        CACHED_MODELS['content_checker'] = content_checker
        
        return generator_tokenizer, generator, sentiment_analyzer, content_checker
    except Exception as e:
        print(f"Error loading models: {str(e)}")
        raise

def generate_content(
    product_name,
    product_description,
    target_audience,
    key_features,
    unique_benefits,
    platform,
    tone,
    generator_tokenizer,
    generator,
    sentiment_analyzer,
    content_checker
):
    char_limit = 280 if platform == "Twitter" else 500
    
    # Split features and benefits into lists
    features = [f.strip() for f in key_features.split(',')]
    benefits = [b.strip() for b in unique_benefits.split(',')]
    
    # Expanded intro phrases for each tone
    intro_phrases = {
        'professional': [
            f"Introducing {product_name}:",
            f"Discover {product_name}:",
            f"Meet {product_name}:",
            f"Presenting {product_name}:",
            f"Announcing {product_name}:",
            f"Experience {product_name}:",
            f"Elevate your life with {product_name}:",
        ],
        'casual': [
            f"Check out {product_name}!",
            f"Say hello to {product_name}!",
            f"Get ready for {product_name}!",
            f"You'll love {product_name}!",
            f"Looking for something special? Try {product_name}!",
            f"Meet your new favorite: {product_name}!",
            f"Game-changer alert: {product_name} is here!",
        ],
        'friendly': [
            f"We're excited to share {product_name} with you!",
            f"You'll love what {product_name} can do!",
            f"Let {product_name} transform your day!",
            f"Ready to discover {product_name}?",
            f"Here's why you'll love {product_name}:",
            f"Make every day better with {product_name}!",
            f"Transform your experience with {product_name}!",
        ]
    }

    # Description connectors
    description_connectors = [
        f" - {product_description}",
        f": {product_description}",
        f"! {product_description}",
        f", {product_description}",
        f". {product_description}",
    ]

    # Feature introduction phrases
    feature_intros = [
        "Featuring",
        "With",
        "Including",
        "Equipped with",
        "Powered by",
        "Designed with",
        "Built with",
        "Offering",
    ]

    # Benefit connectors
    benefit_connectors = [
        "Experience",
        "Enjoy",
        "Benefit from",
        "Take advantage of",
        "Discover",
        "Appreciate",
        "Make the most of",
    ]

    # Target audience phrases
    audience_phrases = [
        f"Perfect for {target_audience}",
        f"Ideal for {target_audience}",
        f"Designed for {target_audience}",
        f"Made specially for {target_audience}",
        f"Tailored for {target_audience}",
        f"Created with {target_audience} in mind",
    ]

    # Call-to-action phrases
    cta_phrases = {
        'Twitter': [
            "Learn more today!",
            "Discover more →",
            "Get yours now!",
            "Visit our website!",
            "Join us today!",
            "Transform your life today!",
            "Start your journey!",
        ],
        'Instagram': [
            f"\n\n#{product_name.replace(' ', '')}",
            f"\n\nLearn more - Link in bio! #{product_name.replace(' ', '')}",
            f"\n\nDiscover more ↗️ #{product_name.replace(' ', '')}",
            f"\n\nTap link to learn more! #{product_name.replace(' ', '')}",
        ]
    }

    import random

    def create_post():
        # Select tone
        selected_tone = tone.lower() if tone.lower() in intro_phrases else 'professional'
        
        # Random structure selection (1-4)
        structure = random.randint(1, 4)
        
        if structure == 1:
            # Standard structure
            post = random.choice(intro_phrases[selected_tone])
            post += random.choice(description_connectors)
            feature = random.choice(features)
            benefit = random.choice(benefits)
            
            if len(post) + len(feature) + len(benefit) + 20 < char_limit:
                post += f" {random.choice(feature_intros)} {feature}."
                post += f" {random.choice(benefit_connectors)} {benefit}."
                
        elif structure == 2:
            # Benefit-first structure
            benefit = random.choice(benefits)
            post = f"Ready to {benefit.lower()}? "
            post += random.choice(intro_phrases[selected_tone])
            post += random.choice(description_connectors)
            
            if len(post) + 30 < char_limit:
                feature = random.choice(features)
                post += f" {random.choice(feature_intros)} {feature}."
                
        elif structure == 3:
            # Question-based structure
            post = f"Looking for {product_description.lower()}? "
            post += random.choice(intro_phrases[selected_tone]).replace(':', '!')
            feature = random.choice(features)
            benefit = random.choice(benefits)
            
            if len(post) + len(feature) + len(benefit) + 20 < char_limit:
                post += f" {random.choice(feature_intros)} {feature}."
                post += f" {benefit}."
                
        else:
            # Feature-focused structure
            feature = random.choice(features)
            post = f"From {feature} to {random.choice(benefits).lower()}, "
            post += f"{product_name} has it all! "
            post += product_description

        # Add target audience if space allows
        if len(post) + 50 < char_limit:
            post += f" {random.choice(audience_phrases)}."

        # Add call to action
        if platform == "Twitter":
            if len(post) + 30 < char_limit:
                post += f" {random.choice(cta_phrases['Twitter'])}"
        else:
            if len(post) + 50 < char_limit:
                post += random.choice(cta_phrases['Instagram'])

        return post.strip()

    try:
        # Generate multiple versions
        posts = [create_post() for _ in range(2)]
        filtered_content = []
        
        for post in posts:
            # Verify length
            if len(post) > char_limit:
                post = post[:char_limit-3] + "..."
            
            # Check sentiment and safety
            try:
                sentiment = sentiment_analyzer(post)[0]
                safety_check = content_checker(post)[0]
                
                filtered_content.append({
                    'text': post,
                    'sentiment': sentiment['label'],
                    'safety_score': f"{float(safety_check.get('score', 0)):.2f}"
                })
            except Exception as e:
                print(f"Error in content analysis: {str(e)}")
                continue
        
        return filtered_content if filtered_content else [{
            'text': create_post(),
            'sentiment': 'positive',
            'safety_score': '1.00'
        }]
    
    except Exception as e:
        print(f"Error in content generation: {str(e)}")
        return [{
            'text': f"Introducing {product_name}: {product_description[:100]}... Learn more!",
            'sentiment': 'neutral',
            'safety_score': '1.00'
        }]

def create_interface():
    print("Loading models...")
    generator_tokenizer, generator, sentiment_analyzer, content_checker = load_models()
    print("Models loaded successfully!")
    
    # Sample data function
    def fill_sample_data():
        return [
            "EcoBottle",  # Product Name
            "Sustainable water bottle made from recycled ocean plastic",  # Product Description
            "Environmentally conscious young professionals",  # Target Audience
            "100% recycled materials, Insulated design, Leak-proof",  # Key Features
            "Helps clean oceans, Keeps drinks cold for 24 hours",  # Unique Benefits
            "Twitter",  # Platform
            "professional"  # Tone
        ]
    
    def process_input(
        product_name,
        product_description,
        target_audience,
        key_features,
        unique_benefits,
        platform,
        tone
    ):
        try:
            results = generate_content(
                product_name,
                product_description,
                target_audience,
                key_features,
                unique_benefits,
                platform,
                tone,
                generator_tokenizer,
                generator,
                sentiment_analyzer,
                content_checker
            )
            
            output = "🎯 Generated Marketing Content:\n\n"
            for i, content in enumerate(results, 1):
                output += f"Version {i}:\n"
                output += f"📝 Content: {content['text']}\n"
                output += f"😊 Sentiment: {content['sentiment']}\n"
                output += f"✅ Safety Score: {content['safety_score']}\n"
                output += "-" * 50 + "\n"
            
            return output
        except Exception as e:
            return f"An error occurred: {str(e)}"

    # Create input components
    with gr.Blocks() as demo:
        gr.Markdown("# Ethimar - AI Marketing Content Generator")
        gr.Markdown("Generate ethical marketing content with AI-powered insights.\n⏳ Note: First generation might take 3-5 minutes due to model loading. Subsequent generations will be faster!")
        
        with gr.Row():
            fill_button = gr.Button(
                "Fill the form with sample data",
                variant="primary",
                scale=1,
                size="sm"
            )

        with gr.Column():
            product_name = gr.Textbox(label="Product Name", placeholder="Enter product name")
            product_description = gr.Textbox(label="Product Description", lines=3, placeholder="Brief description of your product")
            target_audience = gr.Textbox(label="Target Audience", placeholder="Who is this product for?")
            key_features = gr.Textbox(label="Key Features", lines=2, placeholder="Main features of your product")
            unique_benefits = gr.Textbox(label="Unique Benefits", lines=2, placeholder="What makes your product special?")
            platform = gr.Radio(
                choices=["Twitter", "Instagram"],
                label="Platform",
                value="Twitter"
            )
            tone = gr.Textbox(label="Tone", placeholder="e.g., professional, casual, friendly")
            
            submit_button = gr.Button("Generate Content", variant="primary")
            output = gr.Textbox(label="Generated Content", lines=10)

        # Connect the buttons to functions
        fill_button.click(
            fn=fill_sample_data,
            outputs=[
                product_name,
                product_description,
                target_audience,
                key_features,
                unique_benefits,
                platform,
                tone
            ]
        )
        
        submit_button.click(
            fn=process_input,
            inputs=[
                product_name,
                product_description,
                target_audience,
                key_features,
                unique_benefits,
                platform,
                tone
            ],
            outputs=output
        )
        
        # Add examples
        gr.Examples(
            examples=[
                [
                    "EcoBottle",
                    "Sustainable water bottle made from recycled ocean plastic",
                    "Environmentally conscious young professionals",
                    "100% recycled materials, Insulated design, Leak-proof",
                    "Helps clean oceans, Keeps drinks cold for 24 hours",
                    "Twitter",
                    "professional"
                ]
            ],
            inputs=[
                product_name,
                product_description,
                target_audience,
                key_features,
                unique_benefits,
                platform,
                tone
            ]
        )

    return demo

# Launch the app
if __name__ == "__main__":
    demo = create_interface()
    demo.launch()