app.py

# # import gradio as gr
# # from transformers import pipeline
# # import pytesseract
# # from sentence_transformers import SentenceTransformer, util
# # from PIL import Image
# # from typing import List
# # import requests

# # # Initialize sentence transformer model
# # model1 = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')

# # # Hugging Face API details
# # API_URL = "https://api-inference.huggingface.co/models/openai-community/gpt2"
# # headers = {"Authorization": f"Bearer {hf_TsCTtXxnvpmhFKABqKmcVLyLEhjQPsITSVx}"}

# # # Function to interact with Hugging Face API for GPT-2
# # def query(payload):
# #     response = requests.post(API_URL, headers=headers, json=payload)
# #     return response.json()

# # # Function to generate text response from GPT-2 model using Hugging Face API
# # def generate_response(prompt):
# #     response = query({"inputs": prompt})
    
# #     # Check if the response contains the expected format
# #     if isinstance(response, list) and len(response) > 0 and 'generated_text' in response[0]:
# #         return response[0]['generated_text']
# #     else:
# #         # Log the response if something unexpected is returned
# #         print("Unexpected response format:", response)
# #         return "Sorry, I couldn't generate a response."
    

# # # Function to generate text response from GPT-2 model using Hugging Face API
# # # def generate_response(prompt):
# # #     response = query({"inputs": prompt})
# # #     return response[0]['generated_text']

# # # Extract text from an image using Tesseract
# # def extract_text_from_image(filepath: str, languages: List[str]):
# #     image = Image.open(filepath)
# #     lang_str = '+'.join(languages)  # Join languages for Tesseract
# #     return pytesseract.image_to_string(image=image, lang=lang_str)

# # # Function to get embeddings for text using SentenceTransformer
# # def get_embedding(text):
# #     return model1.encode(text, convert_to_tensor=True)

# # # Calculate similarity between two texts using cosine similarity
# # def calculate_similarity(text1, text2):
# #     embedding1 = get_embedding(text1)
# #     embedding2 = get_embedding(text2)
# #     similarity = util.pytorch_cos_sim(embedding1, embedding2)
# #     return similarity.item()

# # # Assign grades based on similarity score
# # def get_grade(similarity_score):
# #     if similarity_score >= 0.9:
# #         return 5
# #     elif similarity_score >= 0.8:
# #         return 4
# #     elif similarity_score >= 0.7:
# #         return 3
# #     elif similarity_score >= 0.6:
# #         return 2
# #     else:
# #         return 1

# # # Function to evaluate student's answer by comparing it to a model answer
# # def evaluate_answer(image, languages):
# #     student_answer = extract_text_from_image(image, languages)
# #     model_answer = "The process of photosynthesis helps plants produce glucose using sunlight."
# #     similarity_score = calculate_similarity(student_answer, model_answer)
# #     grade = get_grade(similarity_score)
# #     feedback = f"Student's answer: {student_answer}\nTeacher's answer: {model_answer}"
# #     prompt=f"the student got grades: {grade} when Student's answer is: {student_answer} and Teacher's answer is: {model_answer}. justify the grades given to student"
# #     return grade, similarity_score * 100, feedback, prompt

# # # Main interface function for Gradio
# # def gradio_interface(image, languages: List[str], prompt=""):
# #     grade, similarity_score, feedback,prompt = evaluate_answer(image, languages)
# #     response = generate_response(prompt)
# #     return grade, similarity_score, feedback, response

# # # Get available Tesseract languages
# # language_choices = pytesseract.get_languages()

# # # Define Gradio interface
# # interface = gr.Interface(
# #     fn=gradio_interface,
# #     inputs=[
# #         gr.Image(type="filepath", label="Input"), 
# #         gr.CheckboxGroup(language_choices, type="value", value=['eng'], label='language'),
# #         gr.Textbox(lines=2, placeholder="Enter your prompt here", label="Prompt")
# #     ],
# #     outputs=[
# #         gr.Text(label="Grade"), 
# #         gr.Number(label="Similarity Score (%)"), 
# #         gr.Text(label="Feedback"), 
# #         gr.Text(label="Generated Response")
# #     ],
# #     title="Automated Grading System",
# #     description="Upload an image of your answer sheet to get a grade from 1 to 5, similarity score, and feedback based on the model answer.",
# #     live=True
# # )

# # if __name__ == "__main__":
# #     interface.launch()





