one q only

app.py

@@ -96,28 +96,15 @@ def create_latex_document(content, questions_only=False):
 \usepackage{amsmath,amssymb}
 \usepackage[margin=1in]{geometry}
 \begin{document}
-\title{Mathematics Test}
+\title{Mathematics Question}
 \maketitle
 """
         latex_footer = r"\end{document}"
         
         if questions_only:
-            processed_content = []
-            current_question = []
-            for line in content.split('\n'):
-                if 'Solution:' in line:
-                    processed_content.append('\n'.join(current_question))
-                    current_question = []
-                    continue
-                if any(line.startswith(f"{i})") for i in range(1, 4)):
-                    if current_question:
-                        processed_content.append('\n'.join(current_question))
-                    current_question = [line]
-                elif current_question:
-                    current_question.append(line)
-            if current_question:
-                processed_content.append('\n'.join(current_question))
-            content = '\n\n'.join(processed_content)
+            # Modified to handle single question
+            processed_content = content.split('Solution:')[0]
+            content = processed_content
         
         full_document = f"{latex_header}\n{content}\n{latex_footer}"
         logger.debug(f"Created {'questions-only' if questions_only else 'full'} LaTeX document")
@@ -129,52 +116,24 @@ def create_latex_document(content, questions_only=False):
 def save_to_temp_file(content, filename):
     """Save content to a temporary file and return the path"""
     try:
-        # Create a temporary directory that persists
         temp_dir = Path(tempfile.gettempdir()) / "math_test_files"
         temp_dir.mkdir(exist_ok=True)
-        
-        # Create the file path
         file_path = temp_dir / filename
-        
-        # Write the content
         file_path.write_text(content, encoding='utf-8')
-        
         logger.debug(f"Saved content to temporary file: {file_path}")
         return str(file_path)
     except Exception as e:
         logger.error(f"Error saving temporary file: {str(e)}")
         raise
 
-def validate_question_counts(computation, proof, application):
-    """Validate that question counts sum to 3"""
+def generate_question(subject, difficulty, question_type):
+    """Generate a single math question"""
     try:
-        comp = int(computation)
-        prf = int(proof)
-        app = int(application)
-        
-        if comp + prf + app != 3:
-            return False, "Total number of questions must equal 3"
-        if any(x < 0 for x in [comp, prf, app]):
-            return False, "Question counts cannot be negative"
-        return True, ""
-    except ValueError:
-        return False, "Please enter valid numbers"
-
-def generate_test(subject, difficulty, computation_count, proof_count, application_count):
-    """Generate a math test with enhanced difficulty scaling"""
-    try:
-        # Validate inputs
-        is_valid, error_message = validate_question_counts(
-            computation_count, proof_count, application_count
-        )
-        if not is_valid:
-            return error_message, None, None
-            
         if not os.environ.get('ANTHROPIC_API_KEY'):
             logger.error("Anthropic API key not found")
             return "Error: Anthropic API key not configured", None, None
         
-        logger.debug(f"Generating test for subject: {subject} at difficulty level: {difficulty}")
+        logger.debug(f"Generating {question_type} question for subject: {subject} at difficulty level: {difficulty}")
         
         # Check rate limit
         now = datetime.now()
@@ -191,29 +150,18 @@ def generate_test(subject, difficulty, computation_count, proof_count, applicati
             "Linear Algebra": ["matrices", "vector spaces", "eigenvalues", "linear transformations"],
         }
         
-        selected_topics = random.sample(topics.get(subject, ["general"]), min(3, len(topics.get(subject, ["general"]))))
-        logger.debug(f"Selected topics: {selected_topics}")
-
-        # Create question type list based on user input
-        question_types = (
-            ["computation"] * int(computation_count) +
-            ["proof"] * int(proof_count) +
-            ["application"] * int(application_count)
-        )
+        selected_topic = random.choice(topics.get(subject, ["general"]))
+        logger.debug(f"Selected topic: {selected_topic}")
         
         difficulty_params = get_difficulty_parameters(difficulty)
         
         # Enhanced prompt for difficulty level 5
         if difficulty == 5:
-            system_prompt = f"""You are an expert mathematics professor creating graduate-level exam questions.
-
+            system_prompt = f"""You are an expert mathematics professor creating a graduate-level exam question.
 STRICT REQUIREMENTS:
-1. Write exactly 3 graduate-level questions on {subject} with these specific characteristics:
-   - Question Types (in order): {', '.join(question_types)}
-   - Topics to cover: {', '.join(selected_topics)}
-
+1. Write exactly 1 graduate-level {question_type} question on {subject} covering {selected_topic}.
 2. Advanced Difficulty Requirements:
-   These questions must be suitable for PhD qualifying exams or advanced competitions.
+   This question must be suitable for PhD qualifying exams or advanced competitions.
    MUST include:
    - Novel applications of theoretical concepts
    - Graduate-level mathematical reasoning
@@ -223,50 +171,37 @@ STRICT REQUIREMENTS:
    
    Follow these specific constraints:
    {chr(10).join(f'   - {c}' for c in difficulty_params['constraints'])}
-
 3. Style Reference:
-   Questions should be {difficulty_params['example_style']}
-
-4. Each question MUST:
+   Question should be {difficulty_params['example_style']}
+4. The question MUST:
    - Bridge multiple mathematical domains
    - Require deep theoretical understanding
    - Test mastery of advanced concepts
    - Demand innovative solution approaches
-
 5. For LaTeX formatting:
    - Use $ for inline math
    - Use $$ on separate lines for equations and solutions
    - Put each solution step on its own line in $$ $$
    - DO NOT use \\begin{{aligned}} or similar environments
-
-6. Number questions as 1), 2), 3)
-7. Include detailed solutions with thorough explanations of advanced concepts used
-8. Maintain clear, precise formatting"""
+6. Include a detailed solution with thorough explanations of advanced concepts used
+7. Maintain clear, precise formatting"""
         else:
-            system_prompt = f"""You are an expert mathematics professor creating {difficulty_params['description']} exam questions.
-
+            system_prompt = f"""You are an expert mathematics professor creating a {difficulty_params['description']} exam question.
 STRICT REQUIREMENTS:
-1. Write exactly 3 university-level questions on {subject} with these specific characteristics:
-   - Question Types (in order): {', '.join(question_types)}
-   - Topics to cover: {', '.join(selected_topics)}
-
+1. Write exactly 1 {question_type} question on {subject} covering {selected_topic}.
 2. Difficulty Level Guidelines:
    {difficulty_params['description'].upper()}
    Follow these specific constraints:
    {chr(10).join(f'   - {c}' for c in difficulty_params['constraints'])}
-
 3. Style Reference:
-   Questions should be {difficulty_params['example_style']}
-
+   Question should be {difficulty_params['example_style']}
 4. For LaTeX formatting:
    - Use $ for inline math
    - Use $$ on separate lines for equations and solutions
    - Put each solution step on its own line in $$ $$
    - DO NOT use \\begin{{aligned}} or similar environments
-
-5. Number questions as 1), 2), 3)
-6. Include detailed solutions
-7. Maintain clear formatting"""
+5. Include a detailed solution
+6. Maintain clear formatting"""
         
         logger.debug("Sending request to Anthropic API")
         message = anthropic.messages.create(
@@ -275,7 +210,7 @@ STRICT REQUIREMENTS:
             temperature=0.7,
             messages=[{
                 "role": "user",
-                "content": f"{system_prompt}\n\nWrite an exam for {subject}."
+                "content": f"{system_prompt}\n\nWrite a question for {subject}."
             }]
         )
         
@@ -291,22 +226,22 @@ STRICT REQUIREMENTS:
         full_latex = create_latex_document(response_text, questions_only=False)
         
         # Save to temporary files
-        questions_path = save_to_temp_file(questions_latex, "questions.tex")
-        full_path = save_to_temp_file(full_latex, "full_test.tex")
+        questions_path = save_to_temp_file(questions_latex, "question.tex")
+        full_path = save_to_temp_file(full_latex, "full_question.tex")
         
         logger.debug("Successfully created temporary files")
         
         return response_text, questions_path, full_path
             
     except Exception as e:
-        logger.error(f"Error generating test: {str(e)}")
+        logger.error(f"Error generating question: {str(e)}")
         return f"Error: {str(e)}", None, None
 
 # Create Gradio interface
 with gr.Blocks() as interface:
-    gr.Markdown("# Advanced Mathematics Test Generator")
-    gr.Markdown("""Generates unique university-level mathematics exam questions with solutions using Claude 3.
-    Each test features different topics and difficulty levels. Limited to 25 requests per day.""")
+    gr.Markdown("# Advanced Mathematics Question Generator")
+    gr.Markdown("""Generates a unique university-level mathematics question with solution using Claude 3.
+    Each question features different topics and difficulty levels. Limited to 25 requests per day.""")
     
     with gr.Row():
         with gr.Column():
@@ -324,7 +259,7 @@ with gr.Blocks() as interface:
                     "Topology"
                 ],
                 label="Select Mathematics Subject",
-                info="Choose a subject for the exam questions"
+                info="Choose a subject for the question"
             )
             
             difficulty_slider = gr.Slider(
@@ -335,32 +270,18 @@ with gr.Blocks() as interface:
                 label="Difficulty Level",
                 info="1: Very Easy, 2: Easy, 3: Moderate, 4: Difficult, 5: Very Difficult"
             )
-    
-    with gr.Row():
-        with gr.Column():
-            computation_count = gr.Number(
-                value=1,
-                label="Number of Computation Questions",
-                info="Enter the number of computation questions (total must be 3)",
-                precision=0
-            )
-            proof_count = gr.Number(
-                value=1,
-                label="Number of Proof Questions",
-                info="Enter the number of proof questions (total must be 3)",
-                precision=0
-            )
-            application_count = gr.Number(
-                value=1,
-                label="Number of Application Questions",
-                info="Enter the number of application questions (total must be 3)",
-                precision=0
+            
+            question_type = gr.Radio(
+                choices=["computation", "proof", "application"],
+                label="Question Type",
+                info="Select the type of question you want",
+                value="computation"
             )
     
-    generate_btn = gr.Button("Generate Test")
+    generate_btn = gr.Button("Generate Question")
     
     output_text = gr.Markdown(
-        label="Generated Test Preview",
+        label="Generated Question Preview",
         latex_delimiters=[
             {"left": "$$", "right": "$$", "display": True},
             {"left": "$", "right": "$", "display": False}
@@ -368,17 +289,15 @@ with gr.Blocks() as interface:
     )
     
     with gr.Row():
-        questions_file = gr.File(label="Questions Only (LaTeX)")
-        full_file = gr.File(label="Full Test with Solutions (LaTeX)")
+        questions_file = gr.File(label="Question Only (LaTeX)")
+        full_file = gr.File(label="Question with Solution (LaTeX)")
     
     generate_btn.click(
-        generate_test,
+        generate_question,
         inputs=[
             subject_dropdown,
             difficulty_slider,
-            computation_count,
-            proof_count,
-            application_count
+            question_type
         ],
         outputs=[output_text, questions_file, full_file]
     )