Update app.py

app.py

@@ -1065,7 +1065,49 @@ def update_inputs_with_llm_suggestions(suggestions):
         gr.update(value=suggestions["apply_phonetic"]),      # apply_phonetic_input
         gr.update(value=suggestions["phonetic_weight"])      # phonetic_weight_input
     ]
+
+def parse_model_selections(default_models, custom_models):
+    """
+    Parse selected default models and custom models into model configurations
     
+    Args:
+        default_models (List[str]): Selected default models in format "type:name"
+        custom_models (str): Custom models string with one model per line in format "type:name"
+    
+    Returns:
+        List[Dict[str, str]]: List of model configurations with 'type' and 'name' keys
+    """
+    model_configs = []
+    
+    # Process default models
+    if default_models:
+        for model in default_models:
+            model_type, model_name = model.split(':')
+            model_configs.append({
+                'type': model_type,
+                'name': model_name
+            })
+    
+    # Process custom models
+    if custom_models:
+        custom_model_lines = custom_models.strip().split('\n')
+        for line in custom_model_lines:
+            if line.strip() and ':' in line:
+                model_type, model_name = line.strip().split(':')
+                model_configs.append({
+                    'type': model_type.strip(),
+                    'name': model_name.strip()
+                })
+    
+    return model_configs
+
+def parse_comma_separated(text):
+    """Parse comma-separated values into a list"""
+    if not text:
+        return []
+    return [x.strip() for x in text.split(',') if x.strip()]
+
+
     
 # Gradio Interface
 def launch_interface(share=True):
@@ -1111,8 +1153,6 @@ def launch_interface(share=True):
             use_reranking_input = gr.Checkbox(label="Use Reranking", value=False)
 
         with gr.Tab("Automation"):
-
-
             with gr.Row():
                 auto_file_input = gr.File(label="Upload File (Optional)")
                 auto_query_input = gr.Textbox(label="Search Query")
@@ -1138,14 +1178,14 @@ def launch_interface(share=True):
                         value=[f"HuggingFace:{DEFAULT_MODELS['HuggingFace'][0]}"]
                     )
                 
-            with gr.Column():
-                # Custom model input
-                custom_models_input = gr.TextArea(
-                    label="Custom Models (Optional)",
-                    placeholder="Enter one model per line in format: type:name",
-                    lines=3
-                )
-  
+                with gr.Column():
+                    # Custom model input
+                    custom_models_input = gr.TextArea(
+                        label="Custom Models (Optional)",
+                        placeholder="Enter one model per line in format: type:name",
+                        lines=3
+                    )
+        
             auto_split_strategies = gr.CheckboxGroup(
                 choices=["token", "recursive"],
                 label="Split Strategies to Test"
@@ -1164,24 +1204,69 @@ def launch_interface(share=True):
             auto_optimize_vocab = gr.Checkbox(label="Test Vocabulary Optimization", value=True)
             auto_use_query_optimization = gr.Checkbox(label="Test Query Optimization", value=True)
             auto_use_reranking = gr.Checkbox(label="Test Reranking", value=True)
-
             
             auto_results_output = gr.Dataframe(label="Automated Test Results", interactive=False)
             auto_stats_output = gr.Dataframe(label="Automated Test Statistics", interactive=False)
             recommendations_output = gr.JSON(label="Recommendations")
-    
+        
+            def run_automation(file_input, query_input, expected_result, default_models, custom_models,
+                              split_strategies, chunk_sizes, overlap_sizes,
+                              vector_store_types, search_types, top_k_values,
+                              optimize_vocab, use_query_optimization, use_reranking,
+                              model_feedback):
+                """Wrapper function to handle Gradio inputs and run automated tests"""
+                
+                # Parse model configurations
+                model_configs = parse_model_selections(default_models, custom_models)
+                
+                # Parse test parameters
+                test_params = {
+                    'split_strategy': split_strategies,
+                    'chunk_size': parse_comma_separated(chunk_sizes),
+                    'overlap_size': parse_comma_separated(overlap_sizes),
+                    'vector_store_type': vector_store_types,
+                    'search_type': search_types,
+                    'top_k': parse_comma_separated(top_k_values),
+                    'optimize_vocab': [optimize_vocab],
+                    'use_query_optimization': [use_query_optimization],
+                    'use_reranking': [use_reranking],
+                    'lang': ['en'],  # Default to English
+                    'apply_preprocessing': [True],  # Default preprocessing
+                    'apply_phonetic': [False],  # Default phonetic settings
+                    'phonetic_weight': [0.5],
+                    'custom_separators': [None],
+                    'query_optimization_model': ['gpt-3.5-turbo']  # Default query optimization model
+                }
+                
+                # Run automated tests
+                results_df, stats_df = run_automated_tests(
+                    file_input.name if file_input else None,
+                    query_input,
+                    model_configs,
+                    test_params,
+                    expected_result if expected_result else None,
+                    model_feedback if model_feedback else None
+                )
+                
+                # Generate recommendations based on results
+                recommendations = generate_recommendations(stats_df)
+                
+                return results_df, stats_df, recommendations
+        
             auto_submit_button = gr.Button("Run Automated Tests")
             auto_submit_button.click(
-                fn=lambda *args: run_automated_tests(*args),
+                fn=run_automation,
                 inputs=[
-                    auto_file_input, auto_query_input, auto_expected_result_input, auto_model_types, auto_model_names,
+                    auto_file_input, auto_query_input, auto_expected_result_input,
+                    default_models_input, custom_models_input,
                     auto_split_strategies, auto_chunk_sizes, auto_overlap_sizes,
                     auto_vector_store_types, auto_search_types, auto_top_k,
-                    auto_optimize_vocab, auto_use_query_optimization, auto_use_reranking
+                    auto_optimize_vocab, auto_use_query_optimization, auto_use_reranking,
+                    model_feedback_input
                 ],
                 outputs=[auto_results_output, auto_stats_output, recommendations_output]
             )
-            ###
+        ###
             
         with gr.Tab("Results"):
             with gr.Row():