Upload 14 files

.dockerignore

@@ -0,0 +1,5 @@
+__pycache__
+*.pyc
+*.pyo
+.env
+.git

Dockerfile

@@ -0,0 +1,17 @@
+# Use an official Python runtime as the base image
+FROM python:3.9-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy all project files to the container
+COPY . .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Expose port 5000 for Flask
+EXPOSE 5000
+
+# Command to run the Flask app
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,16 @@
+from flask import Flask, render_template
+from routes.chatbot_routes import chatbot_routes
+import os
+
+# Explicitly set the templates folder
+app = Flask(__name__, template_folder=os.path.join(os.getcwd(), "templates"))
+
+# Register routes
+app.register_blueprint(chatbot_routes)
+
+@app.route("/")
+def home():
+    return render_template("tempor.html")
+
+if __name__ == "__main__":
+    app.run(debug=True)

requirements.txt

@@ -0,0 +1,3 @@
+open ai version=0.28.0
+python-dotenv
+flask

response.py

@@ -0,0 +1,215 @@
+# Predefined responses
+predefined_responses = {
+    "hi": "Hello! How can I assist you with Python today?",
+    "what is a variable": "A variable is a named reference to a value. Example:\n```python\nx = 5\nprint(x)  # Output: 5\n```",
+    "path": (
+        "To learn Python step-by-step:\n"
+        "1. Install Python.\n"
+        "2. Learn basic syntax: variables, data types, and operators.\n"
+        "3. Practice control structures: loops and if-else statements.\n"
+        "4. Explore Python data structures.\n"
+        "5. Learn functions and error handling."
+    ),
+    "indentation error example": (
+        "An IndentationError occurs when your code is not properly indented. Example:\n"
+        "```python\n"
+        "if True:\nprint('Hello')  # IndentationError\n```\n"
+        "Correct it like this:\n"
+        "```python\n"
+        "if True:\n    print('Hello')\n```"
+    ),
+    "bubble sort example": (
+        "Bubble sort is a simple comparison-based sorting algorithm that works by repeatedly stepping through the list, comparing adjacent elements, and swapping them if they are in the wrong order.\n\n"
+        "Example:\n"
+        "```python\n"
+        "def bubble_sort(arr):\n"
+        "    n = len(arr)\n"
+        "    for i in range(n):\n"
+        "        for j in range(0, n-i-1):\n"
+        "            if arr[j] > arr[j+1]:\n"
+        "                arr[j], arr[j+1] = arr[j+1], arr[j]\n"
+        "    return arr\n\n"
+        "# Test the function\n"
+        "arr = [64, 34, 25, 12, 22, 11, 90]\n"
+        "print('Sorted array:', bubble_sort(arr))\n"
+        "```\n"
+        "This code implements bubble sort and sorts the array."
+    ),
+    "count characters": (
+        "To count the characters in a word in Python, you can use the `len()` function. This function returns the length of a string, which is the number of characters it contains.\n\n"
+        "Example:\n"
+        "```python\n"
+        "word = 'Python'\n"
+        "char_count = len(word)\n"
+        "print(f'The word {word} has {char_count} characters.')\n"
+        "```\n"
+        "This code counts the characters in the word 'Python' and prints the result."
+    ),
+    "product": (
+        "To find the product of two numbers in Python, you can use the multiplication operator (`*`).\n\n"
+        "Example:\n"
+        "```python\n"
+        "a = 5\n"
+        "b = 3\n"
+        "product = a * b\n"
+        "print(f'The product of {a} and {b} is {product}')\n"
+        "```\n"
+        "This code multiplies two numbers and prints the result."
+    ),
+    "factorial": (
+        "To find the factorial of a number in Python, you can use a recursive function or a loop.\n\n"
+        "Example:\n"
+        "```python\n"
+        "def factorial(n):\n"
+        "    if n == 0 or n == 1:\n"
+        "        return 1\n"
+        "    else:\n"
+        "        return n * factorial(n-1)\n\n"
+        "# Test the function\n"
+        "num = 5\n"
+        "print(f'The factorial of {num} is {factorial(num)}')\n"
+        "```\n"
+        "This code calculates the factorial of a given number recursively."
+    ),
+    "fibonacci": (
+        "To find the Fibonacci series in Python, you can use a loop or recursion.\n\n"
+        "Example:\n"
+        "```python\n"
+        "def fibonacci(n):\n"
+        "    fib_sequence = [0, 1]\n"
+        "    for i in range(2, n):\n"
+        "        fib_sequence.append(fib_sequence[-1] + fib_sequence[-2])\n"
+        "    return fib_sequence\n\n"
+        "# Test the function\n"
+        "num = 10\n"
+        "print(f'The first {num} Fibonacci numbers are: {fibonacci(num)}')\n"
+        "```\n"
+        "This code generates the first `n` numbers in the Fibonacci series."
+    ),
+    "if-else": (
+        "The if-else statement is used for decision-making in Python. It allows the program to execute one block of code if a condition is true, and another block if it is false.\n\n"
+        "Example:\n"
+        "```python\n"
+        "num = 10\n"
+        "if num % 2 == 0:\n"
+        "    print('Even number')\n"
+        "else:\n"
+        "    print('Odd number')\n"
+        "```\n"
+        "This code checks if a number is even or odd and prints the result."
+    ),
+    "if else": (
+        "The if-else statement is used for decision-making in Python. It allows the program to execute one block of code if a condition is true, and another block if it is false.\n\n"
+        "Example:\n"
+        "```python\n"
+        "num = 10\n"
+        "if num % 2 == 0:\n"
+        "    print('Even number')\n"
+        "else:\n"
+        "    print('Odd number')\n"
+        "```\n"
+        "This code checks if a number is even or odd and prints the result."
+    ),
+    "what is shallow copy": (
+        "A shallow copy creates a new object but references the same nested objects as the original. Changes to nested objects in the copied object will affect the original.\n\n"
+        "Example:\n"
+        "```python\n"
+        "import copy\n"
+        "original = [[1, 2, 3], [4, 5, 6]]\n"
+        "shallow = copy.copy(original)\n"
+        "shallow[0][0] = 100\n"
+        "print('Original:', original)  # Nested list is affected\n"
+        "print('Shallow:', shallow)\n"
+        "```\n"
+        "This code demonstrates how modifying a shallow copy affects the original object's nested elements."
+    ),
+    "difference between deep and shallow copy": (
+        "In Python, a shallow copy creates a new object, but nested objects are shared between the copy and the original. "
+        "A deep copy creates a new object and recursively copies all nested objects, ensuring complete independence.\n\n"
+        "Example:\n"
+        "```python\n"
+        "import copy\n"
+        "original = [[1, 2], [3, 4]]\n"
+        "shallow = copy.copy(original)\n"
+        "deep = copy.deepcopy(original)\n"
+        "shallow[0][0] = 100  # Affects original\n"
+        "deep[0][0] = 200  # Does not affect original\n"
+        "```\n"
+    ),
+    "python libraries": (
+        "Python libraries are collections of pre-written code that simplify tasks. Popular libraries include NumPy (numerical computing), Pandas (data analysis), "
+        "and Matplotlib (data visualization). Example:\n\n"
+        "```python\n"
+        "import pandas as pd\n"
+        "data = {'Name': ['Alice', 'Bob'], 'Age': [25, 30]}\n"
+        "df = pd.DataFrame(data)\n"
+        "print(df)\n"
+        "```\n"
+        "This creates and displays a simple data table using Pandas."
+    ),
+    "can you provide a simple python code": (
+        "Sure! Here's a simple Python code to calculate the factorial of a number:\n\n"
+        "```python\n"
+        "def factorial(n):\n"
+        "    if n == 0 or n == 1:\n"
+        "        return 1\n"
+        "    else:\n"
+        "        return n * factorial(n-1)\n\n"
+        "# Test the function\n"
+        "num = 5\n"
+        "print(f'The factorial of {num} is {factorial(num)}')\n"
+        "```\n"
+    ),
+    "explain ai": (
+        "Artificial Intelligence (AI) refers to the simulation of human intelligence by machines, allowing them to perform tasks like problem-solving, decision-making, and learning."
+    ),
+    "datatypes examples": (
+        "Sure! In Python, data types are known as classes. Here are some common data types with examples:\n\n"
+        "- **Integer (`int`)**:\n"
+        "   ```python\n"
+        "   num = 10\n"
+        "   print(type(num))  # Output: <class 'int'>\n"
+        "   ```\n\n"
+        "- **String (`str`)**:\n"
+        "   ```python\n"
+        "   text = 'Hello, World!'\n"
+        "   print(type(text))  # Output: <class 'str'>\n"
+        "   ```\n\n"
+        "- **List (`list`)**:\n"
+        "   ```python\n"
+        "   items = [1, 2, 3]\n"
+        "   print(type(items))  # Output: <class 'list'>\n"
+        "   ```"
+    ),
+    "for loop": (
+        "A `for` loop in Python is used to iterate over a sequence and execute a block of code for each item.\n\n"
+        "Example:\n"
+        "```python\n"
+        "fruits = ['apple', 'banana', 'cherry']\n"
+        "for fruit in fruits:\n"
+        "    print(fruit)\n"
+        "```\n"
+        "This code prints each fruit from the list."
+    ),
+    "add": (
+        "To add two numbers in Python, you can use the `+` operator.\n\n"
+        "Example:\n"
+        "```python\n"
+        "a = 5\n"
+        "b = 3\n"
+        "result = a + b\n"
+        "print(f'The sum of {a} and {b} is {result}')\n"
+        "```\n"
+        "This code adds two numbers and prints the result."
+    ),
+    "how to read a string": (
+        "To read a string in Python, you can use the `input()` function. This function takes user input and returns it as a string.\n\n"
+        "Example:\n"
+        "```python\n"
+        "name = input('Enter your name: ')\n"
+        "print(f'Hello, {name}!')\n"
+        "```\n"
+        "This code asks the user to enter their name and then prints a greeting message."
+    )
+
+}

