- fix generation_results

Project.py

@@ -7,6 +7,7 @@ from langtrace_python_sdk.utils.with_root_span import with_langtrace_root_span
 import openai
 from contextlib import contextmanager
 import json
+from sample_permutations import *
 from state import state
 import re
 from typing import Tuple
@@ -218,82 +219,221 @@ class Project:
     ##########################################################
     ## Generate PRD and components from project details ##
     def generate_prd_and_components(self, progress=gr.Progress()):
-      """Generate PRD and components from project details, streaming results"""
-      results = []  # Use a list instead of a set to maintain order
-      
-      # Generate PRD
-      yield "Generating PRD...", results
-      prd_response = self.execute_prompt(
-          "generate_prd",
-          {
-              "project_detail": self.get_project_detail()
-          }
-      )
-      
-      # Parse the PRD JSON response
-      try:
-          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
-          
-      # Add PRD to results and yield update
-      results.append(("generate_prd", self.generated_prd))  
-      yield "PRD generation complete", results
-      
-      try:
-          yield "Analyzing configuration with component agent...", results
-          configuration_output = self.execute_prompt(
-              "component_agent",
-              {
-                  "generated_prd": self.generated_prd
-              }
-          )
-          
-          results.append(("component_agent", configuration_output))  # Use append
-          yield "Component analysis complete", results
-          
-          # Parse configuration output
-          try:
-              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"]
-              yield f"Selected {len(selected_functions)} components to generate", results
-              
-          except (json.JSONDecodeError, KeyError, IndexError) as e:
-              yield f"Warning: Could not parse configuration output ({str(e)})", results
-              return
-              
-      except Exception as e:
-          yield f"Error in analyzing configuration: {str(e)}", results
-          return
-      
-      # Execute each function and stream results
-      for i, function_name in enumerate(selected_functions, 1):
-          try:
-              yield f"Generating component {i}/{len(selected_functions)}: {function_name}...", results
-              result = self.execute_prompt(function_name)
-              results.append((function_name, result))  # Use append
-              yield f"Successfully generated {function_name}", results
-          
-          except Exception as e:
-              yield f"Error executing {function_name}: {str(e)}", results
-              continue
-      
-      yield "All components generated successfully!", results
-      
-    def generate_mandays(self, progress=gr.Progress()):
-      """Generate PRD and components from project details, streaming results"""
-      results = []  # Use a list instead of a set to maintain order
-      
-      # Generate PRD
-      yield "Generating Mandays...", results
+        """Generate PRD and components from project details, streaming results"""
+        results = []  # Use a list instead of a set to maintain order
+        
+        # Generate PRD
+        yield "Generating PRD...", results
+        prd_response = self.execute_prompt(
+            "generate_prd",
+            {
+                "project_detail": self.get_project_detail()
+            }
+        )
+        
+        # Parse and format the PRD response
+        try:
+            # Handle PRD response
+            if isinstance(prd_response, str):
+                if "```json" in prd_response:
+                    prd_response = prd_response.split("```json")[1].split("```")[0].strip()
+                elif "```" in prd_response:
+                    prd_response = prd_response.split("```")[1].split("```")[0].strip()
+                prd_json = json.loads(prd_response)
+            else:
+                prd_json = prd_response
+
+            # Extract PRD content
+            if isinstance(prd_json, dict):
+                if "detailed_breakdown" in prd_json:
+                    self.generated_prd = prd_json["detailed_breakdown"]
+                    formatted_prd = {
+                        "function_name": "generate_prd",
+                        "result": {
+                            "detailed_breakdown": prd_json["detailed_breakdown"],
+                            "summary": prd_json.get("summary", "")
+                        }
+                    }
+                else:
+                    self.generated_prd = prd_json
+                    formatted_prd = {
+                        "function_name": "generate_prd",
+                        "result": prd_json
+                    }
+            else:
+                self.generated_prd = str(prd_json)
+                formatted_prd = {
+                    "function_name": "generate_prd",
+                    "result": str(prd_json)
+                }
+            
+            # Add formatted PRD to results
+            results.append(formatted_prd)
+            yield "PRD generation complete", results
+            
+        except json.JSONDecodeError as e:
+            print(f"Warning: Could not parse PRD as JSON: {str(e)}")
+            self.generated_prd = prd_response
+            results.append({
+                "function_name": "generate_prd",
+                "result": prd_response
+            })
+            yield "PRD generation complete (raw format)", results
+        
+        try:
+            yield "Analyzing configuration with component agent...", results
+            configuration_output = self.execute_prompt(
+                "component_agent",
+                {
+                    "generated_prd": self.generated_prd
+                }
+            )
+            
+            # Parse and format configuration output
+            try:
+                if isinstance(configuration_output, str):
+                    if "```json" in configuration_output:
+                        configuration_output = configuration_output.split("```json")[1].split("```")[0].strip()
+                    elif "```" in configuration_output:
+                        configuration_output = configuration_output.split("```")[1].split("```")[0].strip()
+                    config = json.loads(configuration_output)
+                else:
+                    config = configuration_output
+
+                # Store config for later use
+                self.config = config
+                
+                formatted_config = {
+                    "function_name": "component_agent",
+                    "result": json.dumps(config, indent=2)
+                }
+                results.append(formatted_config)
+                
+                selected_functions = config[0]["selected_functions"]
+                yield f"Selected {len(selected_functions)} components to generate", results
+                
+            except (json.JSONDecodeError, KeyError, IndexError) as e:
+                yield f"Warning: Could not parse configuration output ({str(e)})", results
+                return
+                
+        except Exception as e:
+            yield f"Error in analyzing configuration: {str(e)}", results
+            return
+        
+        # Execute each function and stream results
+        for i, function_name in enumerate(selected_functions, 1):
+            try:
+                yield f"Generating component {i}/{len(selected_functions)}: {function_name}...", results
+                result = self.execute_prompt(function_name)
+                
+                # Format the component result
+                try:
+                    if isinstance(result, str):
+                        if "```json" in result:
+                            result = result.split("```json")[1].split("```")[0].strip()
+                        elif "```" in result:
+                            result = result.split("```")[1].split("```")[0].strip()
+                        try:
+                            # Try to parse as JSON
+                            parsed_result = json.loads(result)
+                            formatted_result = {
+                                "function_name": function_name,
+                                "result": json.dumps(parsed_result, indent=2)
+                            }
+                        except json.JSONDecodeError:
+                            # If not JSON, use raw string
+                            formatted_result = {
+                                "function_name": function_name,
+                                "result": result
+                            }
+                    else:
+                        formatted_result = {
+                            "function_name": function_name,
+                            "result": json.dumps(result, indent=2) if isinstance(result, (dict, list)) else str(result)
+                        }
+                    
+                    results.append(formatted_result)
+                    yield f"Successfully generated {function_name}", results
+                    
+                except Exception as e:
+                    print(f"Warning: Error formatting result for {function_name}: {str(e)}")
+                    results.append({
+                        "function_name": function_name,
+                        "result": str(result)
+                    })
+                    yield f"Generated {function_name} (raw format)", results
+            
+            except Exception as e:
+                yield f"Error executing {function_name}: {str(e)}", results
+                continue
+        
+        yield "All components generated successfully!", results
+
+    def generate_mandays_estimate(self, progress=gr.Progress()):
+        """Generate mandays estimation based on configuration type and selected functions, streaming results"""
+        results = []  # Use a list instead of a set to maintain order
+    
+        try:
+            # Check if the configuration is already available
+            if not hasattr(self, 'config'):
+                yield "Configuration not found. Please run 'generate_prd_and_components' first.", results
+                return
+    
+            # Use the pre-parsed configuration
+            config = self.config
+            configuration_type = config[0]["configuration_type"]
+            yield f"Configuration type detected: {configuration_type}", results
+    
+            # Map the configuration type to the enum
+            try:
+                config_type_enum = ConfigurationType(configuration_type)
+            except ValueError:
+                yield f"Unsupported configuration type: {configuration_type}", results
+                return
+    
+            # Get the functions to execute based on the configuration type
+            selected_functions = CONFIGURATION_TYPE_FUNCTIONS.get(config_type_enum, [])
+            yield f"Selected functions: {', '.join(selected_functions)}", results
+    
+            # Execute each function with its required inputs
+            for function_name in selected_functions:
+                try:
+                    yield f"Executing function: {function_name}...", results
+    
+                    # Get the required inputs for the function from PROMPTS
+                    if function_name not in PROMPTS:
+                        yield f"Error: Function {function_name} not found in PROMPTS.", results
+                        continue
+    
+                    prompt_config = PROMPTS[function_name]
+                    input_variables = {}
+    
+                    # Populate input variables using INPUT_MAPPINGS
+                    for input_name in prompt_config.inputs:
+                        if input_name not in self.INPUT_MAPPINGS:
+                            yield f"Error: No mapping defined for required input '{input_name}' in function {function_name}.", results
+                            continue
+    
+                        try:
+                            input_variables[input_name] = self.INPUT_MAPPINGS[input_name](self)
+                        except Exception as e:
+                            yield f"Error retrieving input '{input_name}' for function {function_name}: {str(e)}", results
+                            continue
+    
+                    # Execute the function with the populated input variables
+                    result = self.execute_prompt(function_name, input_variables)
+                    results.append((function_name, result))
+                    yield f"Successfully executed {function_name}", results
+    
+                except Exception as e:
+                    yield f"Error executing {function_name}: {str(e)}", results
+                    continue
+    
+            yield "Mandays estimation complete!", results
+    
+        except Exception as e:
+            yield f"Error in generate_mandays_estimate: {str(e)}", results
+
       
       
         