# import os
# from groq import Groq
# import gradio as gr
# from transformers import pipeline
# import pytesseract
# from sentence_transformers import SentenceTransformer, util
# from PIL import Image
# from typing import List
# import requests



# import os
# os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "constant-jigsaw-437209-r0-22d4c9dadcc9.json"

# # Initialize sentence transformer model
# model1 = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')

# # Initialize Groq client
# client = Groq(api_key=os.environ.get("GROQ_API_KEY"))

# # System prompt for Groq
# system_prompt = {
#     "role": "system",
#     "content": "You are a useful assistant. You reply with efficient answers."
# }

# # Function to interact with Groq for generating response
# async def chat_groq(message, history):
#     messages = [system_prompt]

#     for msg in history:
#         messages.append({"role": "user", "content": str(msg[0])})
#         messages.append({"role": "assistant", "content": str(msg[1])})

#     messages.append({"role": "user", "content": str(message)})

#     response_content = ''
    
#     stream = client.chat.completions.create(
#         model="llama3-70b-8192",
#         messages=messages,
#         max_tokens=1024,
#         temperature=1.3,
#         stream=True
#     )

#     for chunk in stream:
#         content = chunk.choices[0].delta.content
#         if content:
#             response_content += chunk.choices[0].delta.content
#         yield response_content

# # Extract text from an image using Tesseract
# def extract_text_from_image(filepath: str, languages: List[str]):
#     image = Image.open(filepath)
#     lang_str = '+'.join(languages)  # Join languages for Tesseract
#     return pytesseract.image_to_string(image=image, lang=lang_str)

# # Function to get embeddings for text using SentenceTransformer
# def get_embedding(text):
#     return model1.encode(text, convert_to_tensor=True)

# # Calculate similarity between two texts using cosine similarity
# def calculate_similarity(text1, text2):
#     embedding1 = get_embedding(text1)
#     embedding2 = get_embedding(text2)
#     similarity = util.pytorch_cos_sim(embedding1, embedding2)
#     return similarity.item()

# # Assign grades based on similarity score
# def get_grade(similarity_score):
#     if similarity_score >= 0.9:
#         return 5
#     elif similarity_score >= 0.8:
#         return 4
#     elif similarity_score >= 0.7:
#         return 3
#     elif similarity_score >= 0.6:
#         return 2
#     else:
#         return 1

# # Function to evaluate student's answer by comparing it to a model answer
# def evaluate_answer(image, languages):
#     student_answer = extract_text_from_image(image, languages)
#     model_answer = "The process of photosynthesis helps plants produce glucose using sunlight."
#     similarity_score = calculate_similarity(student_answer, model_answer)
#     grade = get_grade(similarity_score)
#     feedback = f"Student's answer: {student_answer}\nTeacher's answer: {model_answer}"
#     prompt = f"The student got grade: {grade} when the student's answer is: {student_answer} and the teacher's answer is: {model_answer}. Justify the grade given to the student."
#     return grade, similarity_score * 100, feedback, prompt

# # Main interface function for Gradio
# async def gradio_interface(image, languages: List[str], prompt="", history=[]):
#     grade, similarity_score, feedback, prompt = evaluate_answer(image, languages)
#     response = ""
#     async for result in chat_groq(prompt, history):
#         response = result  # Get the Groq response
#     return grade, similarity_score, feedback, response

# # Get available Tesseract languages
# language_choices = pytesseract.get_languages()

# # Define Gradio interface
# interface = gr.Interface(
#     fn=gradio_interface,
#     inputs=[
#         gr.Image(type="filepath", label="Input"), 
#         gr.CheckboxGroup(language_choices, type="value", value=['eng'], label='Languaage'),
#         gr.Textbox(lines=2, placeholder="Enter your prompt here", label="Prompt")
#     ],
#     outputs=[
#         gr.Text(label="Grade"), 
#         gr.Number(label="Similarity Score (%)"), 
#         gr.Text(label="Feedback"), 
#         gr.Text(label="Generated Response")
#     ],
#     title="Automated Grading System",
#     description="Upload an image of your answer sheet to get a grade from 1 to 5, similarity score, and feedback based on the model answer.",
#     live=True
# )

# if __name__ == "__main__":
#     interface.queue()
#     interface.launch()





import os
from groq import Groq
import gradio as gr
from transformers import pipeline
import pytesseract
from sentence_transformers import SentenceTransformer, util
from PIL import Image
from typing import List
import requests
from nltk.metrics.distance import edit_distance  # Levenshtein distance
from google.cloud import vision
import io

