Update app.py

app.py

@@ -1,229 +1,241 @@
 import torch
 import gradio as gr
 import speech_recognition as sr
-import time
 import difflib
+import json
 import os
 from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
-from happytransformer import HappyTextToText, TTSettings
 
-# Constants
 MODEL_NAME = "prithivida/grammar_error_correcter_v1"
-CSS = """
-.gradio-container { max-width: 1400px !important; }
-.header { text-align: center; padding: 2rem; background: linear-gradient(135deg, #3b82f6, #6366f1); color: white; border-radius: 15px; }
-#container { height: 500px; width: 100%; background: #1a1a1a; border-radius: 10px; }
-.diff-ins { color: #10b981; background: #d1fae5; padding: 2px 4px; border-radius: 4px; }
-.diff-del { color: #ef4444; background: #fee2e2; padding: 2px 4px; border-radius: 4px; }
-"""
-
-THREEJS_TEMPLATE = """
-<div id="container"></div>
-<script async src="https://unpkg.com/[email protected]/dist/es-module-shims.js"></script>
-<script type="importmap">
-{
-  "imports": {
-    "three": "https://unpkg.com/[email protected]/build/three.module.js",
-    "three/addons/": "https://unpkg.com/[email protected]/examples/jsm/"
-  }
-}
-</script>
+tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+model = AutoModelForSeq2SeqLM.from_pretrained(MODEL_NAME)
 
-<script type="module">
-import * as THREE from 'three';
-import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
-
-class GrammarVisualizer {
-  constructor() {
-    this.initScene();
-    this.addLights();
-    this.createGrammarSphere();
-    this.setupControls();
-    this.animate();
-  }
-
-  initScene() {
-    this.scene = new THREE.Scene();
-    this.camera = new THREE.PerspectiveCamera(75, 500/400, 0.1, 1000);
-    this.renderer = new THREE.WebGLRenderer({ antialias: true, alpha: true });
-    document.getElementById('container').appendChild(this.renderer.domElement);
-    this.renderer.setSize(500, 400);
-    this.camera.position.z = 5;
-  }
-
-  addLights() {
-    const ambient = new THREE.AmbientLight(0x404040);
-    const directional = new THREE.DirectionalLight(0xffffff, 1);
-    directional.position.set(5, 5, 5);
-    this.scene.add(ambient, directional);
-  }
-
-  createGrammarSphere() {
-    const geometry = new THREE.SphereGeometry(2, 32, 32);
-    this.material = new THREE.MeshPhongMaterial({ 
-      color: 0x3b82f6,
-      transparent: true,
-      opacity: 0.9
+D3_TEMPLATE = """
+<div id="d3-dashboard">
+  <svg id="main-chart"></svg>
+  <div id="text-vis" class="text-visualization"></div>
+</div>
+<script src="https://d3js.org/d3.v7.min.js"></script>
+<script>
+const container = d3.select("#d3-dashboard");
+const width = 800;
+const height = 500;
+const margin = {top: 20, right: 30, bottom: 30, left: 40};
+
+const svg = container.select("#main-chart")
+  .attr("width", width)
+  .attr("height", height)
+  .style("background", "#f8fafc")
+  .style("border-radius", "12px");
+
+const textVis = container.select("#text-vis")
+  .style("margin-top", "20px")
+  .style("min-height", "100px")
+  .style("padding", "20px")
+  .style("background", "white")
+  .style("border-radius", "12px")
+  .style("box-shadow", "0 2px 4px rgba(0,0,0,0.1)");
+
+function updateDashboard(data) {
+  // Clear previous elements
+  svg.selectAll("*").remove();
+  textVis.html("");
+
+  // Score Arc
+  const arc = d3.arc()
+    .innerRadius(80)
+    .outerRadius(120)
+    .startAngle(0)
+    .endAngle((Math.PI * 2 * data.score) / 100);
+
+  svg.append("path")
+    .attr("transform", `translate(${width/2},${height/3})`)
+    .attr("d", arc)
+    .attr("fill", "#3b82f6")
+    .transition()
+    .duration(1000)
+    .attrTween("d", function(d) {
+      const interpolate = d3.interpolate(0, data.score/100);
+      return function(t) {
+        arc.endAngle(Math.PI * 2 * interpolate(t));
+        return arc();
+      };
     });
-    this.sphere = new THREE.Mesh(geometry, this.material);
-    this.scene.add(this.sphere);
-  }
-
-  setupControls() {
-    this.controls = new OrbitControls(this.camera, this.renderer.domElement);
-    this.controls.enableDamping = true;
-    this.controls.dampingFactor = 0.05;
-  }
-
-  animate() {
-    requestAnimationFrame(() => this.animate());
-    this.controls.update();
-    this.renderer.render(this.scene, this.camera);
-  }
-
-  updateVisuals(score) {
-    const hue = score / 100;
-    this.material.color.setHSL(hue, 0.8, 0.5);
-    this.sphere.rotation.x = (score / 50) * Math.PI;
-    this.sphere.rotation.y = (score / 75) * Math.PI;
-  }
-}
-
-let visualizer;
-window.addEventListener('DOMContentLoaded', () => {
-  visualizer = new GrammarVisualizer();
-});
 