app.py

@@ -168,7 +168,7 @@ def create_quotation_generator_section():
     page_notes_box = None
     page_save_quotation_btn = None
     project_name = None
-    generation_results = gr.State([])
+    generation_results = gr.State({})
 
     with gr.Tab(label="Quotation Generator"):
         with gr.Row():
@@ -189,41 +189,60 @@ def create_quotation_generator_section():
             with gr.Column(scale=4):
                 # Organize steps and their outputs
                 step_outputs = {}
+                sub_steps = {}
+                
                 for prompt_key, prompt_config in PROMPTS.items():
                     if prompt_config.step == "Chatbot Prompt Editors":
                         continue
                     
                     step = prompt_config.step
                     sub_step = prompt_config.sub_step
-                    
-                    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]:
-                            step_outputs[step][sub_step] = []
-                        step_outputs[step][sub_step].append(prompt_key)
-                    else:
-                        if "main" not in step_outputs[step]:
-                            step_outputs[step]["main"] = []
-                        step_outputs[step]["main"].append(prompt_key)
+                    if step and step.strip():
+                        if step not in step_outputs:
+                            step_outputs[step] = []
+                        step_outputs[step].append(prompt_key)
+                        
+                        # Track sub-steps if they exist
+                        if sub_step:
+                            if step not in sub_steps:
+                                sub_steps[step] = {}
+                            if sub_step not in sub_steps[step]:
+                                sub_steps[step][sub_step] = []
+                            sub_steps[step][sub_step].append(prompt_key)
 
                 all_components = {}
                 step_buttons = {}
 
                 # Create main step accordions
