Upload 5 files

Dockerfile (1)

@@ -0,0 +1,37 @@
+# FROM python:3.9-slim
+
+# WORKDIR /app
+
+# # Install system dependencies
+# RUN apt-get update && apt-get install -y \
+#     build-essential \
+#     && rm -rf /var/lib/apt/lists/*
+
+# # Copy and install requirements
+# COPY requirements.txt .
+# RUN pip install --no-cache-dir -r requirements.txt
+
+# # Copy application files
+# COPY . .
+
+# # Expose ports for both FastAPI and Gradio
+# EXPOSE 7860
+# EXPOSE 8000
+
+# # Run the combined application
+# CMD ["python", "app.py"]
+
+
+FROM python:3.9
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,99 @@
----
-title: TestSeriesAITestScheduler
-emoji: 🌖
-colorFrom: green
-colorTo: purple
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Test Creation Agent
+emoji: 📝
+colorFrom: blue
+colorTo: green
+sdk: docker
+sdk_version: latest
+app_port: 7860
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# Test Creation Agent
+
+This application provides a conversational interface to collect educational test creation parameters. It extracts details like chapters, question counts, difficulty distribution, and test timing from natural language inputs.
+
+## Features
+
+- User-friendly Gradio chat interface
+- Intelligent parameter extraction from natural language
+- Supports multiple academic subjects and chapters
+- Normalizes chapter names to standardized curriculum topics
+- Tracks conversation state and guides users through completion
+
+## Architecture
+
+The application consists of two main components:
+
+1. **FastAPI Backend**: Handles the parameter extraction and conversation logic
+2. **Gradio Frontend**: Provides the user interface for conversation
+
+## Setup
+
+### Environment Variables
+
+Create a `.env` file from the example:
+
+```bash
+cp .env.example .env
+```
+
+Edit the `.env` file and add your OpenAI API key:
+
+```
+OPENAI_API_KEY=your_openai_api_key_here
+```
+
+### Running with Docker
+
+Build and run the Docker container:
+
+```bash
+docker build -t test-creation-agent .
+docker run -p 7860:7860 -p 8000:8000 --env-file .env test-creation-agent
+```
+
+### Running Locally
+
+Install dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+Run the application:
+
+```bash
+python app.py
+```
+
+This will start both the FastAPI backend and the Gradio frontend. Access the application at http://localhost:7860.
+
+## API Endpoints
+
+The FastAPI backend provides these endpoints:
+
+- `GET /`: Check if the API is running
+- `POST /chat`: Send a user message and get a response
+  - Request body: `{"message": "string", "session_id": "string"}`
+- `GET /session/{session_id}`: Get the current state of a session
+- `DELETE /session/{session_id}`: Delete a session
+- `POST /reset`: Reset a session to start over
+  - Request body: `{"message": "", "session_id": "string"}`
+
+## Deploying to Hugging Face Spaces
+
+1. Create a new Space on Hugging Face with Docker template
+2. Link your GitHub repository or upload the files directly
+3. Set the OPENAI_API_KEY in the Space's secrets
+4. The application will be accessible at your Space's URL
+
+## Usage Example
+
+Simply open the Gradio interface and start describing your test requirements. For example:
+
+"I need a test on Thermodynamics and Electrostatics, 10 questions each, 60% medium, 20% easy, 20% hard, 90 minutes, on May 15, 2025 at 10 AM"
+
+The agent will extract the parameters, normalize chapter names, and either ask for missing information or confirm when all parameters are collected.

app (1).py

