Update app.py

app.py

@@ -1,145 +1,115 @@
 import gradio as gr
-import language_tool_python
-import nltk
 from transformers import pipeline
 from newspaper import Article
+import nltk
 from nltk.tokenize import sent_tokenize
 import re
 
+# Download punkt tokenizer
 nltk.download("punkt")
 
-# Correct way to connect to the locally running LanguageTool server
-grammar_tool = language_tool_python.LanguageTool(
-    language='en-US',
-    remote_server='http://localhost:8081/v2/'
-)
-
-
-# Hugging Face pipelines
-toxicity_classifier = pipeline("text-classification", model="unitary/toxic-bert")
-summarizer = pipeline("summarization", model="sshleifer/distilbart-cnn-6-6")
+# Load Hugging Face pipelines
+grammar_corrector = pipeline("text2text-generation", model="pszemraj/flan-t5-base-grammar-synthesis")
+toxicity_detector = pipeline("text-classification", model="unitary/toxic-bert")
 
+# Utility: extract blog text from URL
 def extract_text(input_type, text_input, url_input):
-    if input_type == "URL" and url_input:
-        article = Article(url_input)
-        article.download()
-        article.parse()
-        return article.text
-    return text_input
-
-def check_grammar(text):
-    matches = grammar_tool.check(text)
-    return [
-        {
-            "text": match.context,
-            "error": match.message,
-            "suggestions": match.replacements,
-            "offset": match.offset,
-            "length": match.errorLength
-        } for match in matches
-    ]
-
-def detect_sensitive_content(text):
-    sentences = sent_tokenize(text)
-    sensitive_issues = []
-    for i, sentence in enumerate(sentences):
-        result = toxicity_classifier(sentence)
-        if result[0]['label'] == 'toxic' and result[0]['score'] > 0.7:
-            sensitive_issues.append({
-                "sentence": sentence,
-                "score": result[0]['score'],
-                "index": i
-            })
-    return sensitive_issues
-
-def generate_suggestions(text, grammar_issues, sensitive_issues):
-    suggestions = []
-    for issue in grammar_issues:
-        if issue['suggestions']:
-            suggestions.append(f"Replace '{issue['text']}' with '{issue['suggestions'][0]}' ({issue['error']})")
-    for issue in sensitive_issues:
-        summary = summarizer(issue['sentence'], max_length=50, min_length=10, do_sample=False)[0]['summary_text']
-        suggestions.append(f"Rephrase sensitive content '{issue['sentence']}' to: '{summary}' (Toxicity score: {issue['score']:.2f})")
-    return suggestions
-
-def highlight_text(text, grammar_issues, sensitive_issues):
-    highlighted = text
-    offset_adjust = 0
-    for issue in grammar_issues:
-        start = issue['offset'] + offset_adjust
-        end = start + issue['length']
-        error_text = highlighted[start:end]
-        span = f"<span style='background-color: yellow'>{error_text}</span>"
-        highlighted = highlighted[:start] + span + highlighted[end:]
-        offset_adjust += len(span) - len(error_text)
-    for issue in sensitive_issues:
-        highlighted = highlighted.replace(
-            issue['sentence'],
-            f"<span style='background-color: red'>{issue['sentence']}</span>"
-        )
-    return highlighted
+    if input_type == "Text":
+        return text_input
+    elif input_type == "URL":
+        try:
+            article = Article(url_input)
+            article.download()
+            article.parse()
+            return article.text
+        except Exception as e:
+            return f"Error extracting article: {str(e)}"
+    return ""
+
+# Highlight grammar & sensitive content
+def highlight_text(text, grammar_sentences, toxic_sentences):
+    for s in grammar_sentences:
+        text = text.replace(s, f"<span style='background-color: yellow'>{s}</span>")
+    for s in toxic_sentences:
+        text = text.replace(s, f"<span style='background-color: red'>{s}</span>")
+    return text
 
+# Main blog review function
 def review_blog(input_type, text_input, url_input):
-    if not text_input and not url_input:
-        return "Please provide text or a URL.", "", []
     text = extract_text(input_type, text_input, url_input)
-    grammar_issues = check_grammar(text)
-    sensitive_issues = detect_sensitive_content(text)
-    suggestions = generate_suggestions(text, grammar_issues, sensitive_issues)
-    highlighted_text = highlight_text(text, grammar_issues, sensitive_issues)
-    suggestions_text = "\n".join([f"{i+1}. {s}" for i, s in enumerate(suggestions)])
-    return highlighted_text, suggestions_text, suggestions
-
-def apply_changes(text, suggestions, approved_indices):
+    if not text or text.startswith("Error"):
+        return text, "", []
+
     sentences = sent_tokenize(text)
