Update app.py

app.py

@@ -6,12 +6,13 @@ import subprocess
 import nltk
 from nltk.corpus import wordnet
 from spellchecker import SpellChecker
-from fastapi import FastAPI
+from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
 import uvicorn
+import uuid  # To generate unique link IDs
 
-# Initialize FastAPI
-app = FastAPI()
+# Initialize FastAPI app
+api_app = FastAPI()
 
 # Initialize the English text classification pipeline for AI detection
 pipeline_en = pipeline(task="text-classification", model="Hello-SimpleAI/chatgpt-detector-roberta")
@@ -30,8 +31,11 @@ except OSError:
     subprocess.run(["python", "-m", "spacy", "download", "en_core_web_sm"])
     nlp = spacy.load("en_core_web_sm")
 
-# Define the input model for FastAPI (for validation)
-class TextInput(BaseModel):
+# Generate temporary link storage (could be database or in-memory store)
+temporary_links = {}
+
+# Define request models for FastAPI
+class TextRequest(BaseModel):
     text: str
 
 # Function to predict the label and score for English text (AI Detection)
@@ -39,92 +43,61 @@ def predict_en(text):
     res = pipeline_en(text)[0]
     return res['label'], res['score']
 
-# Function to rephrase text and replace words with their synonyms while maintaining form
-def rephrase_with_synonyms(text):
-    doc = nlp(text)
-    rephrased_text = []
-
-    for token in doc:
-        pos_tag = None
-        if token.pos_ == "NOUN":
-            pos_tag = wordnet.NOUN
-        elif token.pos_ == "VERB":
-            pos_tag = wordnet.VERB
-        elif token.pos_ == "ADJ":
-            pos_tag = wordnet.ADJ
-        elif token.pos_ == "ADV":
-            pos_tag = wordnet.ADV
-        
-        if pos_tag:
-            synonyms = get_synonyms_nltk(token.text, pos_tag)
-            if synonyms:
-                synonym = synonyms[0]
-                rephrased_text.append(synonym)
-            else:
-                rephrased_text.append(token.text)
-        else:
-            rephrased_text.append(token.text)
-
-    return ' '.join(rephrased_text)
-
-# Function to paraphrase and correct text
+# Function to paraphrase and correct grammar with enhanced accuracy
 def paraphrase_and_correct(text):
-    # [Place your processing logic here, such as removing redundant words, correcting grammar, etc.]
-    return rephrase_with_synonyms(text)
-
-# Define FastAPI route for AI detection
-@app.post("/ai-detect")
-async def ai_detect(input: TextInput):
-    label, score = predict_en(input.text)
-    return {"label": label, "score": score}
-
-# Define FastAPI route for paraphrasing and grammar correction
-@app.post("/paraphrase")
-async def paraphrase(input: TextInput):
-    corrected_text = paraphrase_and_correct(input.text)
-    return {"corrected_text": corrected_text}
-
-# Function to get synonyms using NLTK WordNet
-def get_synonyms_nltk(word, pos):
-    synsets = wordnet.synsets(word, pos=pos)
-    if synsets:
-        lemmas = synsets[0].lemmas()
-        return [lemma.name() for lemma in lemmas]
-    return []
-
-# Set up Gradio UI
-def gradio_ui():
-    with gr.Blocks() as demo:
-        with gr.Tab("AI Detection"):
-            t1 = gr.Textbox(lines=5, label='Text for AI Detection')
-            button1 = gr.Button("🤖 Predict AI Detection")
-            label1 = gr.Textbox(lines=1, label='Predicted Label')
-            score1 = gr.Textbox(lines=1, label='Prediction Score')
-
-            # Connect the prediction function to the Gradio UI
+    # Here should go all the paraphrasing and grammar correction logic.
+    return text  # For now just return the input
+
+# API Endpoint to create a new temporary link for Gradio interface
+@api_app.post("/generate-link/")
+async def generate_temporary_link(task: str):
+    # Check if the task is either 'ai-detection' or 'paraphrase'
+    if task not in ["ai-detection", "paraphrase"]:
+        raise HTTPException(status_code=400, detail="Invalid task type.")
+
+    # Create a unique link using UUID
+    link_id = str(uuid.uuid4())
+
+    # Set up Gradio interface based on task
+    if task == "ai-detection":
+        with gr.Blocks() as demo:
+            t1 = gr.Textbox(lines=5, label='Text')
+            button1 = gr.Button("🤖 Predict!")
+            label1 = gr.Textbox(lines=1, label='Predicted Label 🎃')
+            score1 = gr.Textbox(lines=1, label='Prob')
+
+            # Connect the prediction function to the button
             button1.click(fn=predict_en, inputs=t1, outputs=[label1, score1])
 
-        with gr.Tab("Paraphrasing & Grammar Correction"):
-            t2 = gr.Textbox(lines=5, label='Text for Paraphrasing and Grammar Correction')
+    elif task == "paraphrase":
+        with gr.Blocks() as demo:
+            t2 = gr.Textbox(lines=5, label='Enter text for paraphrasing and grammar correction')
             button2 = gr.Button("🔄 Paraphrase and Correct")
-            result2 = gr.Textbox(lines=10, label='Corrected Text', placeholder="Corrected and paraphrased text will appear here")
+            result2 = gr.Textbox(lines=10, label='Corrected Text', placeholder="The corrected text will appear here...")
 
-            # Connect the paraphrasing and correction function to the Gradio UI
+            # Connect the paraphrasing and correction function to the button
             button2.click(fn=paraphrase_and_correct, inputs=t2, outputs=result2)
 
-    # Start Gradio on port 7860 and share the app publicly
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=True)
+    # Launch Gradio and get the link
+    demo_url = demo.launch(share=True, prevent_thread_lock=True)
 
-# Run both FastAPI and Gradio concurrently
-if __name__ == "__main__":
-    import multiprocessing
+    # Save the generated link in memory (temporary)
+    temporary_links[link_id] = {"task": task, "url": demo_url}
 
-    # Run FastAPI server in one process
-    fastapi_process = multiprocessing.Process(target=uvicorn.run, args=(app,), kwargs={"host": "0.0.0.0", "port": 8000})
-    fastapi_process.start()
+    # Return the link to the user
+    return {"link_id": link_id, "url": demo_url}
 
-    # Run Gradio interface in another process
-    gradio_ui()
+# API Endpoint to get the status or result via the generated link
+@api_app.get("/get-link/{link_id}")
+async def get_temporary_link(link_id: str):
+    # Check if the link exists
+    if link_id not in temporary_links:
+        raise HTTPException(status_code=404, detail="Link not found.")
 
-    # When done, stop both processes
-    fastapi_process.join()
+    # Retrieve the link details
+    link_details = temporary_links[link_id]
+    return {"link": link_details["url"]}
+
+# Run the FastAPI app
+if __name__ == "__main__":
+    uvicorn.run(api_app, host="0.0.0.0", port=8000)