-window.updateGrammarVisuals = (score) => {
-  if(visualizer) visualizer.updateVisuals(score);
-};
+  // Error Distribution
+  const errorTypes = data.errors;
+  const x = d3.scaleBand()
+    .domain(errorTypes.map(d => d.type))
+    .range([margin.left, width - margin.right])
+    .padding(0.2);
+
+  const y = d3.scaleLinear()
+    .domain([0, d3.max(errorTypes, d => d.count)])
+    .range([height/2 - margin.bottom, margin.top]);
+
+  svg.selectAll(".error-bar")
+    .data(errorTypes)
+    .enter().append("rect")
+      .attr("class", "error-bar")
+      .attr("x", d => x(d.type))
+      .attr("y", d => y(d.count))
+      .attr("width", x.bandwidth())
+      .attr("height", d => height/2 - margin.bottom - y(d.count))
+      .attr("fill", "#ef4444")
+      .attr("rx", 4)
+      .on("mouseover", function(event, d) {
+        d3.select(this).attr("fill", "#dc2626");
+      })
+      .on("mouseout", function(event, d) {
+        d3.select(this).attr("fill", "#ef4444");
+      });
+
+  // Interactive Text Visualization
+  const textBox = textVis.selectAll(".word")
+    .data(data.corrections)
+    .enter().append("div")
+      .attr("class", "word")
+      .style("display", "inline-block")
+      .style("margin", "2px")
+      .style("padding", "4px 8px")
+      .style("border-radius", "4px")
+      .style("background", d => d.correct ? "#d1fae5" : "#fee2e2")
+      .style("color", d => d.correct ? "#065f46" : "#991b1b")
+      .style("cursor", "pointer")
+      .on("mouseover", function(event, d) {
+        d3.select(this).style("filter", "brightness(90%)");
+      })
+      .on("mouseout", function(event, d) {
+        d3.select(this).style("filter", "brightness(100%)");
+      })
+      .html(d => d.original);
+
+  textBox.append("div")
+    .attr("class", "tooltip")
+    .style("position", "absolute")
+    .style("background", "white")
+    .style("padding", "8px")
+    .style("border-radius", "6px")
+    .style("box-shadow", "0 2px 8px rgba(0,0,0,0.1)")
+    .html(d => `
+      <strong>${d.type}</strong><br>
+      ${d.message}<br>
+      <em>Suggested:</em> ${d.suggestion}
+    `);
+}
 </script>
 """
-# Load models
-tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
-model = AutoModelForSeq2SeqLM.from_pretrained(MODEL_NAME)
-happy_tt = HappyTextToText("T5", MODEL_NAME)
-
-def create_diff_html(original, corrected):
-    d = difflib.Differ()
-    diff = d.compare(original.split(), corrected.split())    
-    return " ".join([
-        f'<span class="diff-ins">{p[2:]}</span> ' if p.startswith('+ ') else
-        f'<span class="diff-del">{p[2:]}</span> ' if p.startswith('- ') else
-        f'{p[2:]} ' for p in diff
-    ])
-
-def analyze_grammar(text):
-    inputs = tokenizer.encode("gec: " + text, return_tensors="pt", max_length=256, truncation=True)
-    with torch.no_grad():
-        outputs = model.generate(inputs, max_length=256, num_beams=5)
-    correction = tokenizer.decode(outputs[0], skip_special_tokens=True)
-    
-    args = TTSettings(num_beams=5, min_length=1)
-    happy_correction = happy_tt.generate_text("gec: " + text, args=args).text
-    
-    final_correction = happy_correction if len(happy_correction) > len(correction) else correction
-    changes = sum(1 for a, b in zip(text.split(), final_correction.split()) if a != b)
-    score = max(0, 100 - (changes * 2))
-    
-    return {
-        "original": text,
-        "corrected": final_correction,
-        "score": score,
-        "diff_html": create_diff_html(text, final_correction)
-    }
+
+def analyze_errors(original, corrected):
+    diff = difflib.SequenceMatcher(None, original.split(), corrected.split())
+    errors = []
+    for tag, i1, i2, j1, j2 in diff.get_opcodes():
+        if tag != 'equal':
+            error = {
+                'type': 'Grammar' if tag == 'replace' else 'Structure',
+                'original': ' '.join(original.split()[i1:i2]),
+                'suggestion': ' '.join(corrected.split()[j1:j2]),
+                'message': 'Improvement suggested' if tag == 'replace' else 'Structural change'
+            }
+            errors.append(error)
+    return errors
 
 def process_input(audio_path, text):
-    # Handle audio input
-    if audio_path and os.path.exists(audio_path):
-        try:
+    try:
+        # Handle audio input
+        if audio_path and os.path.exists(audio_path):
             recognizer = sr.Recognizer()
             with sr.AudioFile(audio_path) as source:
                 audio = recognizer.record(source)
             text = recognizer.recognize_google(audio)
-        except Exception as e:
-            return [
-                "Audio processing error", 
-                0, 
-                f"<span style='color:red'>Error: {str(e)}</span>",
-                "<script>window.updateGrammarVisuals(0)</script>"
-            ]
-    
-    # Handle text input
-    if not text.strip():
-        return ["No input provided", 0, "", "<script>window.updateGrammarVisuals(0)</script>"]
-    
-    try:
-        results = analyze_grammar(text)
-        return [
-            results['original'],
-            results['score'],
-            results['diff_html'],
-            f"<script>window.updateGrammarVisuals({results['score']})</script>"
-        ]
+
+        if not text.strip():
+            return {"error": "No input provided"}, ""
+            
+        # Grammar correction
+        inputs = tokenizer.encode("gec: " + text, return_tensors="pt", 
+                                max_length=256, truncation=True)
+        with torch.no_grad():
+            outputs = model.generate(inputs, max_length=256, num_beams=5)
+        corrected = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        
+        # Analysis
+        errors = analyze_errors(text, corrected)
+        score = max(0, 100 - len(errors)*5)
+        
+        # D3 data format
+        error_counts = {
+            "Grammar": sum(1 for e in errors if e['type'] == 'Grammar'),
+            "Structure": sum(1 for e in errors if e['type'] == 'Structure'),
+            "Spelling": 0  # Add spelling detection logic if available
+        }
+        
+        d3_data = {
+            "score": score,
+            "errors": [{"type": k, "count": v} for k, v in error_counts.items()],
+            "corrections": errors[:10]  # Show first 10 corrections
+        }
+        
+        return d3_data, corrected
+        
     except Exception as e:
-        return [
-            "Analysis error", 
-            0, 
-            f"<span style='color:red'>Error: {str(e)}</span>",
-            "<script>window.updateGrammarVisuals(0)</script>"
-        ]
-
-with gr.Blocks(css=CSS) as app:
-    gr.Markdown("""
-    <div class="header">
-        <h1>🌍 3D Grammar Analyzer Pro</h1>
-        <p>Interactive AI-Powered Writing Assistant with 3D Visualization</p>
-    </div>
-    """)
+        return {"error": str(e)}, ""
+
+with gr.Blocks(css="""
+.gradio-container { max-width: 1400px!important; padding: 20px!important; }
+#d3-dashboard { background: white; padding: 20px; border-radius: 12px; }
+.text-visualization { font-family: monospace; font-size: 16px; }
+""") as app:
+
+    gr.Markdown("# ✨ AI Writing Analytics Suite")
     
     with gr.Row():
         with gr.Column(scale=1):
             gr.Markdown("### Input Section")
-            audio_input = gr.Audio(sources=["microphone"], type="filepath", label="🎤 Voice Input")
-            text_input = gr.Textbox(lines=5, placeholder="📝 Type your text here...", label="Text Input")
-            submit_btn = gr.Button("🚀 Analyze Text", variant="primary")
+            audio = gr.Audio(sources=["microphone"], type="filepath", 
+                           label="🎤 Voice Input")
+            text = gr.Textbox(lines=5, placeholder="📝 Enter text here...", 
+                            label="Text Input")
+            btn = gr.Button("Analyze", variant="primary")
             
         with gr.Column(scale=2):
-            gr.Markdown("### 3D Visualization")
-            threejs = gr.HTML(THREEJS_TEMPLATE)
+            gr.Markdown("### Writing Analytics")
+            visualization = gr.HTML(D3_TEMPLATE)
+            report = gr.JSON(label="Detailed Report")
             
-            with gr.Row():
-                grammar_score = gr.Number(label="📊 Grammar Score", precision=0)
-                score_gauge = gr.BarPlot(x=["Score"], y=[0], color="#3b82f6", height=150)
-                
-            diff_output = gr.HTML(label="📝 Text Corrections")
-            hidden_trigger = gr.HTML(visible=False)
-
-    # Fixed examples configuration
-    gr.Markdown("### Example Sentences")
+            gr.Markdown("### Corrected Text")
+            corrected = gr.Textbox(label="Result", interactive=False)
+    
+    # Examples handling
+    gr.Markdown("### Example Inputs")
     gr.Examples(
         examples=[
-            ["I is going to the park yesterday."],  # Text-only examples
+            ["I is going to the park yesterday."],
             ["Their happy about there test results."],
             ["She dont like apples, but she like bananas."]
         ],
-        inputs=[text_input],  # Only text input
-        outputs=[text_input, grammar_score, diff_output, hidden_trigger],
-        fn=lambda text: process_input(None, text),  # Explicitly handle text-only examples
-        cache_examples=False  # Disable caching to prevent startup issues
+        inputs=[text],
+        outputs=[report, corrected],
+        fn=lambda t: process_input(None, t),
+        cache_examples=False
     )
     
-    submit_btn.click(
+    btn.click(
         fn=process_input,
-        inputs=[audio_input, text_input],
-        outputs=[text_input, grammar_score, diff_output, hidden_trigger]
+        inputs=[audio, text],
+        outputs=[report, corrected]
     )
     
-    text_input.change(
-        lambda x: analyze_grammar(x)["score"] if x else 0,
-        inputs=text_input,
-        outputs=grammar_score
+    # JavaScript update
+    visualization.change(
+        fn=lambda data: f"<script>updateDashboard({json.dumps(data)})</script>",
+        inputs=[report],
+        outputs=[visualization]
     )
 
 if __name__ == "__main__":
     app.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        share=False  # Disable sharing until basic functionality works
+        share=False
     )