helper.py

import pdfplumber
from langchain.text_splitter import CharacterTextSplitter
from openai import OpenAI
import json
import numpy as np
import time
import re
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
from dotenv import load_dotenv
import os
load_dotenv()

def process_file(filepath):
    """Process file and generate chunks"""
    content = []
    with pdfplumber.open(filepath) as pdf:
        for page in pdf.pages:
            text = page.extract_text()
            if text:  # Avoid NoneType errors
                content.append(text)

    # Join extracted text with proper spacing
    full_text = "\n\n".join(content)
    
    # Apply chunking
    text_splitter = CharacterTextSplitter(
        chunk_size=50000,
        chunk_overlap=10
    )

    chunks = text_splitter.split_text(full_text)

    # Vectorize and get similarities
    query = ""
    vectorizer = TfidfVectorizer()
    vectors = vectorizer.fit_transform([query] + chunks)
    cosine_similarities = cosine_similarity(vectors[0:1], vectors[1:]).flatten()
    
    # Select top chunks
    if len(chunks) > 8:
        top_n = int(len(chunks)/2)
    else:
        top_n = len(chunks)
    if len(query) < 5:
        top_n = len(chunks)
    top_indices = cosine_similarities.argsort()[-top_n:][::-1]

    return chunks

    
def givemcqquestion(chunks, create, evaluate, analyze, apply, understand, remember, level,questions):
    if level == 1:
        game = "easy and non-tricky with simple options"
    elif level == 2:
        game = "tricky and medium-level lengthy questions"
    elif level == 3:
        game = "hard and tricky and lengthy questions"
    else:
        raise ValueError("Invalid level. Choose 1 (easy), 2 (medium), or 3 (hard).")

    prompt = f"""You are an AI designed to generate high-quality {game} level multiple-choice questions (MCQs) for educational assessments, following Bloom’s Taxonomy. Your task is to create a well-structured question that aligns with the given cognitive level, ensuring it accurately reflects the required depth of understanding.



Instructions:

For each Bloom’s Taxonomy level, follow the guidelines below to ensure appropriate question complexity:

- **Knowledge (Remembering)**: Formulate a factual or recall-based question.

- **Comprehension (Understanding)**: Create a question that requires explanation or interpretation.

- **Application (Applying)**: Develop a question that applies knowledge to a new situation.

- **Analysis (Analyzing)**: Design a question that encourages breaking down concepts.

- **Synthesis (Creating)**: Construct a question requiring idea combination or new approaches.

- **Evaluation (Evaluating)**: Generate a question that involves judgment or assessment.



STRICT RULES:

- Generate exactly **{questions} MCQ** based on the given context and Bloom’s Taxonomy level.

- Return the response as a **structured JSON object** without any additional text.

- The question should reflect the complexity required for the given cognitive level.

- Options should be **plausible, with only one correct answer** clearly identifiable.

- Ensure a structured rubric to evaluate student responses.



Input Parameters:

- **Context**: {chunks} (Relevant learning material)

- **Bloom’s Taxonomy Distribution**:

  - Understanding: {understand*100}%

  - Analysis: {analyze*100}%

  - Evaluation: {evaluate*100}%

  - Synthesis: {create*100}%

  - Application: {apply*100}%

  - Knowledge: {remember*100}%



Expected JSON Output Format:



{{

  "question": "<Your MCQ Question>",

  "options": {{

    "A": "<Option A>",

    "B": "<Option B>",

    "C": "<Option C>",

    "D": "<Option D>"

  }},

  "correct_answer": "<Correct Option>",

  "rubric": {{

    "key_concept_assessed": "<Briefly explain what is being tested>",

    "criteria_for_correct_answer": "<Explain why the correct answer is correct>",

    "common_misconceptions": "<List potential incorrect assumptions>",

    "cognitive_skill_tested": "<Describe how it aligns with Bloom’s Taxonomy>"

  }}

}}



"""
    print("API KEY",os.getenv("API_KEY"))
    print("BASE URL",os.getenv("GENERATOR_BASE_URL"))
    print("MODEL NAME",os.getenv("MODEL_NAME"))
    client = OpenAI(
        api_key=os.getenv("API_KEY"),
        base_url=os.getenv("GENERATOR_BASE_URL")
    )

    response = client.chat.completions.create(
        model=os.getenv("MODEL_NAME"),
        messages=[{"role": "user", "content": prompt}]
    )

    mcq = response.choices[0].message.content
    if "```json" in mcq:
      mcq = mcq.replace("```json","")
      mcq = mcq.replace("```","")
    mcq = mcq.replace("\n","")
    mcq = json.loads(mcq)
    return mcq,prompt


