add: WORKING config parser

config_parser.py

@@ -6,6 +6,10 @@ from enum import Enum
 class ModelType(Enum):
     O1_MINI = "O1_MINI"
     GPT_4O_MINI = "GPT_4O_MINI"
+class UIComponentType(Enum):
+    TEXTBOX = "textbox"
+    MARKDOWN = "markdown"
+    DATAFRAME = "dataframe"
 
 @dataclass
 class UIConfig:
@@ -31,6 +35,13 @@ class PromptConfig:
     thoughts: Optional[list]
     ui: Dict[str, UIConfig]
 
+safe_globals = {
+"PromptConfig": PromptConfig,
+"ModelType": ModelType,
+"UIConfig": UIConfig,
+"UIComponentType": UIComponentType,
+}
+
 class ConfigParser:
     def __init__(self, file_path: str):
         self.file_path = file_path
@@ -68,6 +79,12 @@ class ConfigParser:
         
         return ui_configs
 
+    def clean_enum_values(self, text: str) -> str:
+        """Clean enum values in the text to make them evaluatable"""
+        # Replace enum patterns like <TEXTBOX: 'textbox'> with just the enum name
+        enum_pattern = r'<(\w+):\s*\'[^\']+\'>'
+        return re.sub(enum_pattern, r'UIComponentType.\1', text)
+
     def parse_config(self) -> Dict[str, PromptConfig]:
         """Parse the config file and return a dictionary of PromptConfig objects"""
         print("Starting parse_config...")
@@ -77,21 +94,6 @@ class ConfigParser:
 
         # Split content into individual prompt configs
         # prompt_pattern = r'"([^"]+)":\s*PromptConfig\(\s*prompt="""([^"]*?)""",\s*description="([^"]*)",\s*step="([^"]*)",\s*sub_step="([^"]*)",\s*inputs=\[([^\]]*)\],\s*outputs=\[([^\]]*)\],\s*model=([^,]*),\s*thoughts=\[([^\]]*)\],\s*ui=({[^}]+})\s*\)'
-        # Build regex pattern to match PromptConfig structure with optional fields
-        prompt_pattern = (
-            r'"([^"]+)":\s*'                    # Key
-            r'PromptConfig\(\s*'                # PromptConfig start
-            r'prompt="""(.*?)""",\s*'           # Prompt text (non-greedy match)
-            r'(?:description="([^"]*)",\s*)?'   # Optional description
-            r'(?:step="([^"]*)",\s*)?'         # Optional step
-            r'(?:sub_step="([^"]*)",\s*)?'     # Optional sub_step
-            r'(?:inputs=\[(.*?)\],\s*)?'       # Optional inputs list
-            r'(?:outputs=\[(.*?)\],\s*)?'      # Optional outputs list
-            r'(?:model=([^,\s]*),\s*)?'        # Optional model
-            r'(?:thoughts=\[(.*?)\],\s*)?'     # Optional thoughts list
-            r'(?:ui=({[^}]+})\s*)?'           # Optional UI config
-            r'\)'                               # PromptConfig end
-        )
        
         # # Option 1 : Match all configs by $$ marker
         # regex_pattern = r"\$\$(.*?)\$\$"
@@ -103,85 +105,109 @@ class ConfigParser:
         # print("Using regex pattern to find prompt configs...")
         
         # Option 2 : Matches configs, without $$ markers therefor very unstable
-        configs = {}
+        # prompt_pattern = (
+        #     r'"([^"]+)":\s*'                    # Key
+        #     r'PromptConfig\(\s*'                # PromptConfig start
+        #     r'prompt="""(.*?)""",\s*'           # Prompt text (non-greedy match)
+        #     r'(?:description="([^"]*)",\s*)?'   # Optional description
+        #     r'(?:step="([^"]*)",\s*)?'         # Optional step
+        #     r'(?:sub_step="([^"]*)",\s*)?'     # Optional sub_step
+        #     r'(?:inputs=\[(.*?)\],\s*)?'       # Optional inputs list
+        #     r'(?:outputs=\[(.*?)\],\s*)?'      # Optional outputs list
+        #     r'(?:model=([^,\s]*),\s*)?'        # Optional model
+        #     r'(?:thoughts=\[(.*?)\],\s*)?'     # Optional thoughts list
+        #     r'(?:ui=({[^}]+})\s*)?'           # Optional UI config
+        #     r'\)'                               # PromptConfig end
+        # )
+        # configs = {}
 
-        for match in re.finditer(prompt_pattern, content, re.DOTALL):
-            key = match.group(1)
-            print(f"\nProcessing config for key: {key}")
+        # for match in re.finditer(prompt_pattern, content, re.DOTALL):
+        #     key = match.group(1)
+        #     print(f"\nProcessing config for key: {key}")
             
-            prompt = match.group(2).strip()
-            description = match.group(3)
-            step = match.group(4)
-            sub_step = match.group(5)
-            print(f"Found description: {description}, step: {step}, sub_step: {sub_step}")
+        #     prompt = match.group(2).strip()
+        #     description = match.group(3)
+        #     step = match.group(4)
+        #     sub_step = match.group(5)
+        #     print(f"Found description: {description}, step: {step}, sub_step: {sub_step}")
             
