Update app.py

app.py

@@ -1,104 +1,92 @@
 import os
-from fastapi import FastAPI, File, Form, HTTPException
-from fastapi.responses import JSONResponse
-from pydantic import BaseModel
+from flask import Flask, request, render_template, jsonify
 from groq import Groq
-import io
+import json
 
 # Set up the Groq client
-os.environ["GROQ_API_KEY"] = os.getenv("GROQ_API_KEY")
+os.environ["GROQ_API_KEY"] = "your_groq_api_key_here"  # Replace with your actual API key
 client = Groq(api_key=os.environ["GROQ_API_KEY"])
 
-app = FastAPI()
+app = Flask(__name__)
 
-# Pydantic model for the transcription result
-class TranscriptionResponse(BaseModel):
-    transcription: str
+# Route to render the upload form
+@app.route('/')
+def index():
+    return render_template('index.html')
 
-class FeedbackResponse(BaseModel):
-    grammar_feedback: str
-    vocabulary_feedback: str
-    grammar_score: int
-    vocabulary_score: int
+# Route to handle the audio upload and transcription
+@app.route('/transcribe', methods=['POST'])
+def transcribe_audio():
+    audio_data = request.files['audio_data']
+    selected_language = request.form['language']
 
-@app.get("/")
-async def index():
-    return {"message": "Welcome to the Audio Transcription API!"}
-
-@app.post("/transcribe")
-async def transcribe_audio(audio_data: bytes = File(...), language: str = Form(...)):
     try:
         # Transcribe the audio based on the selected language
         transcription = client.audio.transcriptions.create(
-            file=("audio.wav", audio_data),
-            model="whisper-large-v3",
-            prompt="Transcribe the audio accurately based on the selected language.",
+            file=(audio_data.filename, audio_data.read()),
+            model="whisper-large-v3",  # You can change this model if needed
             response_format="text",
-            language=language,
+            language=selected_language,
         )
-        return JSONResponse(content=TranscriptionResponse(transcription=transcription).dict())
+
+        return jsonify({'transcription': transcription['text']})  # Fix to extract text
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+        return str(e), 500
 
-@app.post("/check_grammar")
-async def check_grammar(transcription: str = Form(...), language: str = Form(...)):
-    if not transcription or not language:
-        raise HTTPException(status_code=400, detail="Missing transcription or language selection")
+# Route to check grammar and vocabulary of the transcription
+@app.route('/check_grammar', methods=['POST'])
+def check_grammar():
+    transcription = request.form['transcription']
+    selected_language = request.form['language']
 
-    try:
-        # Grammar check
-        grammar_prompt = (
-            f"Briefly check the grammar of the following text in {language}: {transcription}. "
-            "Identify any word that does not belong to the selected language and flag it. Based on the number of incorrect words, "
-            "also check the grammar deeply and carefully. Provide a score from 1 to 10 based on the grammar accuracy, reducing points for incorrect words, "
-            "and make sure to output the score on a new line after two line breaks like \"SCORE=\"."
-        )
+    if not transcription:
+        return "No transcription available."
 
+    try:
+        # Grammar check with scoring and concise feedback
+        grammar_prompt = f"""
+        Check the grammar of the following text in {selected_language}:
+        \"\"\"
+        {transcription}
+        \"\"\"
+        Provide a score from 1 to 10 and a concise feedback (1-1.5 lines) without including the score in the feedback.
+        Return the result in JSON format with keys 'score' and 'feedback'.
+        """
         grammar_check_response = client.chat.completions.create(
-            model="llama3-groq-70b-8192-tool-use-preview",
+            model="gemma-7b-it",  # Change the model if needed
             messages=[{"role": "user", "content": grammar_prompt}]
         )
-        grammar_feedback = grammar_check_response.choices[0].message.content.strip()
-
-        # Vocabulary check
-        vocabulary_prompt = (
-            f"Check the vocabulary accuracy of the following text in {language}: {transcription}. "
-            "Identify any word that does not belong to the selected language and flag it. Based on the number of incorrect words, "
-            "also check the grammar deeply and carefully. Provide a score from 1 to 10 based on the vocabulary accuracy, reducing points for incorrect words, "
-            "and make sure to output the score on a new line after two line breaks like \"SCORE=\"."
-        )
+        grammar_response_content = grammar_check_response.choices[0].message.content.strip()
+        grammar_result = json.loads(grammar_response_content)
+        grammar_score = grammar_result.get('score', '')
+        grammar_feedback = grammar_result.get('feedback', '')
 
+        # Vocabulary check with scoring and concise feedback
+        vocabulary_prompt = f"""
+        Check the vocabulary accuracy of the following text in {selected_language}:
+        \"\"\"
+        {transcription}
+        \"\"\"
+        Provide a score from 1 to 10 and a concise feedback (1-1.5 lines) without including the score in the feedback.
+        Return the result in JSON format with keys 'score' and 'feedback'.
+        """
         vocabulary_check_response = client.chat.completions.create(
-            model="llama-3.1-70b-versatile",
+            model="llama3-8b-8192",  # Change the model if needed
             messages=[{"role": "user", "content": vocabulary_prompt}]
         )
-        vocabulary_feedback = vocabulary_check_response.choices[0].message.content.strip()
-
-        # Calculate scores from feedback
-        grammar_score = calculate_score(grammar_feedback)
-        vocabulary_score = calculate_score(vocabulary_feedback)
+        vocabulary_response_content = vocabulary_check_response.choices[0].message.content.strip()
+        vocabulary_result = json.loads(vocabulary_response_content)
+        vocabulary_score = vocabulary_result.get('score', '')
+        vocabulary_feedback = vocabulary_result.get('feedback', '')
 
-        return JSONResponse(content=FeedbackResponse(
-            grammar_feedback=grammar_feedback,
-            vocabulary_feedback=vocabulary_feedback,
-            grammar_score=grammar_score,
-            vocabulary_score=vocabulary_score
-        ).dict())
+        return jsonify({
+            'grammar_feedback': grammar_feedback,
+            'grammar_score': grammar_score,
+            'vocabulary_feedback': vocabulary_feedback,
+            'vocabulary_score': vocabulary_score
+        })
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+        return str(e), 500
 
-def calculate_score(feedback):
-    """
-    Calculate score based on feedback content. 
-    This function searches for the keyword 'SCORE=' or similar variations 
-    (SCORE:, score:, etc.) and extracts the score value.
-    """
-    import re
-    match = re.search(r'(SCORE=|score=|SCORE:|score:|SCORE = )\s*(\d+)', feedback)
-    
-    if match:
-        # Extract and return the score as an integer
-        return int(match.group(2))
-    
-    # Return a default score of 0 if no score is found in the feedback
-    return 0
+if __name__ == "__main__":
+    app.run(debug=True)