routes/chatbot_routes.py

@@ -0,0 +1,196 @@
+from flask import Blueprint, request, jsonify
+import openai
+import os
+from dotenv import load_dotenv
+from utils.quiz_utils import quiz_questions
+from utils.openai_utils import query_dynamic_generation, format_code_block
+from response import predefined_responses
+
+# Load environment variables
+load_dotenv()
+
+# Initialize OpenAI API
+openai_api_key = os.getenv("OPENAI_API_KEY")
+if not openai_api_key:
+    raise ValueError("OPENAI_API_KEY environment variable is not set!")
+
+openai.api_key = openai_api_key
+
+# Define a Blueprint for chatbot routes
+chatbot_routes = Blueprint("test_hugging_face", __name__)
+
+# Maintain a history for context-aware responses
+history = [
+    {"role": "system", "content": "You are a Python programming tutor and assistant."}
+]
+
+quiz_state = {}  # Initialize quiz state
+
+
+
+def add_to_history(role, content):
+    history.append({"role": role, "content": content})
+    if len(history) > 5:  # Limit to the last 5 exchanges
+        history.pop(1)
+
+
+@chatbot_routes.route("/get_response", methods=["POST"])
+def get_response():
+    user_input = request.json.get("user_input", "").strip()
+
+    if not user_input:
+        return jsonify({"reply": "Please provide a valid input."})
+
+    # Normalize user input
+    user_input_normalized = user_input.lower()
+
+    # Check if the input explicitly asks for an explanation or dynamic query
+    if "explain" in user_input_normalized or "describe" or "what" in user_input_normalized:
+        try:
+            # Handle dynamic query generation for explanations
+            add_to_history("user", user_input)
+            chatbot_reply = query_dynamic_generation(user_input)
+            add_to_history("assistant", chatbot_reply)
+            chatbot_reply = format_code_block(chatbot_reply)
+            return jsonify({"reply": chatbot_reply})
+        except Exception as e:
+            return jsonify({"reply": f"Error: {str(e)}"})
+
+    # Check predefined responses for exact match (if no explanation keyword is found)
+    if user_input_normalized in predefined_responses:
+        chatbot_reply = predefined_responses[user_input_normalized]
+        chatbot_reply = format_code_block(chatbot_reply)
+        return jsonify({"reply": chatbot_reply})
+
+    # Extract keywords for predefined responses
+    keyword = extract_keywords(user_input_normalized)
+
+    if keyword and keyword in predefined_responses:
+        chatbot_reply = predefined_responses[keyword]
+        chatbot_reply = format_code_block(chatbot_reply)
+        return jsonify({"reply": chatbot_reply})
+
+    # Fallback to dynamic query generation if no match is found
+    try:
+        add_to_history("user", user_input)
+        chatbot_reply = query_dynamic_generation(user_input)
+        add_to_history("assistant", chatbot_reply)
+        chatbot_reply = format_code_block(chatbot_reply)
+        return jsonify({"reply": chatbot_reply})
+    except Exception as e:
+        return jsonify({"reply": f"Error: {str(e)}"})
+
+
+
+@chatbot_routes.route("/clear_history", methods=["POST"])
+def clear_history():
+    """
+    Clears the conversation history and resets quiz state.
+    """
+    global history
+    history = [
+        {"role": "system", "content": "You are a Python programming tutor and assistant."}
+    ]
+    quiz_state.clear()  # Clear quiz state if any
+    return jsonify({"reply": "Chat history cleared!"})
+
+
+# Route: Start Quiz
+@chatbot_routes.route("/start_quiz", methods=["POST"])
+def start_quiz():
+    """
+    Initializes or resets the quiz for the user based on the selected difficulty level.
+    """
+    user_id = request.json.get("user_id", "default")
+    level = request.json.get("level", "beginner")  # Default to beginner level
+
+    # Reset quiz state if level changes or new quiz is started
+    if user_id not in quiz_state or quiz_state[user_id].get("level") != level:
+        quiz_state[user_id] = {
+            "current": 0,
+            "level": level,
+            "questions": quiz_questions.get(level, [])
+        }
+
+    state = quiz_state[user_id]
+
+    # Check if there are more questions available
+    if state["current"] < len(state["questions"]):
+        current_question = state["questions"][state["current"]]
+        return jsonify({"question": current_question["question"], "options": current_question["options"]})
+    return jsonify({"reply": "Quiz finished! Great job!"})
+
+
+# Route: Submit Answer
+@chatbot_routes.route("/submit_answer", methods=["POST"])
+def submit_answer():
+    """
+    Handles the user's answer and returns the next question or completion message.
+    """
+    user_id = request.json.get("user_id", "default")
+    answer = request.json.get("answer", "").strip()
+    state = quiz_state.get(user_id, {})
+
+    if not state:
+        return jsonify({"reply": "No active quiz found. Start a quiz first."})
+
+    current_index = state.get("current", 0)
+    questions = state.get("questions", [])
+
+    if current_index >= len(questions):
+        return jsonify({"reply": "You have completed the quiz! Great job!"})
+
+    correct_answer = questions[current_index]["answer"].strip()
+
+    state["current"] += 1  # Move to the next question
+
+    if answer.lower() == correct_answer.lower():
+        if state["current"] < len(questions):
+            next_question = questions[state["current"]]
+            return jsonify({
+                "reply": f"Correct! Here's your next question: ",
+                "next_question": next_question["question"],
+                "options": next_question["options"]
+            })
+        else:
+            return jsonify({"reply": "Correct! You have completed the quiz! Great job!"})
+    else:
+        if state["current"] < len(questions):
+            next_question = questions[state["current"]]
+            return jsonify({
+                "reply": f"Incorrect! The correct answer was: {correct_answer}.",
+                "next_question": next_question["question"],
+                "options": next_question["options"]
+            })
+        else:
+            return jsonify({"reply": f"Incorrect! The correct answer was: {correct_answer}. You have completed the quiz!"})
+
+
+@chatbot_routes.route("/debug_quiz_state", methods=["GET"])
+def debug_quiz_state():
+    return jsonify(quiz_state)
+
+
+def normalize_answer(answer):
+    """
+    Normalize the answer for case-insensitive and whitespace-insensitive matching.
+    """
+    import re
+    # Remove extra spaces and make case-insensitive
+    return re.sub(r"\s+", " ", answer.strip().lower())
+
+
+def extract_keywords(user_input):
+    """
+    Extract keywords from user input to match predefined responses.
+    """
+    user_input_normalized = user_input.lower().strip()
+    keywords = ["product", "fibonacci", "count characters", "add", "factorial", "if-else", "if else", "bubble sort example", "indentation error example", "path", "quiz"]
+    for keyword in keywords:
+        if keyword in user_input_normalized:
+            return keyword
+    return None
+
+
+
+

