first run

app.py

@@ -0,0 +1,197 @@
+import gradio as gr
+import torch
+from transformers import (
+    AutoTokenizer, 
+    AutoModelForSequenceClassification,
+    pipeline
+)
+import os
+from pdf_generator import ReportGenerator
+from news_checker import NewsChecker
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Initialize models and tokenizers
+def load_models():
+    # Hate speech detection model
+    hate_tokenizer = AutoTokenizer.from_pretrained("facebook/roberta-hate-speech-dynabench-r4-target")
+    hate_model = AutoModelForSequenceClassification.from_pretrained("facebook/roberta-hate-speech-dynabench-r4-target")
+    
+    # Bias detection (using same model with different labels)
+    bias_tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")
+    bias_model = AutoModelForSequenceClassification.from_pretrained("distilbert-base-uncased")
+    
+    return {
+        'hate_speech': (hate_model, hate_tokenizer),
+        'bias': (bias_model, bias_tokenizer)
+    }
+
+# Initialize news checker
+news_checker = NewsChecker()
+
+def check_text_length(text):
+    if len(text) > 1000:
+        return {
+            'status': 'fail',
+            'message': 'Text exceeds 1000 character limit'
+        }
+    return {
+        'status': 'pass',
+        'message': 'Text length is within limits'
+    }
+
+def check_hate_speech(text, model, tokenizer):
+    try:
+        inputs = tokenizer(text, return_tensors="pt", truncation=True, max_length=512)
+        outputs = model(**inputs)
+        predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
+        
+        # Threshold for hate speech detection
+        if predictions[0][1].item() > 0.3:  # Adjusted threshold
+            return {
+                'status': 'fail',
+                'message': 'Potential hate speech detected'
+            }
+        elif predictions[0][1].item() > 0.1:
+            return {
+                'status': 'warning',
+                'message': 'Some concerning language detected - please review'
+            }
+        return {
+            'status': 'pass',
+            'message': 'No hate speech detected'
+        }
+    except Exception as e:
+        return {
+            'status': 'error',
+            'message': f'Error in hate speech detection: {str(e)}'
+        }
+
+def check_grammar(text):
+    try:
+        nlp = pipeline("text2text-generation", model="gramformer/gramformer", device=0 if torch.cuda.is_available() else -1)
+        corrected = nlp(text, max_length=1000)[0]['generated_text']
+        
+        if corrected.lower() != text.lower():
+            return {
+                'status': 'warning',
+                'message': f'Suggested corrections:\n{corrected}'
+            }
+        return {
+            'status': 'pass',
+            'message': 'No grammar issues detected'
+        }
+    except Exception as e:
+        return {
+            'status': 'error',
+            'message': f'Error in grammar check: {str(e)}'
+        }
+
+def analyze_content(text):
+    # Initialize report generator
+    report_gen = ReportGenerator()
+    report_gen.add_header()
+    report_gen.add_input_text(text)
+    
+    # Load models
+    models = load_models()
+    
+    # Run all checks
+    results = {}
+    
+    # 1. Length Check
+    length_result = check_text_length(text)
+    results['Length Check'] = length_result
+    report_gen.add_check_result("Length Check", length_result['status'], length_result['message'])
+    
+    if length_result['status'] == 'fail':
+        report_path = report_gen.save_report()
+        return results, report_path
+    
+    # 2. Hate Speech Check
+    hate_result = check_hate_speech(text, models['hate_speech'][0], models['hate_speech'][1])
+    results['Hate Speech Check'] = hate_result
+    report_gen.add_check_result("Hate Speech Check", hate_result['status'], hate_result['message'])
+    
+    # 3. Grammar Check
+    grammar_result = check_grammar(text)
+    results['Grammar Check'] = grammar_result
+    report_gen.add_check_result("Grammar Check", grammar_result['status'], grammar_result['message'])
+    
+    # 4. News Context Check
+    news_result = news_checker.check_content_against_news(text)
+    results['Current Events Context'] = news_result
+    report_gen.add_check_result("Current Events Context", news_result['status'], news_result['message'])
+    
+    # Generate and save report
+    report_path = report_gen.save_report()
+    
+    return results, report_path
+
+def format_results(results):
+    status_symbols = {
+        'pass': '✅',
+        'fail': '❌',
+        'warning': '⚠️',
+        'error': '⚠️'
+    }
+    
+    formatted_output = ""
+    for check, result in results.items():
+        symbol = status_symbols.get(result['status'], '❓')
+        formatted_output += f"{check}: {symbol}\n"
+        if result['message']:
+            formatted_output += f"Details: {result['message']}\n\n"
+    
+    return formatted_output
+
+# Gradio Interface
+def create_interface():
+    with gr.Blocks(title="Marketing Content Validator") as interface:
+        gr.Markdown("# Marketing Content Validator")
+        gr.Markdown("Paste your marketing content below to check for potential issues.")
+        
+        with gr.Row():
+            with gr.Column():
+                input_text = gr.TextArea(
+                    label="Marketing Content",
+                    placeholder="Enter your marketing content here (max 1000 characters)...",
+                    lines=10
+                )
+                analyze_btn = gr.Button("Analyze Content")
+            
+            with gr.Column():
+                output_text = gr.TextArea(
+                    label="Analysis Results",
+                    lines=10,
+                    interactive=False
+                )
+                report_output = gr.File(label="Download Report")
+        
+        analyze_btn.click(
+            fn=lambda text: (
+                format_results(analyze_content(text)[0]),
+                analyze_content(text)[1]
+            ),
+            inputs=input_text,
+            outputs=[output_text, report_output]
+        )
+        
+        gr.Markdown("""
+        ### Notes:
+        - Maximum text length: 1000 characters
+        - Analysis may take up to 2 minutes
+        - Results include checks for:
+          - Text length
+          - Hate speech and bias
+          - Grammar
+          - Current events context
+        """)
+    
+    return interface
+
+# Launch the application
+if __name__ == "__main__":
+    interface = create_interface()
+    interface.launch()