-            # Parse lists
-            inputs = [x.strip("'") for x in match.group(6).split(",") if x.strip()]
-            outputs = [x.strip("'") for x in match.group(7).split(",") if x.strip()]
-            print(f"Parsed inputs: {inputs}")
-            print(f"Parsed outputs: {outputs}")
+        #     # Parse lists
+        #     inputs = [x.strip("'") for x in match.group(6).split(",") if x.strip()]
+        #     outputs = [x.strip("'") for x in match.group(7).split(",") if x.strip()]
+        #     print(f"Parsed inputs: {inputs}")
+        #     print(f"Parsed outputs: {outputs}")
             
-            # Parse model type
-            model_str = match.group(8).strip()
-            model = ModelType[model_str.split(".")[-1]] if model_str else ModelType.O1_MINI
-            print(f"Using model: {model}")
+        #     # Parse model type
+        #     model_str = match.group(8).strip()
+        #     model = ModelType[model_str.split(".")[-1]] if model_str else ModelType.O1_MINI
+        #     print(f"Using model: {model}")
             
-            # Parse thoughts
-            thoughts_str = match.group(9)
-            thoughts = [x.strip("'") for x in thoughts_str.split(",") if x.strip()] if thoughts_str else None
-            print(f"Found {len(thoughts) if thoughts else 0} thoughts")
+        #     # Parse thoughts
+        #     thoughts_str = match.group(9)
+        #     thoughts = [x.strip("'") for x in thoughts_str.split(",") if x.strip()] if thoughts_str else None
+        #     print(f"Found {len(thoughts) if thoughts else 0} thoughts")
             
-            # Parse UI config
-            ui_text = match.group(10)
-            print("Parsing UI config...")
-            ui = self.parse_ui_config(ui_text)
-            print(f"Found {len(ui)} UI components")
+        #     # Parse UI config
+        #     ui_text = match.group(10)
+        #     print("Parsing UI config...")
+        #     ui = self.parse_ui_config(ui_text)
+        #     print(f"Found {len(ui)} UI components")
             
-            configs[key] = PromptConfig(
-                prompt=prompt,
-                description=description,
-                step=step,
-                sub_step=sub_step,
-                inputs=inputs,
-                outputs=outputs,
-                model=model,
-                thoughts=thoughts,
-                ui=ui
-            )
-            print(f"Successfully created PromptConfig for {key}")
-        return configs
+        #     configs[key] = PromptConfig(
+        #         prompt=prompt,
+        #         description=description,
+        #         step=step,
+        #         sub_step=sub_step,
+        #         inputs=inputs,
+        #         outputs=outputs,
+        #         model=model,
+        #         thoughts=thoughts,
+        #         ui=ui
+        #     )
+        #     print(f"Successfully created PromptConfig for {key}")
+        # return configs
 
-        
-    def format_config(self, config: Dict[str, PromptConfig]) -> str:
-        """Format the config dictionary back to string representation"""
-        formatted = "{\n"
-        for key, value in config.items():
-            formatted += f'    "{key}": PromptConfig(\n'
-            formatted += f'        prompt="""\n{value.prompt}\n""",\n'
-            formatted += f'        description="{value.description}",\n'
-            formatted += f'        step="{value.step}",\n'
-            formatted += f'        sub_step="{value.sub_step}",\n'
-            formatted += f'        inputs={value.inputs},\n'
-            formatted += f'        outputs={value.outputs},\n'
-            formatted += f'        model={value.model},\n'
-            formatted += f'        thoughts={value.thoughts},\n'
-            formatted += f'        ui={value.ui}\n'
-            formatted += '    ),\n'
-        formatted += "}"
-        return formatted
+        # Option 3, Block and ast method
+
+        # Extract each block wrapped by $$ markers.
+        block_pattern = r"\$\$(.*?)\$\$"
+        blocks = re.findall(block_pattern, content, re.DOTALL)
+        print(f"Found {len(blocks)} config blocks.")
+
+        configs = {}
+        error_log_path = 'config_parser_errors.txt'
+        with open(error_log_path, 'w') as error_log:
+            for i, block in enumerate(blocks, 1):
+                block = block.strip()
+                dict_str = "{" + block + "}"
+                try:
+                    # Clean the enum values before evaluation
+                    cleaned_dict_str = self.clean_enum_values(dict_str)
+                    config_dict = eval(cleaned_dict_str, safe_globals)
+                    configs.update(config_dict)
+                    key = list(config_dict.keys())[0]
+                    print(f"Block {i}: Successfully parsed config for key: {key}")
+                except Exception as e:
+                    error_log.write(f"Block {i}: Error evaluating block: {e}\n")
+                    error_log.write("Block content:\n")
+                    error_log.write(dict_str + "\n")
+                    error_log.write("-" * 40 + "\n")
+        print(f"\nFinished parsing {len(configs)} configs")
+        return configs
 
 # Example usage
-# $$
-# parser = ConfigParser('db_config_log_20250326_195828.txt')
+# Option 1 : with $$ markers
+parser = ConfigParser('db_config_log_20250326_195828.txt')
 
-parser = ConfigParser('db_config_log_20250326_193344.txt')
+# Option 2 : without $$ markers
+# parser = ConfigParser('db_config_log_20250326_193344.txt')
 try:
     config = parser.parse_config()
     # print(f"Config: {config}")
     # Print total number of configs parsed
     print(f"Total configs parsed: {len(config)}")
-    # questioning_agent = config.get('questioning_agent')
-    # print(f"Questioning Agent: {questioning_agent}")
+    questioning_agent = config.get('questioning_agent')
+    print(f"Questioning Agent: {questioning_agent}")
     # if questioning_agent:
     #     print("Prompt:", questioning_agent.prompt[:100])
     #     print("Model:", questioning_agent.model)