-    for idx in approved_indices.split(','):
-        try:
-            idx = int(idx.strip()) - 1
-            if idx < len(suggestions):
-                suggestion = suggestions[idx]
-                match = re.search(r"'([^']+)'$", suggestion)
-                if match:
-                    new_text = match.group(1)
-                    if "Rephrase sensitive content" in suggestion:
-                        orig_match = re.search(r"'([^']+)'\s+to:", suggestion)
-                        if orig_match:
-                            orig_sentence = orig_match.group(1)
-                            text = text.replace(orig_sentence, new_text)
-                    else:
-                        orig_match = re.search(r"Replace '([^']+)' with '([^']+)'", suggestion)
-                        if orig_match:
-                            text = text.replace(orig_match.group(1), orig_match.group(2))
-        except ValueError:
-            continue
-    return text
+    grammar_issues = []
+    toxic_issues = []
+    suggestions = []
 
+    for sent in sentences:
+        # Check grammar by comparing original and corrected
+        corrected = grammar_corrector(sent, max_length=128, do_sample=False)[0]['generated_text']
+        if corrected.strip() != sent.strip():
+            grammar_issues.append(sent)
+            suggestions.append(f"Grammar: Replace '{sent}' → '{corrected}'")
+
+        # Check for toxicity
+        result = toxicity_detector(sent)
+        if result[0]['label'] == 'toxic' and result[0]['score'] > 0.7:
+            toxic_issues.append(sent)
+            suggestions.append(f"Toxicity: Rephrase '{sent}' (score: {result[0]['score']:.2f})")
+
+    highlighted = highlight_text(text, grammar_issues, toxic_issues)
+    sug_text = "\n".join(f"{i+1}. {s}" for i, s in enumerate(suggestions))
+    return highlighted, sug_text, suggestions
+
+# Apply approved suggestions
+def apply_changes(original_text, suggestions, indices):
+    try:
+        indices = [int(i.strip()) - 1 for i in indices.split(",") if i.strip().isdigit()]
+        sentences = sent_tokenize(original_text)
+        for i in indices:
+            if i < len(suggestions):
+                match = re.search(r"'(.*?)'\s*→\s*'(.*?)'", suggestions[i])
+                if match:
+                    old = match.group(1)
+                    new = match.group(2)
+                    original_text = original_text.replace(old, new)
+        return original_text
+    except Exception as e:
+        return f"Error applying changes: {str(e)}"
+
+# Gradio UI
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# ✨ AI Blog Reviewer")
-    gr.Markdown("Highlight grammar & sensitive issues. Rephrase toxic content. Approve and apply changes.")
+    gr.Markdown("## ✨ Blog Content Reviewer (LLM-powered)")
+    gr.Markdown("Paste blog content or a blog URL. AI will detect grammar issues & sensitive content.")
 
-    input_type = gr.Radio(["Text", "URL"], label="Input Type", value="Text")
+    input_type = gr.Radio(["Text", "URL"], value="Text", label="Input Type")
     text_input = gr.Textbox(label="Blog Text", lines=10, visible=True)
     url_input = gr.Textbox(label="Blog URL", visible=False)
 
-    def toggle_input(type):
-        return {
-            text_input: gr.update(visible=type == "Text"),
-            url_input: gr.update(visible=type == "URL")
-        }
-
-    input_type.change(fn=toggle_input, inputs=input_type, outputs=[text_input, url_input])
+    input_type.change(lambda t: {text_input: gr.update(visible=t=="Text"),
+                                 url_input: gr.update(visible=t=="URL")},
+                      input_type, [text_input, url_input])
 
-    review_btn = gr.Button("Review Content")
-    highlighted = gr.HTML()
-    suggestions = gr.Textbox(label="Suggestions", lines=10)
-    approved = gr.Textbox(label="Approve Suggestions (e.g., 1,3)")
-    apply_btn = gr.Button("Apply Changes")
-    final = gr.Textbox(label="Final Text", lines=10)
+    review_button = gr.Button("Review")
+    highlighted_output = gr.HTML()
+    suggestions_output = gr.Textbox(label="Suggestions", lines=10)
+    approve_input = gr.Textbox(label="Approve Suggestions (e.g., 1,2)")
+    apply_button = gr.Button("Apply Changes")
+    final_text = gr.Textbox(label="Final Output", lines=10)
 
     suggestions_state = gr.State()
 
-    review_btn.click(fn=review_blog, inputs=[input_type, text_input, url_input],
-                     outputs=[highlighted, suggestions, suggestions_state])
-    apply_btn.click(fn=apply_changes, inputs=[text_input, suggestions_state, approved], outputs=final)
+    review_button.click(
+        fn=review_blog,
+        inputs=[input_type, text_input, url_input],
+        outputs=[highlighted_output, suggestions_output, suggestions_state]
+    )
+
+    apply_button.click(
+        fn=apply_changes,
+        inputs=[text_input, suggestions_state, approve_input],
+        outputs=[final_text]
+    )
 
 demo.launch()