news-checker.py

@@ -0,0 +1,73 @@
+import os
+from newsapi import NewsApiClient
+from dotenv import load_dotenv
+import pandas as pd
+from datetime import datetime, timedelta
+
+load_dotenv()
+
+class NewsChecker:
+    def __init__(self):
+        self.api_key = os.getenv('NEWS_API_KEY')
+        self.newsapi = NewsApiClient(api_key=self.api_key)
+        
+    def get_recent_news(self):
+        try:
+            # Get news from the last 7 days
+            week_ago = (datetime.now() - timedelta(days=7)).strftime('%Y-%m-%d')
+            response = self.newsapi.get_everything(
+                q='',
+                from_param=week_ago,
+                language='en',
+                sort_by='relevancy',
+                page_size=100
+            )
+            
+            if response['status'] == 'ok':
+                articles = response['articles']
+                # Extract titles and descriptions
+                news_data = [
+                    {
+                        'title': article['title'],
+                        'description': article['description']
+                    }
+                    for article in articles if article['description']
+                ]
+                return pd.DataFrame(news_data)
+            return pd.DataFrame()
+            
+        except Exception as e:
+            print(f"Error fetching news: {str(e)}")
+            return pd.DataFrame()
+    
+    def check_content_against_news(self, marketing_text):
+        news_df = self.get_recent_news()
+        if news_df.empty:
+            return {
+                'status': 'warning',
+                'message': 'Unable to check against current news context. Proceed with caution.'
+            }
+            
+        # Simple keyword matching for demo purposes
+        # In a production environment, you'd want to use more sophisticated NLP techniques
+        marketing_words = set(marketing_text.lower().split())
+        potential_conflicts = []
+        
+        for _, row in news_df.iterrows():
+            title_words = set(row['title'].lower().split())
+            desc_words = set(str(row['description']).lower().split())
+            
+            # Check for significant word overlap
+            if len(marketing_words.intersection(title_words)) >= 3:
+                potential_conflicts.append(row['title'])
+                
+        if potential_conflicts:
+            return {
+                'status': 'warning',
+                'message': 'Potential conflicts found with current news:\n- ' + '\n- '.join(potential_conflicts)
+            }
+            
+        return {
+            'status': 'pass',
+            'message': 'No significant conflicts with current news found.'
+        }

pdf_generator.py

@@ -0,0 +1,44 @@
+from fpdf import FPDF
+from datetime import datetime
+
+class ReportGenerator:
+    def __init__(self):
+        self.pdf = FPDF()
+        self.pdf.add_page()
+        self.pdf.set_font("Arial", size=12)
+        
+    def add_header(self):
+        self.pdf.set_font("Arial", "B", 16)
+        self.pdf.cell(200, 10, txt="Marketing Content Validation Report", ln=True, align='C')
+        self.pdf.set_font("Arial", size=10)
+        self.pdf.cell(200, 10, txt=f"Generated on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}", ln=True, align='R')
+        self.pdf.ln(10)
+        
+    def add_input_text(self, text):
+        self.pdf.set_font("Arial", "B", 12)
+        self.pdf.cell(200, 10, txt="Input Marketing Content:", ln=True)
+        self.pdf.set_font("Arial", size=12)
+        self.pdf.multi_cell(0, 10, txt=text)
+        self.pdf.ln(10)
+        
+    def add_check_result(self, check_name, status, details=None):
+        status_symbols = {
+            "pass": "✓",
+            "fail": "✗",
+            "warning": "!"
+        }
+        
+        self.pdf.set_font("Arial", "B", 12)
+        status_symbol = status_symbols.get(status.lower(), "?")
+        self.pdf.cell(0, 10, txt=f"{check_name}: {status_symbol}", ln=True)
+        
+        if details:
+            self.pdf.set_font("Arial", size=10)
+            self.pdf.multi_cell(0, 10, txt=details)
+        self.pdf.ln(5)
+        
+    def save_report(self):
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"marketing_report_{timestamp}.pdf"
+        self.pdf.output(filename)
+        return filename

requirements.txt

@@ -0,0 +1,9 @@
+gradio==4.19.2
+transformers==4.36.2
+torch==2.2.0
+newsapi-python==0.2.7
+fpdf2==2.7.8
+pandas==2.1.4
+numpy==1.24.3
+requests==2.31.0
+python-dotenv==1.0.0