static/tempor.css

@@ -0,0 +1,109 @@
+/* General Styles */
+body {
+    font-family: 'Roboto', sans-serif;
+    margin: 0;
+    padding: 0;
+    background-color: #f4f4f9;
+}
+
+h1, h2 {
+    color: #0056b3;
+    text-align: center;
+}
+
+#main-container {
+    max-width: 1200px;
+    margin: 20px auto;
+    padding: 20px;
+    background: #ffffff;
+    border-radius: 15px;
+    box-shadow: 0px 5px 15px rgba(0, 0, 0, 0.2);
+}
+
+#content-container {
+    display: flex;
+    gap: 20px;
+}
+
+#chat-section, #quiz-section {
+    flex: 1;
+    background: #f9f9f9;
+    border: 1px solid #ddd;
+    border-radius: 10px;
+    padding: 20px;
+    box-shadow: 0px 3px 10px rgba(0, 0, 0, 0.1);
+}
+
+#response-box, #quiz-box {
+    margin-top: 15px;
+    padding: 15px;
+    background: #f1f1f1;
+    border-radius: 5px;
+    border: 1px solid #ddd;
+    height: 300px;
+    overflow-y: auto;
+}
+
+.quiz-option {
+    margin: 10px 0;
+    display: flex;
+    align-items: center;
+}
+
+.quiz-option input {
+    margin-right: 10px;
+}
+
+.quiz-feedback {
+    color: green;
+    font-weight: bold;
+    margin: 10px 0;
+}
+
+.quiz-end {
+    color: #0056b3;
+    font-weight: bold;
+    margin: 10px 0;
+}
+
+button {
+    background-color: #0056b3;
+    color: white;
+    border: none;
+    border-radius: 5px;
+    padding: 5px 10px;
+    font-size:14px
+    cursor: pointer;
+}
+
+button:hover {
+    background-color: #003d80;
+}
+.btn-primary {
+    padding: 5px 10px;
+    font-size: 14px;
+}
+
+.btn-danger {
+    padding: 5px 10px;
+    font-size: 14px;
+    background-color: red;
+}
+input, select {
+    padding: 8px;
+    margin: 5px 0;
+    border: 1px solid #ddd;
+    border-radius: 5px;
+    width: 100%;
+}
+
+
+#clear-history-btn {
+    display: block;
+    margin: 10px auto; /* Center align */
+}
+
+#chat-form {
+    display: flex;
+    gap: 10px;
+}