@@ -0,0 +1,385 @@
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+import openai
+import os
+import json
+import re
+from typing import Dict, List, Optional, Tuple, Any
+
+app = FastAPI(title="TestCreationAgent", 
+              description="An API for collecting test creation parameters through conversation")
+
+# Add CORS middleware to allow requests from frontend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Allows all origins
+    allow_credentials=True,
+    allow_methods=["*"],  # Allows all methods
+    allow_headers=["*"],  # Allows all headers
+)
+
+# Define subject chapters mapping
+SUBJECT_CHAPTERS = {
+    "Mathematics": [
+        "Number Systems", "Polynomials", "Coordinate Geometry", "Linear Equations in Two Variables",
+        "Introduction to Euclid's Geometry", "Lines and Angles", "Triangles", "Quadrilaterals",
+        "Areas of Parallelograms and Triangles", "Circles", "Constructions", "Heron's Formula",
+        "Surface Areas and Volumes", "Statistics", "Probability", "Real Numbers",
+        "Pair of Linear Equations in Two Variables", "Quadratic Equations", "Arithmetic Progressions",
+        "Introduction to Trigonometry", "Some Applications of Trigonometry", "Areas Related to Circles",
+        "Sets", "Relations and Functions", "Trigonometric Functions", "Principle of Mathematical Induction",
+        "Complex Numbers and Quadratic Equations", "Linear Inequalities", "Permutations and Combinations",
+        "Binomial Theorem", "Sequences and Series", "Straight Lines", "Conic Sections",
+        "Introduction to Three Dimensional Geometry", "Limits and Derivatives",
+        "Inverse Trigonometric Functions", "Matrices", "Determinants",
+        "Continuity and Differentiability", "Application of Derivatives", "Integrals",
+        "Application of Integrals", "Differential Equations", "Vector Algebra",
+        "Three Dimensional Geometry", "Linear Programming"
+    ],
+    "Physics": [
+        "Motion", "Force and Laws of Motion", "Gravitation", "Work and Energy", "Sound",
+        "Light: Reflection and Refraction", "Human Eye and Colourful World", "Electricity",
+        "Magnetic Effects of Electric Current", "Physical World and Measurement", "Kinematics",
+        "Laws of Motion", "Work, Energy and Power", "Motion of System of Particles and Rigid Body",
+        "Properties of Bulk Matter", "Thermodynamics", "Behaviour of Perfect Gases and Kinetic Theory",
+        "Oscillations and Waves", "Electrostatics", "Current Electricity",
+        "Magnetic Effects of Current and Magnetism", "Electromagnetic Induction and Alternating Currents",
+        "Electromagnetic Waves", "Optics", "Dual Nature of Radiation and Matter", "Atoms", "Nuclei",
+        "Semiconductor Electronics: Materials, Devices and Simple Circuits", "Vectors"
+    ],
+    "Chemistry": [
+        "Matter in Our Surroundings", "Is Matter Around Us Pure?", "Atoms and Molecules",
+        "Structure of the Atom", "Chemical Reactions and Equations", "Acids, Bases and Salts",
+        "Metals and Non-metals", "Carbon and Its Compounds", "Periodic Classification of Elements",
+        "Some Basic Concepts of Chemistry", "Structure of Atom",
+        "Classification of Elements and Periodicity in Properties",
+        "Chemical Bonding and Molecular Structure", "States of Matter: Gases and Liquids",
+        "Thermodynamics", "Equilibrium", "Redox Reactions",
+        "Organic Chemistry: Some Basic Principles and Techniques", "Hydrocarbons",
+        "Environmental Chemistry", "Solid State", "Solutions", "Electrochemistry",
+        "Chemical Kinetics", "Surface Chemistry", "General Principles and Processes of Isolation of Elements",
+        "p-Block Elements", "d- and f-Block Elements", "Coordination Compounds",
+        "Haloalkanes and Haloarenes", "Alcohols, Phenols and Ethers",
+        "Aldehydes, Ketones and Carboxylic Acids", "Amines", "Biomolecules", "Polymers",
+        "Chemistry in Everyday Life"
+    ],
+    "Organic Chemistry": [
+        "Organic Chemistry: Some Basic Principles and Techniques", "Hydrocarbons",
+        "Haloalkanes and Haloarenes", "Alcohols, Phenols and Ethers",
+        "Aldehydes, Ketones and Carboxylic Acids", "Amines", "Biomolecules",
+        "Polymers", "Chemistry in Everyday Life"
+    ],
+    "Inorganic Chemistry": [
+        "Classification of Elements and Periodicity in Properties",
+        "Chemical Bonding and Molecular Structure", "Redox Reactions",
+        "p-Block Elements", "d- and f-Block Elements", "Coordination Compounds"
+    ]
+}
+
+# Create a flat mapping of misspelled/approximate chapter names to correct ones
+CHAPTER_MAPPING = {}
+for subject, chapters in SUBJECT_CHAPTERS.items():
+    for chapter in chapters:
+        # Add the correct chapter name
+        CHAPTER_MAPPING[chapter.lower()] = (subject, chapter)
+
+        # Add common misspellings/variations
+        if chapter.lower() == "thermodynamics":
+            CHAPTER_MAPPING["termodyanamics"] = (subject, chapter)
+            CHAPTER_MAPPING["termodyn"] = (subject, chapter)
+            CHAPTER_MAPPING["thermo"] = (subject, chapter)
+            CHAPTER_MAPPING["thermodynamic"] = (subject, chapter)
+
+
+class UserInput(BaseModel):
+    message: str
+    session_id: str
+
+
+class SessionState(BaseModel):
+    params: Dict[str, str] = {
+        "chapters_of_the_test": "",
+        "questions_per_chapter": "",
+        "difficulty_distribution": "",
+        "test_duration": "",
+        "test_date": "",
+        "test_time": ""
+    }
+    completed: bool = False
+    attempt_count: int = 0
+
+
+# In-memory session storage
+sessions = {}
+
+
+def normalize_chapter_name(chapter_input: str) -> Optional[Tuple[str, str]]:
+    """
+    Maps user input to standardized chapter names from the curriculum.
+    Returns tuple of (subject, correct_chapter_name) or None if no match.
+    """
+    if not chapter_input:
+        return None
+
+    # Direct mapping for exact matches or known misspellings
+    norm_input = chapter_input.lower().strip()
+    if norm_input in CHAPTER_MAPPING:
+        return CHAPTER_MAPPING[norm_input]
+
+    # Try fuzzy matching if no direct match
+    # Look for partial matches
+    for chapter_key, (subject, correct_name) in CHAPTER_MAPPING.items():
+        if norm_input in chapter_key or chapter_key in norm_input:
+            return (subject, correct_name)
+
+    # No match found
+    return None
+
+
+async def llm_extractParams(user_input: str, current_params: Dict[str, str]) -> Dict[str, str]:
+    """
+    Extracts structured test parameters from natural language input
+    and updates the provided params dictionary.
+    """
+    system_prompt = """
+You are an expert educational test creation assistant that extracts test setup parameters from user input.
+Extract ONLY the parameters explicitly mentioned in the user's message.
+
+Return a JSON object with all the following keys:
+- chapters_of_the_test (string: list of chapters or topics)
+- questions_per_chapter (string or number: how many questions per chapter)
+- difficulty_distribution (string: e.g., "easy:40%, medium:40%, hard:20%" or any format specified)
+- test_duration (string or number: time in minutes)
+- test_date (string: in any reasonable date format)
+- test_time (string: time of day)
+
+Important rules:
+- Do NOT make assumptions - if information isn't provided, leave as empty string ("")
+- Only fill in values explicitly mentioned by the user
+- For difficulty_distribution:
+  * Convert numeric sequences like "30 40 30" to "easy:30%, medium:40%, hard:30%" if they appear to be distributions
+  * Convert descriptions like "mostly hard" to approximate percentages (e.g., "easy:20%, medium:20%, hard:60%")
+  * Accept formats like "60 easy, 20 medium, 20 hard" and convert to percentages
+- Return valid JSON with all keys, even if empty
+"""
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": user_input}
+    ]
+
+    try:
+        response = openai.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=messages,
+            temperature=0.2
+        )
+
+        extracted_json = response.choices[0].message.content.strip()
+
+        # Handle potential JSON formatting issues by extracting JSON from response
+        if not extracted_json.startswith('{'):
+            # Find JSON object in text if it's not a clean JSON response
+            start_idx = extracted_json.find('{')
+            end_idx = extracted_json.rfind('}') + 1
+            if start_idx >= 0 and end_idx > start_idx:
+                extracted_json = extracted_json[start_idx:end_idx]
+            else:
+                raise ValueError("Unable to extract valid JSON from response")
+
+        # Parse and update the current_params safely
+        extracted_dict = json.loads(extracted_json)
+        updated_params = current_params.copy()
+        
+        for key in updated_params:
+            if key.lower() in extracted_dict and extracted_dict[key.lower()]:
+                updated_params[key] = extracted_dict[key.lower()]
+            elif key in extracted_dict and extracted_dict[key]:
+                updated_params[key] = extracted_dict[key]
+
+        # Apply chapter mapping if chapters were specified
+        if updated_params["chapters_of_the_test"] and updated_params["chapters_of_the_test"] != current_params["chapters_of_the_test"]:
+            chapters_input = updated_params["chapters_of_the_test"]
+            # Split multiple chapters if comma-separated
+            chapter_list = [ch.strip() for ch in re.split(r',|;', chapters_input)]
+
+            mapped_chapters = []
+            for chapter in chapter_list:
+                result = normalize_chapter_name(chapter)
+                if result:
+                    subject, correct_name = result
+                    mapped_chapters.append(f"{correct_name} ({subject})")
+                else:
+                    mapped_chapters.append(chapter)  # Keep as-is if no mapping found
+
+            updated_params["chapters_of_the_test"] = ", ".join(mapped_chapters)
+
+        return updated_params
+
+    except json.JSONDecodeError as e:
+        print(f"Error: Could not parse response as JSON: {e}")
+        return current_params
+    except Exception as e:
+        print(f"Error during parameter extraction: {e}")
+        return current_params
+
+
+def gate(params: Dict[str, str]) -> List[str]:
+    """
+    Checks which fields are still empty in the params.
+    Returns a list of missing parameter keys.
+    """
+    return [key for key, val in params.items() if not val]
+
+
+async def llm_getMissingParams(missing_keys: List[str]) -> str:
+    """
+    Generates a human-readable prompt to ask user for missing fields.
+    """
+    # Create context-aware prompts for specific missing fields
+    context_details = {
+        "chapters_of_the_test": "such as Math, Science, History, etc.",
+        "questions_per_chapter": "the number of questions for each chapter",
+        "difficulty_distribution": "as percentages or numbers (easy, medium, hard)",
+        "test_duration": "in minutes",
+        "test_date": "when the test will be given",
+        "test_time": "the time of day for the test"
+    }
+
+    # Create a more specific prompt based on what's missing
+    if len(missing_keys) == 1:
+        key = missing_keys[0]
+        prompt = f"Please provide the {key.replace('_', ' ')} {context_details.get(key, '')}."
+    else:
+        formatted_missing = [f"{key.replace('_', ' ')} ({context_details.get(key, '')})" for key in missing_keys]
+        prompt = f"The following test details are still needed: {', '.join(formatted_missing)}."
+
+    messages = [
+        {"role": "system", "content": "You are a helpful assistant who creates clear, concise questions to collect missing test setup information. Keep your response under 2 sentences and focus only on what's missing."},
+        {"role": "user", "content": prompt}
+    ]
+
+    try:
+        response = openai.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=messages,
+            temperature=0.3
+        )
+        return response.choices[0].message.content.strip()
+    except Exception as e:
+        print(f"Error generating prompt for missing values: {e}")
+        return f"Please provide the following missing information: {', '.join(missing_keys)}."
+
+
+@app.on_event("startup")
+async def startup_event():
+    # Set up OpenAI API key from environment variable
+    openai.api_key = os.getenv("OPENAI_API_KEY")
+    if not openai.api_key:
+        print("⚠️ WARNING: OPENAI_API_KEY environment variable not set.")
+
+
+@app.get("/")
+async def root():
+    return {"message": "Test Creation Agent API is running"}
+
+
+@app.post("/chat")
+async def chat(user_input: UserInput):
+    session_id = user_input.session_id
+    
+    # Initialize session if it doesn't exist
+    if session_id not in sessions:
+        sessions[session_id] = SessionState()
+    
+    session = sessions[session_id]
+    
+    # If this is the first message, send a welcome message
+    if session.attempt_count == 0:
+        session.attempt_count += 1
+        return {
+            "response": "👋 Welcome! Please provide the test setup details. I need: chapters, questions per chapter, difficulty distribution, test duration, date, and time.",
+            "session_state": {
+                "params": session.params,
+                "completed": False
+            }
+        }
+    
+    # Process user input to extract parameters
+    session.params = await llm_extractParams(user_input.message, session.params)
+    session.attempt_count += 1
+    
+    # Check if we have all required parameters
+    missing = gate(session.params)
+    
+    # If we have all parameters or exceeded max attempts, return completion
+    max_attempts = 10
+    if not missing or session.attempt_count > max_attempts:
+        session.completed = True
+        if not missing:
+            result = "✅ All test parameters are now complete:"
+        else:
+            result = "⚠️ Some parameters could not be filled after multiple attempts:"
+        
+        # Format the parameters as a readable string
+        for k, v in session.params.items():
+            result += f"\n- {k.replace('_', ' ').title()}: {v or 'Not provided'}"
+        
+        return {
+            "response": result,
+            "session_state": {
+                "params": session.params,
+                "completed": True
+            }
+        }
+    
+    # Otherwise, ask for missing parameters
+    follow_up_prompt = await llm_getMissingParams(missing)
+    
+    return {
+        "response": follow_up_prompt,
+        "session_state": {
+            "params": session.params,
+            "completed": False
+        }
+    }
+
+
+@app.get("/session/{session_id}")
+async def get_session(session_id: str):
+    if session_id not in sessions:
+        raise HTTPException(status_code=404, detail="Session not found")
+    
+    session = sessions[session_id]
+    return {
+        "params": session.params,
+        "completed": session.completed,
+        "attempt_count": session.attempt_count
+    }
+
+
+@app.delete("/session/{session_id}")
+async def delete_session(session_id: str):
+    if session_id in sessions:
+        del sessions[session_id]
+    return {"message": "Session deleted successfully"}
+
+
+@app.post("/reset")
+async def reset_session(user_input: UserInput):
+    session_id = user_input.session_id
+    sessions[session_id] = SessionState()
+    
+    return {
+        "response": "Session reset. 👋 Welcome! Please provide the test setup details. I need: chapters, questions per chapter, difficulty distribution, test duration, date, and time.",
+        "session_state": {
+            "params": sessions[session_id].params,
+            "completed": False
+        }
+    }
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("app:app", host="0.0.0.0", port=int(os.getenv("PORT", 8000)), reload=True)

gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

requirements (1).txt

@@ -0,0 +1,6 @@
+fastapi==0.103.1
+uvicorn==0.23.2
+openai==1.6.1
+pydantic==2.3.0
+python-dotenv==1.0.0
+gunicorn==21.2.0