def givetruefalsequestion(chunks, create, evaluate, analyze, apply, understand, remember, level,questions):
    if level == 1:
        game = "easy and straightforward statements"
    elif level == 2:
        game = "moderate complexity with slight trickiness"
    elif level == 3:
        game = "complex and tricky statements requiring deep understanding"
    else:
        raise ValueError("Invalid level. Choose 1 (easy), 2 (medium), or 3 (hard).")

    prompt = f"""You are an AI designed to generate high-quality {game} level **True/False** questions for educational assessments, following Bloom’s Taxonomy. Your task is to create a well-structured **True/False** question that aligns with the given cognitive level, ensuring it accurately reflects the required depth of understanding.



    ### **Instructions:**

    For each Bloom’s Taxonomy level, follow the guidelines below to ensure appropriate question complexity:

    - **Knowledge (Remembering)**: Generate a straightforward fact-based statement.

    - **Comprehension (Understanding)**: Formulate a statement that requires explanation or interpretation.

    - **Application (Applying)**: Develop a statement that applies knowledge to a new situation.

    - **Analysis (Analyzing)**: Design a statement that involves breaking down concepts.

    - **Synthesis (Creating)**: Construct a statement requiring combining ideas or new approaches.

    - **Evaluation (Evaluating)**: Generate a statement requiring judgment or assessment.



    ### **STRICT RULES:**

    - Generate exactly **{questions}** True/False question.

    - Return the response as a **structured JSON object** without any additional text.

    - The question should reflect the complexity required for the given cognitive level.

    - Ensure a structured rubric to evaluate student responses.



    ### **Input Parameters:**

    - **Context**: {chunks} (Relevant learning material)

    - **Bloom’s Taxonomy Distribution**:

    - Understanding: {understand*100}%

    - Analysis: {analyze*100}%

    - Evaluation: {evaluate*100}%

    - Synthesis: {create*100}%

    - Application: {apply*100}%

    - Knowledge: {remember*100}%



    ### **Expected JSON Output Format:**

    ```json

    {{

    "statement": "<Your True/False Statement>",

    "correct_answer": "<True or False>",

    "rubric": {{

        "key_concept_assessed": "<Briefly explain what is being tested>",

        "criteria_for_correct_answer": "<Explain why the correct answer is correct>",

        "common_misconceptions": "<List potential incorrect assumptions>",

        "cognitive_skill_tested": "<Describe how it aligns with Bloom’s Taxonomy>"

    }}

    }}

    """
    client = OpenAI(
        api_key=os.getenv("API_KEY"),
        base_url=os.getenv("GENERATOR_BASE_URL")
    )

    response = client.chat.completions.create(
        model=os.getenv("MODEL_NAME"),
        messages=[{"role": "user", "content": prompt}]
    )

    tf_question = response.choices[0].message.content
    if "```json" in tf_question:
        tf_question = tf_question.replace("```json", "").replace("```", "")
    tf_question = tf_question.replace("\n", "")
    tf_question = json.loads(tf_question)
    return tf_question




