Update app.py

app.py

@@ -1,144 +1,72 @@
 import gradio as gr
-import requests
-from fpdf import FPDF
 import nltk
-import tempfile
 from nltk.tokenize import sent_tokenize, word_tokenize
 from nltk.corpus import stopwords
-from collections import Counter
-import random
+from sklearn.feature_extraction.text import TfidfVectorizer
+import openai
+import datetime
 
-# Download necessary NLTK data
+# Ensure necessary NLTK resources are downloaded
 try:
-    nltk.download("punkt")
-    nltk.download("stopwords")
-except:
-    print("NLTK data download failed.")
-
-stop_words = set(stopwords.words("english"))
-
-def custom_sent_tokenize(text):
-    return text.split(". ")
-
-def transcribe(audio_path):
-    with open(audio_path, "rb") as audio_file:
-        audio_data = audio_file.read()
-
-    groq_api_endpoint = "https://api.groq.com/openai/v1/audio/transcriptions"
-    headers = {
-        "Authorization": "Bearer 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",  # Replace with your actual API key
-    }
-    files = {
-        'file': ('audio.wav', audio_data, 'audio/wav'),
-    }
-    data = {
-        'model': 'whisper-large-v3-turbo',
-        'response_format': 'json',
-        'language': 'en',
-    }
-
-    response = requests.post(groq_api_endpoint, headers=headers, files=files, data=data)
-
-    if response.status_code == 200:
-        result = response.json()
-        transcript = result.get("text", "No transcription available.")
-        return generate_notes(transcript)
-    else:
-        error_msg = response.json().get("error", {}).get("message", "Unknown error.")
-        print(f"API Error: {error_msg}")
-        return create_error_pdf(f"API Error: {error_msg}")
-
+    nltk.data.find('tokenizers/punkt')
+    nltk.data.find('corpora/stopwords')
+except LookupError:
+    nltk.download('punkt')
+    nltk.download('stopwords')
+
+# Transcription function (mocked for this example)
+def transcribe_audio(file_path):
+    # Assume some transcription service is being used, and return text as output
+    transcript = "This is a sample transcription of an audio file. It contains information that can be converted into important points for study notes."
+    return transcript
+
+# Function to extract key sentences
 def extract_key_sentences(transcript):
-    try:
-        sentences = sent_tokenize(transcript)
-    except LookupError:
-        sentences = custom_sent_tokenize(transcript)
-
-    important_sentences = [sentence for sentence in sentences if any(word.lower() not in stop_words for word in word_tokenize(sentence))]
-    top_sentences = sorted(important_sentences, key=lambda x: len(x), reverse=True)[:5]
-    return top_sentences
-
-def generate_questions(sentences):
-    long_questions = [f"Explain the importance of: '{sentence}'." for sentence in sentences]
-    short_questions = [f"What does '{sentence.split()[0]}' refer to?" for sentence in sentences[:5]]
-
-    mcqs = []
-    for sentence in sentences[:5]:
-        words = [word for word in word_tokenize(sentence) if word.isalpha() and word.lower() not in stop_words]
-        if not words:
-            continue
-        key_word = random.choice(words)
-        mcq = {
-            "question": f"What is '{key_word}'?",
-            "options": [key_word] + random.sample(["Option A", "Option B", "Option C"], 3),
-            "answer": key_word
-        }
-        mcqs.append(mcq)
-
-    return long_questions, short_questions, mcqs
-
+    stop_words = set(stopwords.words("english"))
+    sentences = sent_tokenize(transcript)
+    important_sentences = [
+        sentence for sentence in sentences
+        if any(word.lower() not in stop_words for word in word_tokenize(sentence))
+    ]
+    return important_sentences
+
+# Function to generate study notes from the transcription
 def generate_notes(transcript):
     key_sentences = extract_key_sentences(transcript)