-                for step_name, sub_steps in step_outputs.items():
+                for step_name, prompt_keys in step_outputs.items():
                     with gr.Accordion(step_name, open=False):
-                        try:
-                            if ' : ' in step_name:
-                                button_label = step_name.split(' : ')[1]
-                            else:
-                                button_label = step_name
-                        except Exception:
-                            button_label = step_name
+                        if "Step 2" in step_name:
+                            with gr.Row():
+                                with gr.Column(scale=4):
+                                    # Check if this step has sub-steps
+                                    if step_name in sub_steps:
+                                        # Iterate through sub-steps for this step
+                                        for sub_step_name, prompt_keys_list in sub_steps[step_name].items():
+                                            # Create button for this sub-step
+                                            button_label = sub_step_name.split(' : ')[1] if ' : ' in sub_step_name else sub_step_name
+                                            step_buttons[sub_step_name] = gr.Button(f"✅ {button_label}")
+                                
+                                with gr.Column(scale=1):                 
+                                    quotation_cost = gr.Textbox(label="Cost Summary", lines=3, interactive=False)
+                                    page_recalc_btn = gr.Button("Recalculate")
+                                    print(f"recalc_btn created: {page_recalc_btn}")  
+                
+                                    page_notes_box = gr.Textbox(
+                                        label="Notes", 
+                                        lines=3, 
+                                        placeholder="Add your notes here..."
+                                    )
+                                    page_save_quotation_btn = gr.Button("Save Quotation with Note")
                             