# Set up environment
os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "constant-jigsaw-437209-r0-22d4c9dadcc9.json"

# Initialize models
model1 = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')
client = Groq(api_key=os.environ.get("GROQ_API_KEY"))

# Initialize Google Vision Client
vision_client = vision.ImageAnnotatorClient()

# Define system prompt for Groq
system_prompt = {
    "role": "system",
    "content": "You are a useful assistant. You reply with efficient answers."
}

# Groq chat function
async def chat_groq(message, history):
    messages = [system_prompt]
    for msg in history:
        messages.append({"role": "user", "content": str(msg[0])})
        messages.append({"role": "assistant", "content": str(msg[1])})
    messages.append({"role": "user", "content": str(message)})

    response_content = ''
    stream = client.chat.completions.create(
        model="llama3-70b-8192",
        messages=messages,
        max_tokens=1024,
        temperature=1.3,
        stream=True
    )
    for chunk in stream:
        content = chunk.choices[0].delta.content
        if content:
            response_content += content
        yield response_content

# Extract text using Google Vision OCR
def extract_text_from_image(image_path):
    with io.open(image_path, 'rb') as image_file:
        content = image_file.read()
    image = vision.Image(content=content)
    response = vision_client.text_detection(image=image, image_context={"language_hints": ["en"]})
    texts = response.text_annotations
    if texts:
        return texts[0].description
    return "No text detected."

# Function to calculate text similarity (embedding + Levenshtein distance)
def calculate_similarity(text1, text2):
    embedding1 = model1.encode(text1, convert_to_tensor=True)
    embedding2 = model1.encode(text2, convert_to_tensor=True)

    # Cosine similarity of embeddings
    cosine_similarity = util.pytorch_cos_sim(embedding1, embedding2).item()

    # Levenshtein distance (word order similarity)
    word_order_similarity = 1 - (edit_distance(text1.split(), text2.split()) / max(len(text1.split()), len(text2.split())))

    # Combine similarity scores
    alpha = 0.7  # Weighting factor
    combined_similarity = (alpha * cosine_similarity) + ((1 - alpha) * word_order_similarity)
    return combined_similarity, word_order_similarity, cosine_similarity

# Function to map similarity score to grade
def get_grade(similarity_score):
    if similarity_score >= 1:
        return 5
    elif similarity_score >= 0.9:
        return 4
    elif similarity_score >= 0.8:
        return 3
    elif similarity_score >= 0.75:
        return 2
    else:
        return 1

# Evaluate answer based on similarity with the model answer
def evaluate_answer(student_answer):
    model_answer = "Photosynthesis is the process plants use to make their own food using sunlight. They take in carbon dioxide from the air and water from the soil. Using sunlight, they convert these into glucose (a type of sugar that gives them energy) and oxygen, which they release back into the air."
    
    similarity_score, ws, cs = calculate_similarity(student_answer, model_answer)
    grade = get_grade(similarity_score)
    
    feedback = generate_feedback(student_answer, model_answer)
    return grade, similarity_score * 100, feedback, ws, cs

# Function to generate feedback
def generate_feedback(student_answer, model_answer):
    feedback = []
    if student_answer.lower() not in model_answer.lower():
        feedback.append("The answer is not closely aligned with the model answer.")
    return " ".join(feedback) if feedback else "Answer is well aligned with the model."

# Gradio interface for interaction
async def gradio_interface(image, languages: List[str], prompt="", history=[]):
    student_answer = extract_text_from_image(image)
    grade, similarity_score, feedback, ws, cs = evaluate_answer(student_answer)
    
    # Generate response using Groq chat
    response = ""
    async for result in chat_groq(prompt, history):
        response = result

    return grade, similarity_score, feedback, response

# Define Gradio interface
interface = gr.Interface(
    fn=gradio_interface,
    inputs=[
        gr.Image(type="filepath", label="Input"), 
        gr.CheckboxGroup(['eng', 'fra', 'spa'], type="value", value=['eng'], label='Language'),
        gr.Textbox(lines=2, placeholder="Enter your prompt here", label="Prompt")
    ],
    outputs=[
        gr.Text(label="Grade"), 
        gr.Number(label="Similarity Score (%)"), 
        gr.Text(label="Feedback"), 
        gr.Text(label="Generated Response")
    ],
    title="Automated Grading System",
    description="Upload an image of your answer sheet to get a grade from 1 to 5, similarity score, and feedback based on the model answer.",
    live=True
)

if __name__ == "__main__":
    interface.launch()