Spaces:
Sleeping
Sleeping
| import streamlit as st | |
| import openai | |
| from openai import OpenAI | |
| import time | |
| import gspread | |
| from oauth2client.service_account import ServiceAccountCredentials | |
| # Set up OpenAI client | |
| client = OpenAI(api_key=st.secrets["OPENAI_API_KEY"]) | |
| # Google Sheets setup remains the same | |
| scope = ["https://spreadsheets.google.com/feeds", "https://www.googleapis.com/auth/drive"] | |
| creds = ServiceAccountCredentials.from_json_keyfile_name("genexam-2c8c645ecc0d.json", scope) | |
| client_gs = gspread.authorize(creds) | |
| sheet = client_gs.open("GeneXam user").sheet1 | |
| def check_user_in_sheet(username): | |
| try: | |
| users_list = sheet.col_values(1) | |
| if username in users_list: | |
| return True | |
| return False | |
| except Exception as e: | |
| st.error(f"Error checking user: {str(e)}") | |
| return False | |
| def update_api_usage(username): | |
| try: | |
| users_list = sheet.col_values(1) | |
| row_number = users_list.index(username) + 1 | |
| api_usage = int(sheet.cell(row_number, 2).value) | |
| api_usage += 1 | |
| sheet.update_cell(row_number, 2, api_usage) | |
| except Exception as e: | |
| st.error(f"Error updating API usage: {str(e)}") | |
| def generate_questions_with_retry(knowledge_material, question_type, cognitive_level, extra_instructions, case_based, num_choices=None, max_retries=3): | |
| # Adjust number of questions based on type | |
| if question_type == "Multiple Choice": | |
| num_questions = 3 | |
| format_instructions = f""" | |
| For each multiple choice question: | |
| 1. Present the question clearly | |
| 2. Provide {num_choices} choices labeled with A, B, C{', D' if num_choices > 3 else ''}{', E' if num_choices > 4 else ''} | |
| 3. After all questions, provide an ANSWER KEY section with: | |
| - The correct answer letter for each question | |
| - A brief explanation of why this is the correct answer | |
| - Why other options are incorrect | |
| """ | |
| elif question_type == "Fill in the Blank": | |
| num_questions = 10 | |
| format_instructions = """ | |
| For each fill-in-the-blank question: | |
| 1. Present the question with a clear blank space indicated by _____ | |
| 2. After all questions, provide an ANSWER KEY section with: | |
| - The correct answer for each blank | |
| - A brief explanation of why this answer is correct | |
| - Any alternative acceptable answers if applicable | |
| """ | |
| elif question_type == "True/False": | |
| num_questions = 5 | |
| format_instructions = """ | |
| For each true/false question: | |
| 1. Present the statement clearly | |
| 2. After all questions, provide an ANSWER KEY section with: | |
| - Whether the statement is True or False | |
| - A detailed explanation of why the statement is true or false | |
| - The specific part of the source material that supports this answer | |
| """ | |
| else: # Open-ended | |
| num_questions = 3 | |
| format_instructions = """ | |
| For each open-ended question: | |
| 1. Present the question clearly | |
| 2. After all questions, provide an ANSWER KEY section with: | |
| - A structured scoring checklist of key points (minimum 3-5 points per question) | |
| - Each key point should be worth a specific number of marks | |
| - Total marks available for each question | |
| - Sample answer that would receive full marks | |
| - Common points that students might miss | |
| """ | |
| # Base prompt | |
| prompt = f"""Generate {num_questions} {question_type.lower()} exam questions based on {cognitive_level.lower()} level from the following material: | |
| {knowledge_material} | |
| {format_instructions} | |
| {extra_instructions} | |
| Please format the output clearly with: | |
| 1. Questions section (numbered 1, 2, 3, etc.) | |
| 2. Answer Key section (clearly separated from questions) | |
| 3. Each answer should include explanation for better understanding | |
| Make sure all questions and answers are directly related to the provided material.""" | |
| # Modify prompt for case-based medical situations | |
| if case_based: | |
| prompt = f"""Generate {num_questions} {question_type.lower()} case-based medical exam questions based on {cognitive_level.lower()} level. | |
| Use this material as the medical knowledge base: | |
| {knowledge_material} | |
| Each question should: | |
| 1. Start with a medical case scenario/patient presentation | |
| 2. Include relevant clinical details | |
| 3. Ask about diagnosis, treatment, or management | |
| 4. Be at {cognitive_level.lower()} cognitive level | |
| {format_instructions} | |
| {extra_instructions} | |
| Please format the output with: | |
| 1. Cases and Questions (numbered 1, 2, 3, etc.) | |
| 2. Detailed Answer Key section including: | |
| - Correct answers | |
| - Clinical reasoning | |
| - Key diagnostic or treatment considerations | |
| - Common pitfalls to avoid""" | |
| retries = 0 | |
| while retries < max_retries: | |
| try: | |
| response = client.chat.completions.create( | |
| model="gpt-4o-mini", | |
| messages=[ | |
| {"role": "system", "content": "You are an expert exam question generator with deep knowledge in medical education. Create clear, well-structured questions with detailed answer keys and explanations."}, | |
| {"role": "user", "content": prompt} | |
| ], | |
| temperature=0.7, | |
| max_tokens=3000 # Increased to accommodate answers and explanations | |
| ) | |
| return response.choices[0].message.content | |
| except Exception as e: | |
| retries += 1 | |
| st.warning(f"Attempt {retries} failed. Retrying... Error: {str(e)}") | |
| if retries == max_retries: | |
| st.error(f"Failed to generate questions after {max_retries} attempts. Error: {str(e)}") | |
| return None | |
| time.sleep(2) | |
| # ระบบ login | |
| if 'username' not in st.session_state: | |
| st.title("Login") | |
| username_input = st.text_input("Enter your username:") | |
| if st.button("Login"): | |
| if username_input: | |
| if check_user_in_sheet(username_input): | |
| st.session_state['username'] = username_input | |
| st.success(f"Welcome, {username_input}!") | |
| update_api_usage(username_input) | |
| else: | |
| st.warning("Username not found. Please try again.") | |
| else: | |
| st.warning("Please enter a valid username.") | |
| else: | |
| # Main App after login | |
| st.title(f"Welcome, {st.session_state['username']}! Generate your exam questions") | |
| # Input field for knowledge material (text) with 3,000-word limit | |
| knowledge_material = st.text_area("Enter knowledge material to generate exam questions:") | |
| # Word count check | |
| if len(knowledge_material.split()) > 3000: | |
| st.warning("Please limit the knowledge material to 3,000 words or fewer.") | |
| # File uploader for PDFs (limited to 5 MB) | |
| uploaded_file = st.file_uploader("Upload a file (PDF)", type="pdf") | |
| if uploaded_file is not None: | |
| if uploaded_file.size > 5 * 1024 * 1024: # 5 MB limit | |
| st.warning("File size exceeds 5 MB. Please upload a smaller file.") | |
| else: | |
| st.success("File uploaded successfully! (Text extraction not implemented yet.)") | |
| # Select question type | |
| question_type = st.selectbox("Select question type:", | |
| ["Multiple Choice", "Fill in the Blank", "Open-ended", "True/False"]) | |
| # For multiple choice, let users select the number of choices | |
| num_choices = None | |
| if question_type == "Multiple Choice": | |
| num_choices = st.selectbox("Select the number of choices for each question:", [3, 4, 5]) | |
| # Select cognitive level | |
| cognitive_level = st.selectbox("Select cognitive level:", | |
| ["Recall", "Understanding", "Application", "Analysis", "Synthesis", "Evaluation"]) | |
| # Checkbox for Case-Based Medical Situations | |
| case_based = st.checkbox("Generate case-based medical exam questions") | |
| # Extra input field for additional instructions (placed below cognitive level) | |
| extra_instructions = st.text_area("Enter additional instructions (e.g., how you want the questions to be phrased):") | |
| # Generate questions button | |
| if 'previous_questions' not in st.session_state: | |
| st.session_state['previous_questions'] = [] | |
| if st.button("Generate Questions"): | |
| if len(knowledge_material.split()) <= 3000: | |
| # Generate questions with retry logic | |
| questions = generate_questions_with_retry( | |
| knowledge_material, | |
| question_type, | |
| cognitive_level, | |
| extra_instructions, | |
| case_based, | |
| num_choices | |
| ) | |
| if questions: | |
| st.write("Generated Exam Questions:") | |
| st.write(questions) | |
| # Avoid showing repeated content in future requests | |
| st.session_state['previous_questions'].append(questions) | |
| # Option to download the questions as a text file | |
| st.download_button( | |
| label="Download Questions", | |
| data=questions, | |
| file_name='generated_questions.txt', | |
| mime='text/plain' | |
| ) | |
| else: | |
| st.warning("Please reduce the word count to 3,000 or fewer.") | |
| # Button to generate more questions based on the same material | |
| if st.button("Generate More Questions"): | |
| if len(knowledge_material.split()) <= 3000: | |
| # Regenerate new questions, trying to avoid repeated content | |
| questions = generate_questions_with_retry( | |
| knowledge_material, | |
| question_type, | |
| cognitive_level, | |
| extra_instructions, | |
| case_based, | |
| num_choices | |
| ) | |
| # Check if the new set of questions is not the same as the previous set | |
| if questions and questions not in st.session_state['previous_questions']: | |
| st.write("Generated More Exam Questions:") | |
| st.write(questions) | |
| # Append the new questions to the session state | |
| st.session_state['previous_questions'].append(questions) | |
| # Option to download the new set of questions | |
| st.download_button( | |
| label="Download More Questions", | |
| data=questions, | |
| file_name='more_generated_questions.txt', | |
| mime='text/plain' | |
| ) | |
| else: | |
| st.warning("New questions seem to overlap with the previous ones. Try adjusting the instructions.") | |
| else: | |
| st.warning("Please reduce the word count to 3,000 or fewer.") | |