-                        step_buttons[step_name] = gr.Button(f"✅ Generate {button_label}")
+                        else:
+                            # Regular step button for non-Step 2
+                            button_label = step_name.split(' : ')[1] if ' : ' in step_name else step_name
+                            step_buttons[step_name] = gr.Button(f"✅ Generate {button_label}")
                     
                         # Create the render function for this specific step
                         create_render_results(step_name, generation_results)

event_handler.py

@@ -7,27 +7,43 @@ import json
 from prompt_configs import PROMPTS
 from typing import Generator, Tuple
 
-
 def generate_step_1(progress=gr.Progress()) -> Generator[Tuple[str, list], Any, None]:
     """Generate content using the Project instance"""
     try:
+        # Initialize a list of step_results 
+        step_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 status_msg, result
+            step_results.append(result)
+            state.generation_results['step_1'] = step_results
+            print(f"Intermediate state update: {state.generation_results}") 
+            yield status_msg, step_results
 
+        # Store results in the shared data structure
+        state.generation_results['step_1'] = step_results
+        print("Step 1 Results Stored:", state.generation_results)
+        
     except Exception as e:
-        print(f"Error during generation: {str(e)}")  
+        print(f"Error during generation: {str(e)}")
         yield f"Error during generation: {str(e)}", []
         
-def generate_step_2(progress=gr.Progress()) -> Generator[Tuple[str, list], Any, None]:
+def generate_step_2_a(progress=gr.Progress()) -> Generator[Tuple[str, list], Any, None]:
     """Generate content using the Project instance"""
     try:
-        # Generate PRD and components, yielding results as they're generated
-        for status_msg, result in state.quotation_project.generate_prd_and_components(progress):
-            yield status_msg, result
+        # Initialize results for this step
+        step_results = []
+
+        # Generate mandays estimate, yielding results as they're generated
+        for status_msg, result in state.quotation_project.generate_mandays_estimate(progress):
+            step_results.append(result)
+            yield status_msg, step_results
+
+        # Store results in the shared data structure
+        state.generation_results['step_2_a'] = step_results
 
     except Exception as e:
-        print(f"Error during generation: {str(e)}")  
+        print(f"Error during generation: {str(e)}")
         yield f"Error during generation: {str(e)}", []
         
 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):
@@ -39,58 +55,85 @@ def setup_all_handlers(step_buttons, all_components, progress_update, quotation_
         queue=True
     )
     