templates/tempor.html

@@ -0,0 +1,164 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Interactive Python Chatbot</title>
+    <link rel="stylesheet" type="text/css" href="/static/temper.css">
+    <script>
+        async function sendMessage(event) {
+            event.preventDefault();
+            const userInput = document.getElementById("user_input").value.trim();
+            if (!userInput) {
+                alert("Please enter a valid message.");
+                return;
+            }
+
+            const responseBox = document.getElementById("response-box");
+            responseBox.innerHTML += `<p><strong>User:</strong> ${userInput}</p>`;
+
+            try {
+                const response = await fetch("/get_response", {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ user_input: userInput }),
+                });
+
+                const data = await response.json();
+                responseBox.innerHTML += `<p><strong>Chatbot:</strong> ${data.reply}</p>`;
+                document.getElementById("user_input").value = "";
+            } catch (error) {
+                alert("Error: Unable to send the message.");
+            }
+        }
+
+        async function startQuiz() {
+            const difficulty = document.getElementById("difficulty").value;
+
+            try {
+                const response = await fetch("/start_quiz", {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ user_id: "default", level: difficulty }),
+                });
+
+                const data = await response.json();
+                const quizBox = document.getElementById("quiz-box");
+
+                if (data.question && data.options) {
+                    quizBox.innerHTML = `
+                        <p class="quiz-question"><strong>Question:</strong> ${data.question}</p>
+                        <form id="quiz-form">
+                            ${data.options.map((option, index) => `
+                                <div class="quiz-option">
+                                    <input type="radio" id="option${index}" name="answer" value="${option.split('. ')[0]}">
+                                    <label for="option${index}">${option}</label>
+                                </div>
+                            `).join('')}
+
+                        </form>
+
+                        <button type="button" class="btn btn-primary" onclick="submitAnswer()">Submit Answer</button>
+                    `;
+                } else {
+                    quizBox.innerHTML = `<p class="quiz-end">Quiz finished! Great job!</p>`;
+                }
+            } catch (error) {
+                alert("Error: Unable to start the quiz.");
+            }
+        }
+
+        async function submitAnswer() {
+            const form = document.getElementById("quiz-form");
+            const answer = form.querySelector('input[name="answer"]:checked')?.value;
+
+            if (!answer) {
+                alert("Please select an answer.");
+                return;
+            }
+
+            try {
+                const response = await fetch("/submit_answer", {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ answer, user_id: "default" }),
+                });
+
+                const data = await response.json();
+                const quizBox = document.getElementById("quiz-box");
+
+                // Display feedback for the answer
+                quizBox.innerHTML = `<p class="quiz-feedback">${data.reply}</p>`;
+
+                // Check if there's a next question
+                if (data.next_question && data.options) {
+                    quizBox.innerHTML += `
+                        <p class="quiz-question"><strong>Next Question:</strong> ${data.next_question}</p>
+                        <form id="quiz-form">
+                            ${data.options.map((option, index) => `
+                                <div class="quiz-option">
+                                    <input type="radio" id="option${index}" name="answer" value="${option.split('. ')[0]}">
+                                    <label for="option${index}">${option}</label>
+                                </div>
+                            `).join('')}
+                            <button type="button" class="btn btn-primary" onclick="submitAnswer()">Submit Answer</button>
+                        </form>
+                    `;
+                } else {
+                    quizBox.innerHTML += `<p class="quiz-end">Quiz Completed! Great job!</p>`;
+                }
+            } catch (error) {
+                alert("Error: Unable to submit the answer.");
+            }
+        }
+
+        async function clearHistory() {
+            try {
+                const response = await fetch("/clear_history", { method: "POST" });
+                const data = await response.json();
+                document.getElementById("response-box").innerHTML = "";
+                document.getElementById("quiz-box").innerHTML = "";
+                alert(data.reply || "Chat history cleared!");
+            } catch (error) {
+                alert("Error: Unable to clear history.");
+            }
+        }
+    </script>
+</head>
+<body>
+    <div id="main-container">
+        <div id="header">
+            <h1>Interactive Python Chatbot</h1>
+        </div>
+        <div id="content-container">
+            <!-- Chatbot Section -->
+            <div id="chat-section">
+                <h2>Chatbot</h2>
+                <div id="response-box"></div>
+                <form id="chat-form" onsubmit="sendMessage(event)">
+                    <input type="text" id="user_input" placeholder="Type your message..." required>
+                    <button type="submit">Send</button>
+                </form>
+                <button class="clear-history-btn" onclick="clearHistory()">Clear History</button>
+
+            </div>
+
+            <!-- Quiz Section -->
+            <div id="quiz-section">
+                <h2>Quiz</h2>
+                <div>
+                    <label for="difficulty">Select Difficulty:</label>
+                    <select id="difficulty">
+                        <option value="beginner">Beginner</option>
+                        <option value="intermediate">Intermediate</option>
+                        <option value="advanced">Advanced</option>
+                    </select>
+                    <button class="btn btn-primary" onclick="startQuiz()">Start Quiz</button>
+                </div>
+                <div id="quiz-box"></div>
+            </div>
+        </div>
+    </div>
+</body>
+</html>
+

