retry

app.py

@@ -1,102 +1,44 @@
-import os
-import requests
 import gradio as gr
-from dotenv import load_dotenv
-
-# Load environment variables from .env file
-load_dotenv()
-
-# Get the Hugging Face API key from environment variables
-hf_api_key = os.getenv("HF_API_KEY")
-
-# Ensure the API key is loaded correctly
-if hf_api_key is None:
-    raise ValueError("Hugging Face API key not found. Please set it in the .env file.")
-
-# Hugging Face Inference API URL for the model
-api_url = "https://api-inference.huggingface.co/models/allenai/Molmo-7B-D-0924"
-
-# Function to generate questions and options using the Hugging Face API
-def generate_question(text):
-    headers = {
-        "Authorization": f"Bearer {hf_api_key}",
-        "Content-Type": "application/json",
-    }
-
-    # Prompt to generate a question and options
-    prompt = f"Generate a multiple-choice quiz question based on the following content: {text}"
-
-    # Payload for the request
-    data = {
-        "inputs": prompt,
-        "parameters": {"max_length": 100, "do_sample": False},
-    }
-    
-    # Make the request to the Hugging Face API
-    response = requests.post(api_url, headers=headers, json=data)
-    
-    if response.status_code == 200:
-        result = response.json()
-        
-        # Here we assume the model returns a structured result with question, options, and correct answer
-        return {
-            "question": result[0]["question"],
-            "options": result[0]["options"],
-            "correct_answer": result[0]["correct_answer"]
-        }
-    else:
-        return f"Error: {response.status_code} - {response.text}"
-
-# Function to handle file input, generate the question, and display options
-def handle_file(file):
-    # Read the content of the file
-    file_text = file.decode("utf-8")  # Assuming it's a text file
-    # Generate the question with options
-    result = generate_question(file_text)
-    
-    # Return the question and options to be displayed as buttons
-    if isinstance(result, dict):
-        return result["question"], result["options"]
-    else:
-        return result, []  # In case of error, no options are returned
-
-# Function to check if the user's answer is correct
-def check_answer(selected_option, correct_answer):
-    if selected_option == correct_answer:
-        return "Correct!"
-    else:
-        return "Incorrect."
-
-# Gradio interface for handling the file upload and generating the quiz
-with gr.Blocks() as interface:
-    with gr.Row():
-        # File uploader
-        file_input = gr.File(label="Upload a text file")
-        
-        # Question display
-        question_display = gr.Textbox(label="Question", interactive=False)
-        
-        # Option buttons (initialized empty)
-        options = [gr.Button("", visible=False) for _ in range(4)]
-        
-        # Output for displaying whether the answer is correct
-        result_display = gr.Textbox(label="Result", interactive=False)
-
-    def update_ui(file):
-        question, options_list = handle_file(file)
-        # Update the question and buttons with options
-        question_display.update(value=question)
-        for btn, option in zip(options, options_list):
-            btn.update(value=option, visible=True)
-        return question, options_list
-
-    # Hook up the file upload to generate questions and options
-    file_input.change(fn=update_ui, inputs=file_input, outputs=[question_display] + options)
-
-    # Each button click checks if the selected answer is correct
-    for i, btn in enumerate(options):
-        btn.click(fn=check_answer, inputs=[btn, "correct_answer"], outputs=result_display)
-
-# Launch the Gradio app
-if __name__ == "__main__":
-    interface.launch()
+import torch
+from transformers import AutoTokenizer, AutoModelForQuestionAnswering
+
+# Replace with your Hugging Face API token
+hf_api_token = "HF_API_KEY"
+
+def generate_questions(file_content):
+    # Load MolMo model and tokenizer with API token
+    model_name = "molmo/molmo-qa-base"
+    tokenizer = AutoTokenizer.from_pretrained(model_name, use_auth_token=hf_api_token)
+    model = AutoModelForQuestionAnswering.from_pretrained(model_name, use_auth_token=hf_api_token)
+
+    # Preprocess file content (assuming it's already text)
+    text = file_content.decode("utf-8")
+
+    # Generate questions and answers
+    inputs = tokenizer(text, return_tensors="pt")
+    outputs = model(**inputs)
+    answers = tokenizer.decode(outputs.start_logits.argmax(), skip_special_tokens=True)
+
+    # Extract questions and options (basic implementation)
+    questions = []
+    options = []
+    for answer in answers.split("."):
+        if answer.startswith("Q"):
+            questions.append(answer.strip())
+        else:
+            options.append(answer.strip())
+
+    return questions, options
+
+# Create Gradio interface
+question_box = gr.Textbox(label="Question")
+option_box = gr.Textbox(label="Options")
+
+iface = gr.Interface(
+    fn=generate_questions,
+    inputs=gr.File(label="Upload File"),
+    outputs=[question_box, option_box],
+    title="Question and Option Generator"
+)
+
+iface.launch()