-    step_buttons['Step 2 : Mandays & Quotation'].click(
-        fn=generate_step_1,
+    step_buttons['Step 2.1 : Generate Mandays'].click(
+        fn=generate_step_2_a,
         outputs=[progress_update, generation_results],
         queue=True
     )
     
-    return generation_results
-
 def create_render_results(step, generation_results):
     @gr.render(inputs=[generation_results])
     def render_results(results):
         if not results:
             return [gr.Markdown("No results generated yet.")]
         
-        relevant_results = [
-            (fname, res) for fname, res in results 
-            if PROMPTS.get(fname) and PROMPTS[fname].step == step
-        ]
+        # Retrieve relevant results for the current step from the state
+        if step == "Step 1 : Scope & Components":
+            relevant_results = state.generation_results.get('step_1', [])
+        elif step == "Step 2.1 : Generate Mandays":
+            relevant_results = state.generation_results.get('step_2_a', [])
+        else:
+            relevant_results = []
         
         if not relevant_results:
             return [gr.Markdown("No results generated for this step.")]
         
         # Create components as a list
         result_components = []
-        for function_name, result in relevant_results:
-            prompt_config = PROMPTS.get(function_name)
-            description = prompt_config.description if prompt_config else function_name
-            
-            with gr.Accordion(f"{description}", open=False):
-                 result_components.extend([
-                     gr.Row([
-                         gr.Column(
-                             gr.Textbox(  # Positional argument (child component)
-                                 value=result,
-                                 label="Text Output",
-                                 lines=10,
-                                 interactive=True
-                             ),
-                             scale=1  # Keyword argument
-                         ),
-                         gr.Column(
-                             gr.Markdown(  # Positional argument (child component)
-                                 value=result,
-                                 show_copy_button=True,
-                                 elem_classes=["scrollable-markdown"]
-                             ),
-                             scale=1  # Keyword argument
-                         )
-                     ])
-                 ])
+        seen_results = set()  # To avoid duplicates
+        
+        # Handle case where relevant_results is a list of results
+        if isinstance(relevant_results, list):
+            # If it's a single list in the results, process its items
+            for result_item in relevant_results[-1]:  # Take the latest result set
+                try:
+                    # Extract function name and result from the item
+                    if isinstance(result_item, dict):
+                        function_name = result_item.get("function_name", "Unknown Function")
+                        result = result_item.get("result", "No result")
+                        
+                        # Skip if we've seen this exact result before
+                        result_str = json.dumps(result) if isinstance(result, (dict, list)) else str(result)
+                        if result_str in seen_results:
+                            continue
+                        seen_results.add(result_str)
+                        
+                        # Get prompt config if available
+                        prompt_config = PROMPTS.get(function_name)
+                        description = prompt_config.description if prompt_config else function_name
+                        
+                        # Create an accordion for each result
+                        with gr.Accordion(f"{description}", open=False):
+                            result_components.append(
+                                gr.Row([
+                                    gr.Column(
+                                        gr.Textbox(  
+                                            value=result_str,  
+                                            label="Text Output",
+                                            lines=10,
+                                            interactive=True
+                                        ),
+                                        scale=1  
+                                    ),
+                                    gr.Column(
+                                        gr.Markdown( 
+                                            value=result_str, 
+                                            show_copy_button=True,
+                                            elem_classes=["scrollable-markdown"]
+                                        ),
+                                        scale=1  
+                                    )
+                                ])
+                            )
+                        
+                        
+                except Exception as e:
+                    print(f"Debug: Error processing result item: {str(e)}")
+                    continue
         
-        # Return the list of components directly
+        if not result_components:
+            return [gr.Markdown("No valid results to display.")]
+            
         return result_components
     
     return render_results

prompt_configs.py

@@ -934,6 +934,7 @@ PROMPTS = {
         }
     ),
     
+    # Ivy : Combine both into one
     "generate_plan_test_mandays": PromptConfig(
         prompt=
         """

sample_permutations.py

@@ -5,28 +5,21 @@ class ConfigurationType(Enum):
     CHATBOT = "Basic Chatbot"
     DOCUMENT_EXTRACTION = "Document Extraction"
     CHATBOT_AND_DOC = "Basic Chatbot and Document Extraction"
-    GENERAL_SOFTWARE = "General Software"
 
 CONFIGURATION_TYPE_FUNCTIONS = {
     ConfigurationType.CHATBOT: [
-        "generate_engage_plan_test_components",
-        "generate_intent_list"
-        "generate_engage_dev_components",
+        "generate_intents_csv",
+        "generate_plan_test_mandays",
+        "generate_dev_mandays",
     ],
     ConfigurationType.DOCUMENT_EXTRACTION: [
-        "generate_page_plan_test_components",
-        "generate_page_dev_components"
+        "generate_plan_test_mandays",
+        "generate_dev_mandays",
     ],
     ConfigurationType.CHATBOT_AND_DOC: [
-        "generate_page_plan_test_components",
-        "generate_engage_plan_test_components",
-        "generate_intent_list",
-        "generate_page_dev_components",
-        "generate_engage_dev_components",
-    ],
-    ConfigurationType.GENERAL_SOFTWARE: [
-        "generate_plan_test_components",
-        "generate_dev_components"
+        "generate_intents_csv",
+        "generate_plan_test_mandays",
+        "generate_dev_mandays",
     ]
 }
 

state.py

@@ -8,6 +8,7 @@ class ProjectType(Enum):
 class GlobalState:
     def __init__(self):
         self._quotation_project = None
+        self.generation_results = {}
 
     @property
     def quotation_project(self):