- Dynamic Rendering FIX !

Project.py

@@ -204,34 +204,13 @@ class Project:
             }
         )
         
-    def _clean_json_response(self, text):
-        """Helper method to clean JSON responses from LLM outputs"""
-        # If the response contains a code block with JSON
-        if "```json" in text:
-            text = text.split("```json")[1].split("```")[0].strip()
-        elif "```" in text:
-            text = text.split("```")[1].split("```")[0].strip()
-        
-        # Additional cleaning for common JSON formatting issues
-        # Remove any leading/trailing whitespace
-        text = text.strip()
-        
-        # If the text starts with a markdown comment or explanation, try to find the JSON part
-        if not text.startswith('{') and not text.startswith('['):
-            # Look for the first occurrence of { or [
-            json_start = min(
-                text.find('{') if text.find('{') != -1 else float('inf'),
-                text.find('[') if text.find('[') != -1 else float('inf')
-            )
-            if json_start != float('inf'):
-                text = text[json_start:]
-        
-        return text
-        
     ## Generate PRD and components from project details ##
-    def generate_prd_and_components(self, progress=gr.Progress()):        
-        results = set()  
-        print("\nGenerating PRD...")
+    def generate_prd_and_components(self, progress=gr.Progress()):
+        """Generate PRD and components from project details, streaming results"""
+        results = set()
+        
+        # Generate PRD
+        yield "Generating PRD...", results
         prd_response = self.execute_prompt(
             "generate_prd",
             {
@@ -241,19 +220,18 @@ class Project:
         
         # Parse the PRD JSON response
         try:
-            # Clean the JSON response first
-            cleaned_prd = self._clean_json_response(prd_response)
-            prd_json = json.loads(cleaned_prd)
+            prd_json = json.loads(prd_response)
             self.generated_prd = prd_json.get("detailed_breakdown", "")
         except json.JSONDecodeError:
             print("Warning: Could not parse PRD as JSON, using raw response")
             self.generated_prd = prd_response
             
-        # Store PRD in results as a tuple
+        # Add PRD to results and yield update
         results.add(("generate_prd", self.generated_prd))
+        yield "PRD generation complete", results
         
         try:
-            print("\nAnalyzing configuration with component agent...")
+            yield "Analyzing configuration with component agent...", results
             configuration_output = self.execute_prompt(
                 "component_agent",
                 {
@@ -261,55 +239,42 @@ class Project:
                 }
             )
             
-            # Print the raw configuration output for debugging
-            print("\nRaw configuration output:")
-            print(configuration_output)
-            
-            # Store component agent output in results as a tuple
             results.add(("component_agent", configuration_output))
+            yield "Component analysis complete", results
             
-            # Try to parse configuration output
+            # Parse configuration output
             try:
-                cleaned_output = self._clean_json_response(configuration_output)
+                cleaned_output = configuration_output
+                if "```json" in cleaned_output:
+                    cleaned_output = cleaned_output.split("```json")[1].split("```")[0].strip()
+                elif "```" in cleaned_output:
+                    cleaned_output = cleaned_output.split("```")[1].split("```")[0].strip()
+                
                 config = json.loads(cleaned_output)
                 selected_functions = config[0]["selected_functions"]
-                print(f"\nSelected functions: {selected_functions}")
+                yield f"Selected {len(selected_functions)} components to generate", results
                 
             except (json.JSONDecodeError, KeyError, IndexError) as e:
-                print(f"Warning: Could not parse configuration output ({str(e)}),")
-                print(f"Attempted to parse: {cleaned_output}")
-                return results
+                yield f"Warning: Could not parse configuration output ({str(e)})", results
+                return
                 
         except Exception as e:
-            print(f"Error in analyzing configuration: {str(e)}")
-            return results
+            yield f"Error in analyzing configuration: {str(e)}", results
+            return
         
-        # Execute each function and yield results one by one
-        for function_name in selected_functions:
+        # Execute each function and stream results
+        for i, function_name in enumerate(selected_functions, 1):
             try:
-                print(f"\nExecuting {function_name}...")
+                yield f"Generating component {i}/{len(selected_functions)}: {function_name}...", results
                 result = self.execute_prompt(function_name)
-                
-                # Clean and parse the result if it's JSON
-                try:
-                    cleaned_result = self._clean_json_response(result)
-                    json_result = json.loads(cleaned_result)
-                    # If parsing succeeds, convert back to a formatted JSON string
-                    result = json.dumps(json_result, indent=2)
-                except json.JSONDecodeError:
-                    # If it's not valid JSON, keep the original result
-                    pass
-                
-                # Store the result in the results set as a tuple
                 results.add((function_name, result))
-                print(f"Successfully generated result for {function_name}")
+                yield f"Successfully generated {function_name}", results
             
             except Exception as e:
-                print(f"Error executing {function_name}: {str(e)}")
+                yield f"Error executing {function_name}: {str(e)}", results
                 continue
-            
-        return results
-    
+        
+        yield "All components generated successfully!", results
   
         
     

app.py

@@ -2,7 +2,7 @@ from typing import Tuple
 import gradio as gr
 from Project import *
 from common_functions_v4 import *
-from event_handler import setup_all_handlers
+from event_handler import generate_content, setup_all_handlers
 from google_drive import *
 from notion import *
 from state import state
@@ -168,9 +168,7 @@ def create_quotation_generator_section():
     page_notes_box = None
     page_save_quotation_btn = None
     project_name = None
-    
-    # Initialize generation_results at the beginning
-    generation_results = gr.State(value=set())
+    generation_results = gr.State(set())
 
     with gr.Tab(label="Quotation Generator"):
         with gr.Row():
@@ -200,6 +198,7 @@ def create_quotation_generator_section():
                     
                     if step not in step_outputs:
                         step_outputs[step] = {}
+                    step_outputs[step][prompt_key] = prompt_config
                     
                     if sub_step:
                         if sub_step not in step_outputs[step]:
@@ -215,7 +214,7 @@ def create_quotation_generator_section():
 
                 # Create main step accordions
                 for step_name, sub_steps in step_outputs.items():
-                    with gr.Accordion(step_name, open=False) :
+                    with gr.Accordion(step_name, open=False):
                         # Create button for this step
                         try:
                             if ' : ' in step_name:
@@ -227,63 +226,77 @@ def create_quotation_generator_section():
                             
                         step_buttons[step_name] = gr.Button(f"✅ Generate {button_label}")
                         
-                        # Create a container for dynamic results inside each step accordion
-                        with gr.Column() as dynamic_results_container:
+                        # Create a unique results container for this step
+                        results_container = gr.Column(visible=False)
+                        with results_container:
                             gr.Markdown("## Generated Results")
-                            
-                            # Use gr.render to dynamically create components based on results
+                        
+                        def create_render_results(step):
                             @gr.render(inputs=[generation_results])
                             def render_results(results):
                                 if not results:
-                                    gr.Markdown("No results generated yet.")
-                                    return
-                                    
-                                # Iterate through results and create components for each
-                                for function_name, result in results:
-                                    # Get the output name from function name
-                                    output_name = function_name.replace("generate_", "")
-                                    
-                                    # Find the corresponding prompt config
-                                    prompt_config = None
-                                    for config in PROMPTS.values():
-                                        if function_name in config.outputs:
-                                            prompt_config = config
-                                            break
+                                    return gr.Markdown("No results generated yet.")
+                                
+                                components = []
+                                relevant_results = [
+                                    (fname, res) for fname, res in results 
+                                    if PROMPTS.get(fname) and PROMPTS[fname].step == step
+                                ]
+                                
+                                if not relevant_results:
+                                    return gr.Markdown("No results generated for this step.")
+                                
+                                for function_name, result in relevant_results:
+                                    prompt_config = PROMPTS.get(function_name)
                                     
-                                    # Create a section for this result
-                                    with gr.Group():
-                                        gr.Markdown(f"### {prompt_config.description if prompt_config else function_name}")
-                                        
-                                        with gr.Row():
-                                            with gr.Column(scale=1):
-                                                # Text component
-                                                gr.Textbox(
-                                                    value=result,
-                                                    label=f"{output_name} Text Output",
-                                                    lines=10,
-                                                    interactive=True,
-                                                )
-                                            
-                                            with gr.Column(scale=1):
-                                                # Markdown component
-                                                gr.Markdown(
-                                                    value=result,
-                                                    show_copy_button=True,
-                                                    elem_classes=["scrollable-markdown"]
-                                                )
+                                    components.extend([
+                                        gr.Group([
+                                            gr.Markdown(f"### {prompt_config.description if prompt_config else function_name}"),
+                                            gr.Row([
+                                                gr.Column([
+                                                    gr.Textbox(
+                                                        value=result,
+                                                        label=f"{function_name} Text Output",
+                                                        lines=10,
+                                                        interactive=True
+                                                    )
+                                                ], scale=1),
+                                                gr.Column([
+                                                    gr.Markdown(
+                                                        value=result,
+                                                        show_copy_button=True,
+                                                        elem_classes=["scrollable-markdown"]
+                                                    )
+                                                ], scale=1)
+                                            ])
+                                        ])
+                                    ])
+                                
+                                return components
+                            
+                            return render_results
+                        
+                        step_buttons[str(step_name)].click(
+                            fn=generate_content,
+                            outputs=[page_progress_update, generation_results],
+                            queue=True  
+                        ).then(
+                            fn=create_render_results(step_name),
+                            inputs=[generation_results]
+                        )
 
+        with gr.Column(scale=1):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    project_name = gr.Textbox(
+                        placeholder="Please enter a project name to be saved in Google Drive and Notion",
+                        label="Project Name",
+                        lines=1.5,
+                        interactive=True
+                    )
                 with gr.Column(scale=1):
-                    with gr.Row():
-                        with gr.Column(scale=2):
-                            project_name = gr.Textbox(
-                                placeholder="Please enter a project name to be saved in Google Drive and Notion",
-                                label="Project Name",
-                                lines=1.5,
-                                interactive=True
-                            )
-                        with gr.Column(scale=1):
-                            page_upload_drive_btn = gr.Button("📁 Upload to Google Drive")
-                            page_upload_notion_btn = gr.Button("📝 Upload to Notion")
+                    page_upload_drive_btn = gr.Button("📁 Upload to Google Drive")
+                    page_upload_notion_btn = gr.Button("📝 Upload to Notion")
 
     # Add system prompts tab
     with gr.Tab(label="System Prompts"):
@@ -304,8 +317,6 @@ def create_quotation_generator_section():
                         else:
                             all_components[prompt_key] = components
 
-    # Setup event handlers
-    # Pass the existing generation_results to setup_all_handlers
     setup_all_handlers(
         step_buttons,
         all_components,
@@ -315,7 +326,7 @@ def create_quotation_generator_section():
         page_upload_drive_btn,
         page_upload_notion_btn,
         project_name,
-        generation_results  # Pass the generation_results here
+        generation_results
     )
     
     return (all_components, step_buttons, 
@@ -439,8 +450,6 @@ with gr.Blocks(title="Quotation Chatbot (with SOW)", css=custom_css) as page_int
                 current_session_display,
             ]
         )
-        
-        setup_all_handlers(step_buttons, all_components, page_progress_update, quotation_cost , page_recalc_btn , page_upload_drive_btn ,  page_upload_notion_btn , project_name)
 
     # Call setup_event_handlers after all components are created
     setup_event_handlers()

event_handler.py

@@ -5,54 +5,22 @@ from state import state
 import gradio as gr
 import json
 from prompt_configs import PROMPTS
-import pandas as pd
-from io import StringIO
+from typing import Generator, Tuple
 
-def start_generation():
-    """Initial function to start the generation process"""
-    return "Starting generation..."
-
-def generate_content():
-    """Generate content and return results"""
+def generate_content(progress=gr.Progress()) -> Generator[Tuple[str, set] , Any , None]:
+    """Generate content using the Project instance"""
     try:
-        # Initialize state project if not already done
-        if not hasattr(state, 'quotation_project') or state.quotation_project is None:
-            state.quotation_project = Project("quotation")
-            
-        # Get the results from the project one by one
-        results = state.quotation_project.generate_prd_and_components()
-        
-        # Store results in state for access by render function
-        state.generation_results = results
-            
-        # Return the progress update and results
-        return "Generation complete!", results
-        
+        # Generate PRD and components, yielding results as they're generated
+        for status_msg, result in state.quotation_project.generate_prd_and_components(progress):
+            # Yield both the status message and current results
+            yield status_msg, result
+
     except Exception as e:
-        print(f"Error in generate_content: {str(e)}")
-        return f"Error: {str(e)}", {}
+        print(f"Error during generation: {str(e)}")  # Add debug print
+        yield f"Error during generation: {str(e)}", set()
 
 def setup_all_handlers(step_buttons, all_components, progress_update, quotation_cost=None, recalc_btn=None, upload_drive_btn=None, upload_notion_btn=None, project_name=None, generation_results=None):
     """Set up all step handlers with the provided UI components"""
-    
-    # Store components for use in handlers
-    global components
-    components = all_components
-    
-    # Use the provided generation_results or create a new one if not provided
-    if generation_results is None:
-        generation_results = gr.State(value=set())
-    
-    # Set up handlers for each step button
-    for step_name, button in step_buttons.items():
-        if "Step 1" in step_name:
-            # First update the progress message, then generate content
-            button.click(
-                fn=start_generation,
-                outputs=[progress_update]
-            ).then(
-                fn=generate_content,
-                outputs=[progress_update, generation_results]
-            )
-            
-    return generation_results
+    # Modified button click chain
+    return generation_results
+    

prompt_configs.py

@@ -128,7 +128,7 @@ PROMPTS = {
         """,
         inputs=['generated_prd'],
         outputs=["configuration_type"],
-        step="Analyze Configuration Type",
+        step="Step 1 : Scope & Components",
         model=ModelType.O1_MINI,
         description="Component Agent",
     ),