Update app.py

app.py

@@ -1,114 +1,133 @@
 import gradio as gr
 from huggingface_hub import InferenceClient
+import tempfile
 
 # Initialize the Hugging Face Inference Client
 client = InferenceClient()
 
-# Function to stream content for Math, STEM, and Code Generation
-def generate_stream(selected_topic, subtopic, input_text, examples_count):
+# Function to generate dynamic lessons, examples, or code
+def generate_content(selected_topic, subtopic, complexity, input_text, examples_count, output_type):
     """
-    Generates dynamic lessons, solutions, or code snippets based on the selected topic.
+    Generate content dynamically based on user input.
 
     Args:
-        selected_topic (str): The selected subject (e.g., Math, STEM, or Code Generation).
-        subtopic (str): Specific subtopic or category for more focused output.
-        input_text (str): Additional input for contextual content generation.
+        selected_topic (str): Topic selected by the user.
+        subtopic (str): Specific subtopic for generation.
+        complexity (str): User expertise level.
+        input_text (str): Additional input context.
         examples_count (int): Number of examples to generate.
+        output_type (str): Desired output format.
 
-    Yields:
-        str: Incremental output content.
+    Returns:
+        str or dict: Generated content in the selected format.
     """
-    # Create a topic-specific prompt
+    # Build the prompt dynamically
     prompt = (
-        f"Generate {examples_count} detailed {selected_topic.lower()} examples, lessons, or problems "
-        f"focused on {subtopic}. Input context: {input_text}"
-        if input_text.strip() else
-        f"Generate {examples_count} beginner-level {selected_topic.lower()} lessons or examples on {subtopic}."
+        f"Generate {examples_count} {complexity.lower()}-level {selected_topic.lower()} examples, lessons, "
+        f"or problems related to {subtopic}. Context: {input_text}" if input_text.strip()
+        else f"Generate {examples_count} {complexity.lower()}-level {selected_topic.lower()} lessons "
+             f"or problems focused on {subtopic}."
     )
     messages = [{"role": "user", "content": prompt}]
 
     try:
-        # Create a stream for generating content
-        stream = client.chat.completions.create(
-            model="Qwen/Qwen2.5-Coder-32B-Instruct",  # Streaming model
+        # Generate the content using the model
+        response = client.chat.completions.create(
+            model="Qwen/Qwen2.5-Coder-32B-Instruct",
             messages=messages,
             temperature=0.5,
             max_tokens=1024,
-            top_p=0.7,
-            stream=True
+            top_p=0.7
         )
+        content = response.choices[0].message.content
 
-        # Stream the generated content incrementally
-        generated_content = ""
-        for chunk in stream:
-            generated_content += chunk.choices[0].delta.content
-            yield generated_content  # Yield content incrementally
+        # Adjust the output based on the selected type
+        if output_type == "LaTeX":
+            return {"content": content, "latex": True}
+        elif output_type == "Downloadable":
+            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".txt")
+            with open(temp_file.name, "w") as file:
+                file.write(content)
+            return {"file": temp_file.name}
+        else:
+            return content
     except Exception as e:
-        yield f"Error: {e}"  # Display error if any issues occur
+        return f"Error: {e}"
 
 # Create the Gradio interface
 with gr.Blocks() as app:
-    # App Title and Instructions
-    gr.Markdown("## 🎓 Enhanced STEM Learning and Code Generator")
-    gr.Markdown(
-        "Generate tailored lessons, problem-solving examples, or code snippets for Math, STEM, "
-        "or Computer Science. Select a topic, subtopic, and customize your experience!"
-    )
+    # App Title
+    gr.Markdown("## 🌟 Advanced STEM and Code Generator with Interactive Features")
 
     with gr.Row():
-        # Input Section
+        # Input Panel
         with gr.Column():
             selected_topic = gr.Radio(
-                choices=["Math", "STEM", "Computer Science (Code Generation)"],
+                choices=["Math", "STEM", "Code Generation"],
                 label="Select a Topic",
-                value="Math"  # Default selection
+                value="Math"
             )
             subtopic = gr.Textbox(
-                lines=1,
                 label="Subtopic",
-                placeholder="Specify a subtopic (e.g., Algebra, Physics, Data Structures)."
+                placeholder="E.g., Algebra, Physics, Sorting Algorithms"
+            )
+            complexity = gr.Radio(
+                choices=["Beginner", "Intermediate", "Advanced"],
+                label="Expertise Level",
+                value="Beginner"
             )
             input_text = gr.Textbox(
-                lines=2,
-                label="Context or Additional Input",
-                placeholder="Provide additional context (e.g., 'Explain calculus basics' or 'Generate Python code for sorting')."
+                label="Additional Context",
+                placeholder="E.g., 'Explain integration basics' or 'Generate Python code for searching.'",
+                lines=3
             )
             examples_count = gr.Slider(
                 minimum=1,
                 maximum=5,
-                value=1,
                 step=1,
-                label="Number of Examples"
+                label="Number of Examples",
+                value=1
+            )
+            output_type = gr.Radio(
+                choices=["Plain Text", "LaTeX", "Downloadable"],
+                label="Output Format",
+                value="Plain Text"
             )
             generate_button = gr.Button("Generate Content")
 
-        # Output Section
+        # Output Panel
         with gr.Column():
-            gr.Markdown("### Generated Content")
-            output_stream = gr.Textbox(
-                lines=20,
-                label="Output",
+            gr.Markdown("### 📝 Output")
+            output = gr.Textbox(
+                label="Generated Output",
+                lines=15,
                 interactive=False
             )
-            export_button = gr.Button("Export Code (if applicable)")
+            download_button = gr.File(label="Download File (if applicable)")
 
-    # Link the generate button to the streaming function
+    # Link the generation function to the button
     generate_button.click(
-        fn=generate_stream,
-        inputs=[selected_topic, subtopic, input_text, examples_count],
-        outputs=output_stream
+        fn=generate_content,
+        inputs=[selected_topic, subtopic, complexity, input_text, examples_count, output_type],
+        outputs=[output, download_button]
+    )
+
+    # Feedback Mechanism
+    feedback_label = gr.Label(value="Was this content helpful?")
+    feedback_rating = gr.Radio(
+        choices=["Yes", "No"],
+        label="Feedback",
+        value="Yes"
     )
+    feedback_button = gr.Button("Submit Feedback")
 
-    # Export functionality for code snippets
-    def export_code(content):
-        with open("generated_code.py", "w") as file:
-            file.write(content)
-        return "Code exported successfully to generated_code.py!"
+    def collect_feedback(feedback):
+        return f"Thank you for your feedback: {feedback}"
 
-    export_button.click(
-        fn=export_code,
-        inputs=[output_stream],
-        outputs=[output_stream]
+    feedback_button.click(
+        fn=collect_feedback,
+        inputs=[feedback_rating],
+        outputs=[feedback_label]
     )
 
 # Launch the Gradio app