utils/openai_utils.py

@@ -0,0 +1,52 @@
+import openai
+history = [
+    {"role": "system", "content": "You are a Python programming tutor and assistant."}
+]
+
+def query_dynamic_generation(user_input):
+    """
+    Adjusts response verbosity based on query type.
+    """
+    # Check for keywords to determine verbosity
+    if "explain" in user_input.lower() or "describe" in user_input.lower():
+        prompt = f"""
+        You are a Python tutor.Only answer questions related to Python programming and its libraries. Provide a concise explanation for the query, avoiding unnecessary details. 
+        Focus on delivering the main point clearly and briefly.
+
+        Query: {user_input}
+        Response:
+        """
+    elif "example" in user_input.lower() or "code" in user_input.lower():
+        prompt = f"""
+        You are a Python tutor.Only answer questions related to Python programming and its libraries. Provide a detailed code example for the query, formatted properly for readability with simple explanation. 
+        Avoid lengthy explanations; focus on the code.
+
+        Query: {user_input}
+        Response:
+        """
+    else:
+        prompt = f"""
+        You are a Python tutor.Only answer questions related to Python programming and its libraries. Provide a brief response that directly addresses the user's query.
+
+        Query: {user_input}
+        Response:
+        """
+
+    # Generate response using OpenAI API
+    response = openai.ChatCompletion.create(
+        model="gpt-4o-mini",
+        messages=history + [{"role": "user", "content": prompt}],  # Add the prompt to the message history
+        temperature=0.5,
+        max_tokens=500  # Ensure sufficient length for detailed code examples
+    )
+    return response.choices[0].message["content"].strip()
+
+
+def format_code_block(response):
+    """
+    Formats code blocks for proper HTML rendering.
+    """
+    response = response.replace("```python", "<pre><code>").replace("```", "</code></pre>")
+    response = response.replace("\n", "<br>")
+    return response
+