-    long_questions, short_questions, mcqs = generate_questions(key_sentences)
-    pdf_path = create_pdf(transcript, long_questions, short_questions, mcqs)
-    return pdf_path
-
-def create_pdf(transcript, long_questions, short_questions, mcqs):
-    pdf = FPDF()
-    pdf.add_page()
-    
-    pdf.set_font("Arial", "B", 16)
-    pdf.cell(200, 10, "Transcription Notes", ln=True, align="C")
-
-    pdf.set_font("Arial", "", 12)
-    pdf.multi_cell(0, 10, f"Transcription:\n{transcript.encode('latin1', 'replace').decode('latin1')}\n\n")
-
-    pdf.set_font("Arial", "B", 14)
-    pdf.cell(200, 10, "Long Questions", ln=True)
-    pdf.set_font("Arial", "", 12)
-    for question in long_questions:
-        pdf.multi_cell(0, 10, f"- {question.encode('latin1', 'replace').decode('latin1')}\n")
-
-    pdf.set_font("Arial", "B", 14)
-    pdf.cell(200, 10, "Short Questions", ln=True)
-    pdf.set_font("Arial", "", 12)
-    for question in short_questions:
-        pdf.multi_cell(0, 10, f"- {question.encode('latin1', 'replace').decode('latin1')}\n")
-
-    pdf.set_font("Arial", "B", 14)
-    pdf.cell(200, 10, "Multiple Choice Questions (MCQs)", ln=True)
-    pdf.set_font("Arial", "", 12)
-    for mcq in mcqs:
-        pdf.multi_cell(0, 10, f"Q: {mcq['question'].encode('latin1', 'replace').decode('latin1')}")
-        for option in mcq["options"]:
-            pdf.multi_cell(0, 10, f"   - {option.encode('latin1', 'replace').decode('latin1')}")
-        pdf.multi_cell(0, 10, f"Answer: {mcq['answer'].encode('latin1', 'replace').decode('latin1')}\n")
-
-    with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as temp_pdf:
-        pdf.output(temp_pdf.name)
-        pdf_path = temp_pdf.name
     
-    return pdf_path
-
-def create_error_pdf(message):
-    pdf = FPDF()
-    pdf.add_page()
-    pdf.set_font("Arial", "B", 16)
-    pdf.cell(200, 10, "Error Report", ln=True, align="C")
-    pdf.set_font("Arial", "", 12)
-    pdf.multi_cell(0, 10, message.encode('latin1', 'replace').decode('latin1'))
+    # Using TfidfVectorizer for scoring and ranking sentences
+    vectorizer = TfidfVectorizer(stop_words='english')
+    tfidf_matrix = vectorizer.fit_transform(key_sentences)
+    scores = tfidf_matrix.sum(axis=1).A1
+    scored_sentences = sorted(zip(scores, key_sentences), reverse=True)
+
+    # Generating notes as a mix of important sentences
+    long_questions = scored_sentences[:3]  # Take top 3 for long questions
+    short_questions = scored_sentences[3:6]  # Next 3 for short questions
+    mcqs = scored_sentences[6:9]  # Following 3 for MCQs
     
-    with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as temp_pdf:
-        pdf.output(temp_pdf.name)
-        error_pdf_path = temp_pdf.name
+    notes = {
+        "Long Questions": [sentence for _, sentence in long_questions],
+        "Short Questions": [sentence for _, sentence in short_questions],
+        "MCQs": [sentence for _, sentence in mcqs],
+    }
     
-    return error_pdf_path
+    return notes
+
+# Main function for Gradio app
+def transcribe(file):
+    transcript = transcribe_audio(file.name)
+    notes = generate_notes(transcript)
+    return notes
 
+# Gradio UI setup
 iface = gr.Interface(
     fn=transcribe,
-    inputs=gr.Audio(type="filepath"),
-    outputs=gr.File(label="Download PDF with Notes or Error Report"),
-    title="Voice to Text Converter and Notes Generator",
+    inputs="file",
+    outputs="json",
+    title="Audio to Study Notes",
+    description="Transcribe audio to extract key sentences for study notes, including Long Questions, Short Questions, and MCQs."
 )
 
+# Run the app
 iface.launch()