def giveopenquestion(chunks, create, evaluate, analyze, apply, understand, remember, level, questions):
    # Validate input parameters
    bloom_params = {
        'create': create,
        'evaluate': evaluate,
        'analyze': analyze,
        'apply': apply,
        'understand': understand,
        'remember': remember
    }
    
    if not all(0 <= val <= 1 for val in bloom_params.values()):
        raise ValueError("All Bloom's parameters must be between 0 and 1")
    
    if level not in [1, 2, 3]:
        raise ValueError("Invalid level. Choose 1 (easy), 2 (medium), or 3 (hard).")

    # Complexity description
    complexity_levels = {
        1: "simple recall-based questions",
        2: "moderate explanation questions", 
        3: "complex analytical questions"
    }
    complexity = complexity_levels.get(level)

    prompt = f"""Generate {questions} open-ended question(s) based on the provided context, strictly following these requirements:



    ### CONTEXT:

    {chunks}



    ### BLOOM'S TAXONOMY DISTRIBUTION:

    - Creating: {create*100}%

    - Evaluating: {evaluate*100}%

    - Analyzing: {analyze*100}%

    - Applying: {apply*100}%

    - Understanding: {understand*100}%

    - Remembering: {remember*100}%



    ### COGNITIVE LEVEL:

    {complexity} (Level {level})



    ### OUTPUT REQUIREMENTS:

    - Return ONLY valid JSON format

    - Include detailed rubric with cognitive skill mapping

    - For each question, specify which Bloom's level it primarily targets



    ### RESPONSE FORMAT:

    ```json

    {{

        "metadata": {{

            "blooms_distribution": {{

                "create": {create},

                "evaluate": {evaluate},

                "analyze": {analyze},

                "apply": {apply},

                "understand": {understand},

                "remember": {remember}

            }},

            "complexity_level": {level}

        }},

        "questions": [

            {{

                "question": "Question text",

                "primary_blooms_level": "create|evaluate|analyze|apply|understand|remember",

                "rubric": {{

                    "key_concept": "...",

                    "criteria": "...",

                    "misconceptions": "...",

                    "cognitive_skills": {{

                        "primary": "...",

                        "secondary": ["...", "..."]

                    }}

                }}

            }}

        ]

    }}

    ```

    """

    client = OpenAI(
        api_key=os.getenv("API_KEY"),
        base_url=os.getenv("GENERATOR_BASE_URL")
    )

    try:
        response = client.chat.completions.create(
            model=os.getenv("MODEL_NAME"),
            messages=[{"role": "user", "content": prompt}],
            temperature=0.7,
            max_tokens=1200
        )
        raw_response = response.choices[0].message.content

        # Extract JSON from response
        json_match = re.search(r'```json(.*?)```', raw_response, re.DOTALL)
        json_str = json_match.group(1).strip() if json_match else raw_response.strip()

        # Parse and validate JSON
        result = json.loads(json_str)
        
        # Validate structure
        if not all(key in result for key in ['metadata', 'questions']):
            raise ValueError("Response missing required fields")
            
        return result

    except json.JSONDecodeError as e:
        print(f"JSON Decode Error: {e}")
        print(f"Problematic response:\n{raw_response}")
        raise
    except Exception as e:
        print(f"API Error: {e}")
        raise
    


def generate_questions_from_file(filepath, mcq, tf, qna, create, evaluate, analyze, apply, understand, remember, level):
    """Main function to generate questions from file"""
    # Process file first
    chunks = process_file(filepath)
    
    # Generate questions using existing functionality
    MAX_RETRIES = 3
    RETRY_DELAY = 1
    
    def get_random_chunk():
        return chunks[np.random.randint(len(chunks))] if chunks else ""
    
    def generate_questions(q_type, count, generator):
        results = []
        for _ in range(count):
            for attempt in range(MAX_RETRIES):
                try:
                    chunk = get_random_chunk()
                    question = generator(chunk, create, evaluate, analyze, apply, 
                                       understand, remember, level, questions=1)
                    results.append(question)
                    break
                except Exception as e:
                    print(f"Error generating {q_type} question (attempt {attempt+1}): {str(e)}")
                    if attempt == MAX_RETRIES - 1:
                        results.append({"error": f"Failed to generate {q_type} question"})
                    time.sleep(RETRY_DELAY)
        return results

    return {
        'mcq': generate_questions("MCQ", mcq, givemcqquestion),
        'tf': generate_questions("True/False", tf, givetruefalsequestion),
        'qna': generate_questions("Q&A", qna, giveopenquestion)
    }

if __name__ == "__main__":
    # Example usage
    filepath = "data/eco.pdf"
    mcq = 1
    tf = 1
    qna = 1
    level = 1
    create = 0.2
    evaluate = 0.2
    analyze = 0.2
    apply = 0.2
    understand = 0.2
    remember = 0.2
    
    questions = generate_questions_from_file(
        filepath, mcq, tf, qna, create, evaluate, 
        analyze, apply, understand, remember, level
    )
    print(questions)