utils/quiz_utils.py

@@ -0,0 +1,67 @@
+ # Initialize quiz state
+
+quiz_questions = {
+    "beginner": [
+        {"question": "What is the correct syntax to print a message in Python?",
+         "options": ["A. echo 'Hello'", "B. printf('Hello')", "C. print('Hello')", "D. write('Hello')"],
+         "answer": "C. print('Hello')"},
+        {"question": "What is a correct variable name in Python?",
+         "options": ["A. 1variable", "B. variable1", "C. variable-1", "D. variable@1"],
+         "answer": "B. variable1"},
+        {"question": "Which of the following is a Python data type?",
+         "options": ["A. list", "B. array", "C. stack", "D. queue"],
+         "answer": "A. list"},
+        {"question": "What does `len()` do in Python?",
+         "options": ["A. Calculates length of a string or list", "B. Slices a list", "C. Joins strings", "D. Sorts a list"],
+         "answer": "A. Calculates length of a string or list"},
+        {"question": "What is the output of `print(type(10))`?",
+         "options": ["A. int", "B. float", "C. str", "D. None"],
+         "answer": "A. int"}
+    ],
+    "intermediate": [
+        {"question": "Which keyword is used to handle exceptions in Python?",
+         "options": ["A. catch", "B. handle", "C. try", "D. except"],
+         "answer": "C. try"},
+        {"question": "What is the result of `3 == 3.0` in Python?",
+         "options": ["A. True", "B. False", "C. Error", "D. None"],
+         "answer": "A. True"},
+        {"question": "Which of the following is an immutable data type?",
+         "options": ["A. List", "B. Tuple", "C. Dictionary", "D. Set"],
+         "answer": "B. Tuple"},
+        {"question": "What does the `join()` method do?",
+         "options": ["A. Joins lists", "B. Joins elements of a list into a string", "C. Combines dictionaries", "D. Concatenates two strings"],
+         "answer": "B. Joins elements of a list into a string"},
+        {"question": "What does `list.pop()` do?",
+         "options": ["A. Removes and returns the last element of the list", "B. Removes a random element", "C. Sorts the list", "D. Reverses the list"],
+         "answer": "A. Removes and returns the last element of the list"}
+    ],
+    "advanced": [
+        {"question": "What is the purpose of the `@staticmethod` decorator in Python?",
+         "options": ["A. To define a method that doesn't require an instance",
+                     "B. To define a method that can modify a class attribute",
+                     "C. To define a method that requires an instance",
+                     "D. To define a private method"],
+         "answer": "A. To define a method that doesn't require an instance"},
+        {"question": "What is the time complexity of searching for an element in a dictionary?",
+         "options": ["A. O(1)", "B. O(n)", "C. O(log n)", "D. O(n^2)"],
+         "answer": "A. O(1)"},
+        {"question": "What does the `zip()` function do in Python?",
+         "options": ["A. Combines multiple iterables element-wise",
+                     "B. Compresses a list",
+                     "C. Converts a tuple into a dictionary",
+                     "D. Creates a list of pairs from two dictionaries"],
+         "answer": "A. Combines multiple iterables element-wise"},
+        {"question": "What is the difference between `deepcopy()` and `copy()`?",
+         "options": ["A. `copy()` creates a shallow copy, `deepcopy()` creates a deep copy",
+                     "B. `copy()` is faster than `deepcopy()`",
+                     "C. `deepcopy()` is for strings only",
+                     "D. There is no difference"],
+         "answer": "A. `copy()` creates a shallow copy, `deepcopy()` creates a deep copy"},
+        {"question": "What does the `yield` keyword do?",
+         "options": ["A. Returns multiple values from a function",
+                     "B. Converts a function into a generator",
+                     "C. Pauses a function and resumes it later",
+                     "D. Both B and C"],
+         "answer": "D. Both B and C"}
+    ]
+}