mg-pso-gui 0.1.243__py3-none-any.whl → 0.2.0__py3-none-any.whl

mgpsogui/gui/OptionManager_backup.py

@@ -0,0 +1,443 @@
+from tkinter import StringVar as sv
+from tkinter import IntVar as iv
+from tkinter import BooleanVar as bv
+from tkinter import DoubleVar as dv
+import json
+
+class OptionManager():
+    
+    def __init__(self):
+        
+        self.project_data = {"name": "", "path": ""}
+        self.arguments = {"param": [],
+                 "url": sv(),
+                 "urls": {},
+                 "mode": sv(),
+                 "files": {},
+                 "calibration_parameters": [],
+                 "service_parameters": [],
+                 "figure_parameters": [],
+                 "sensitivity_parameters": [],
+                 "sensitivity_positiveBestMetrics": [],
+                 "sensitivity_negativeBestMetrics": []}
+        
+        self.steps = []
+        self.service_parameters = {}
+
+        self.service_modes = ["Sampling: Halton", "Sampling: Random", "Sensitivity Analysis", "Optimization"]
+        for mode in self.service_modes:
+            self.arguments["urls"][mode] = sv()
+
+            
+    def clear(self):
+        self.arguments['param'].clear()
+        self.arguments['url'].set("")
+        for mode in self.service_modes:
+            self.arguments["urls"][mode].set("")
+        self.arguments['mode'].set("Optimization")
+        self.arguments['files'] = {}
+        self.arguments['calibration_parameters'].clear()
+        self.arguments['service_parameters'].clear()
+        self.arguments['figure_parameters'].clear()
+        self.arguments['sensitivity_parameters'].clear()
+        self.arguments['sensitivity_positiveBestMetrics'].clear()
+        self.arguments['sensitivity_negativeBestMetrics'].clear()
+        self.steps = []
+        self.service_parameters = {}
+    
+    def add_arguments(self, arguments):
+            
+        if ("mode" in arguments):
+            self.arguments["mode"].set(arguments["mode"])
+
+        if ("url" in arguments):
+            self.arguments["urls"][self.arguments["mode"].get()].set(arguments["url"])
+            
+        if ("files" in arguments):
+            for file in arguments["files"]:
+                name = file["name"]
+                value = file["value"]
+                obj = {"name": sv(), "value": sv()}
+                obj["name"].set(name)
+                obj["value"].set(value)
+                self.arguments["files"][name] = obj
+        
+        for param in arguments["param"]:
+            name = param["name"]
+            value = param["value"]
+            obj = {"name": sv(), "value": sv()}
+            obj["name"].set(name)
+            obj["value"].set(value)
+            self.arguments["param"].append(obj)
+            
+        for param in arguments["calibration_parameters"]:
+            name = param["name"]
+            value = param["value"]
+            obj = {"name": sv(), "value": sv()}
+            obj["name"].set(name)
+            obj["value"].set(value)
+            self.arguments["calibration_parameters"].append(obj)
+
+        for param in arguments["service_parameters"]:
+            name = param["name"]
+            value = param["value"]
+            obj = {"name": sv(), "value": sv()}
+            obj["name"].set(name)
+            obj["value"].set(value)
+            self.arguments["service_parameters"].append(obj)
+            
+    def add_steps(self, steps):
+        for step in steps:
+            obj = {"param": [], 
+                    "overrideparam": [],
+                    "objfunc": [], 
+                    "name": sv(), 
+                    "open": False}
+            obj["name"].set("Group " + str(len(self.steps) + 1))
+            
+            if "param" in step:
+                for param in step["param"]:
+                    param_obj = {
+                        "name": sv(), 
+                        "bounds": (sv(), sv()), 
+                        "default_value": sv(), 
+                        "optimal_value": sv(), 
+                        "type": sv(),
+                        "calibration_strategy": sv()
+                    }
+                    param_obj["name"].set(param["name"])
+                    if "bounds" in param:
+                        param_obj["bounds"][0].set(param["bounds"][0])
+                        param_obj["bounds"][1].set(param["bounds"][1]) 
+                    else: 
+                        param_obj["bounds"][0].set(0)
+                        param_obj["bounds"][1].set(1)
+                        
+                    if "type" in param:
+                        param_obj["type"].set(param["type"])
+                    else:
+                        param_obj["type"].set("float")
+                        
+                    if "default_value" in param:
+                        param_obj["default_value"].set(param["default_value"])
+                    else:
+                        param_obj["default_value"].set(1)
+                        
+                    if "optimal_value" in param:
+                        param_obj["optimal_value"].set(param["optimal_value"])
+                    else:
+                        param_obj["optimal_value"].set(0)
+                        
+                    if "calibration_strategy" in param:
+                        param_obj["calibration_strategy"].set(param["calibration_strategy"])
+                    else:
+                        param_obj["calibration_strategy"].set("none")
+                        
+                    obj["param"].append(param_obj)
+            
+            if "overrideparam" in step:
+                for override in step["overrideparam"]:
+                    override_obj = {"name": sv(), "value": sv()}
+                    override_obj['name'].set(override['name'])
+                    override_obj['value'].set(override['value'])
+                    obj['overrideparam'].append(override_obj)
+
+            if "objfunc" in step:
+                for objfunc in step["objfunc"]:
+                    objfunc_obj = {"name": sv(), 
+                                    "of": sv(), 
+                                    "weight": sv(), 
+                                    "custom_function": sv(),
+                                    "custom_function_goal": sv(),
+                                    "custom_function_value": sv(),
+                                    "data": (sv(), sv())}
+                    objfunc_obj["name"].set(objfunc["name"])
+                    objfunc_obj["of"].set(objfunc["of"])
+                    objfunc_obj["custom_function_goal"].set("Positive Best")
+                    
+                    if ("weight" in objfunc): 
+                        objfunc_obj["weight"].set(objfunc["weight"])
+                    else:
+                        objfunc_obj["weight"].set(1)
+                        
+                    if ("custom_function" in objfunc):
+                        objfunc_obj["custom_function"].set(objfunc["custom_function"])
+                    if ("custom_function_goal" in objfunc):
+                        objfunc_obj["custom_function_goal"].set(objfunc["custom_function_goal"])
+                    if ("custom_function_value" in objfunc):
+                        objfunc_obj["custom_function_value"].set(objfunc["custom_function_value"])
+
+                    objfunc_obj["data"][0].set(objfunc["data"][0])
+                    objfunc_obj["data"][1].set(objfunc["data"][1]) 
+                    obj["objfunc"].append(objfunc_obj)
+            
+            self.steps.append(obj)
+    
+    def add_function(self, step_index):
+        obj = {"name": sv(), 
+                "of": sv(), 
+                "weight": sv(), 
+                "custom_function": sv(),
+                "custom_function_goal": sv(),
+                "custom_function_value": sv(),
+                "data": (sv(), sv())}
+        obj["name"].set("ns")
+        obj["of"].set("ns")
+        obj["weight"].set(1)
+        obj["data"][0].set("")
+        obj["data"][1].set("")
+        obj["custom_function"].set("") 
+        obj["custom_function_goal"].set("")
+        obj["custom_function_value"].set("") 
+        
+        self.steps[step_index]["objfunc"].append(obj)
+        
+    def remove_function(self, step_index, index):
+        self.steps[step_index]["objfunc"].pop(index)
+        
+    def dupe_function(self, step_index, index):
+        my_func = self.steps[step_index]["objfunc"][index]
+        
+        new_object = {"name": sv(), 
+                        "of": sv(), 
+                        "weight": sv(), 
+                        "custom_function": sv(),
+                        "custom_function_goal": sv(),
+                        "custom_function_value": sv(),
+                        "data": (sv(), sv())}
+        new_object["name"].set(my_func["name"].get())
+        new_object["of"].set(my_func["of"].get())
+        new_object["weight"].set(my_func["weight"].get())
+        new_object["data"][0].set(my_func["data"][0].get())
+        new_object["data"][1].set(my_func["data"][1].get())
+        new_object["custom_function"].set(my_func["custom_function"].get())
+        new_object["custom_function_goal"].set(my_func["custom_function_goal"].get())
+        new_object["custom_function_value"].set(my_func["custom_function_value"].get())
+        
+        self.steps[step_index]["objfunc"].append(new_object)
+    
+    def add_bound(self, step_index, 
+                  name="name", 
+                  min=0, 
+                  max=1,
+                  type="float",
+                  default_value=1,
+                  optimal_value=0,
+                  calibration_strategy="none"):
+        obj = {
+            "name": sv(), 
+            "bounds": (sv(), sv()), 
+            "default_value": sv(), 
+            "optimal_value": sv(),
+            "type": sv(),
+            "calibration_strategy": sv()
+        }
+        obj["name"].set(name)
+        obj["type"].set(type)
+        obj["default_value"].set(default_value)
+        obj["optimal_value"].set(optimal_value)
+        obj["calibration_strategy"].set(calibration_strategy)
+        obj["bounds"][0].set(min)
+        obj["bounds"][1].set(max)
+        self.steps[step_index]["param"].append(obj)
+        
+    def remove_bound(self, step_index, index):
+        self.steps[step_index]["param"].pop(index)
+        
+    def add_override(self, step_index, name, value):
+        obj = {"name": sv(), "value": sv()}
+        obj["name"].set(name)
+        obj["value"].set(value)
+        self.steps[step_index]["overrideparam"].append(obj)
+
+    def remove_override(self, step_index, index):
+        self.steps[step_index]["overrideparam"].pop(index)
+
+    def get_override(self, step_index):
+        return self.steps[step_index]["overrideparam"]
+
+    def add_argument(self, key, value):
+        obj = {"name": sv(), "value": sv()}
+        obj["name"].set(key)
+        obj["value"].set(value)
+        self.arguments["param"].append(obj)
+        
+    def add_calibration_param(self, key, value):
+        obj = {"name": sv(), "value": sv()}
+        obj["name"].set(key)
+        obj["value"].set(value)
+        self.arguments["calibration_parameters"].append(obj)
+
+    def add_service_param(self, key, value):
+        obj = {"name": sv(), "value": sv()}
+        obj["name"].set(key)
+        obj["value"].set(value)
+        self.arguments["service_parameters"].append(obj)
+
+    def add_figure_param(self, key, value):
+        obj = {"name": sv(), "value": sv()}
+        obj["name"].set(key)
+        obj["value"].set(value)
+        self.arguments["figure_parameters"].append(obj)
+
+    def add_sensitivity_param(self, key, value):
+        obj = {"name": sv(), "value": sv()}
+        obj["name"].set(key)
+        obj["value"].set(value)
+        self.arguments["sensitivity_parameters"].append(obj)
+
+    def add_sensitivity_positiveBestMetrics(self, key, value):
+        obj = {"name": sv(), "value": sv()}
+        obj["name"].set(key)
+        obj["value"].set(value)
+        self.arguments["sensitivity_positiveBestMetrics"].append(obj)
+
+    def add_sensitivity_negativeBestMetrics(self, key, value):
+        obj = {"name": sv(), "value": sv()}
+        obj["name"].set(key)
+        obj["value"].set(value)
+        self.arguments["sensitivity_negativeBestMetrics"].append(obj)
+    
+    def move_argument_up(self, index):
+        if index > 0:
+            self.arguments["param"][index], self.arguments["param"][index - 1] = self.arguments["param"][index - 1], self.arguments["param"][index]
+            
+    def move_argument_down(self, index):
+        if index < len(self.arguments["param"]) - 1:
+            self.arguments["param"][index], self.arguments["param"][index + 1] = self.arguments["param"][index + 1], self.arguments["param"][index]
+            
+    def move_step_up(self, index):
+        if index > 0:
+            self.steps[index], self.steps[index - 1] = self.steps[index - 1], self.steps[index]
+            
+    def move_step_down(self, index):
+        if index < len(self.steps) - 1:
+            self.steps[index], self.steps[index + 1] = self.steps[index + 1], self.steps[index]
+            
+    def toggle_step_open(self, index):
+        self.steps[index]["open"] = not self.steps[index]["open"]
+            
+    def remove_argument(self, index):
+        self.arguments["param"].pop(index)
+        
+    def remove_calibration_parameter(self, index):
+        self.arguments["calibration_parameters"].pop(index)
+
+    def remove_service_parameter(self, index):
+        self.arguments["service_parameters"].pop(index)
+
+    def remove_figure_parameter(self, index):
+        self.arguments["figure_parameters"].pop(index)
+
+    def remove_sensitivity_parameter(self, index):
+        self.arguments["sensitivity_parameters"].pop(index)
+
+    def remove_sensitivity_positiveBestMetrics(self, index):
+        self.arguments["sensitivity_positiveBestMetrics"].pop(index)
+
+    def remove_sensitivity_negativeBestMetrics(self, index):
+        self.arguments["sensitivity_negativeBestMetrics"].pop(index)
+        
+    def remove_step(self, index):
+        self.steps.pop(index)
+            
+    def get_project_data(self):
+        return self.project_data
+            
+    def set_path(self, filename):
+        file_name = filename.split("/")[-1].replace(".json", "")
+        path = filename.replace(file_name + ".json", "")
+        self.project_data["path"] = path
+        self.project_data["name"] = file_name
+            
+    def get_arguments(self):
+        return self.arguments
+    
+    def get_steps(self):
+        return self.steps
+        
+    def get_all_as_json(self):
+        obj = {"arguments": self.arguments, "steps": self.steps}
+        return obj
+    
+    def set_service_parameters(self, service_parameters):
+        self.service_parameters = service_parameters
+    
+    def get_service_parameters(self):
+        return self.service_parameters
+
+    def get_metrics(self):
+
+        self.arguments["url"].set(self.arguments["urls"][self.arguments["mode"].get()].get())
+
+        result = {}
+        result['arguments'] = {}
+        result['calibration_parameters'] = []
+        result['service_parameters'] = []
+        result['service_parameters'] = {}
+        result['project_data'] = self.project_data
+        for key, value in self.arguments.items():
+            if key == 'url' or key == 'mode':
+                result['arguments'][key] = value.get()
+            elif key == 'files':
+                result['arguments'][key] = {}
+                #for name, obj in value.items():
+                #    result['arguments'][key].append({'name': obj['name'].get(), 'value': obj['value'].get()})
+            elif key == 'param':
+                result['arguments'][key] = []
+                for obj in value:
+                    result['arguments'][key].append({'name': obj['name'].get(), 'value': obj['value'].get()})
+            elif key == "calibration_parameters":
+                #result['calibration_parameters'][key] = []
+                for obj in value:
+                    result['calibration_parameters'].append({'name': obj['name'].get(), 'value': obj['value'].get()})
+            elif key == "service_parameters":
+                #result['service_parameters'][key] = []
+                for obj in value:
+                    result['service_parameters'].append({'name': obj['name'].get(), 'value': obj['value'].get()})
+        result['steps'] = []
+        for step in self.steps:
+            step_result = {}
+            #step_result['name'] = step['name'].get()
+            #step_result['open'] = step['open']
+            step_result['param'] = []
+            for param in step['param']:
+                # try converting the bounds to numbers
+                #try:
+                if param['type'].get() == 'float':
+                    step_result['param'].append(
+                        {
+                            'name': param['name'].get(), 
+                            'bounds': (float(param['bounds'][0].get()), 
+                                       float(param['bounds'][1].get())),
+                            'default_value': float(param['default_value'].get()),
+                            'optimal_value': float(param['optimal_value'].get()),
+                            'type': 'float',
+                            'calibration_strategy': param['calibration_strategy'].get()
+                        }
+                    )
+                elif param['type'].get() == 'list':
+                    step_result['param'].append(
+                        {
+                            'name': param['name'].get(), 
+                            'bounds': (float(param['bounds'][0].get()), 
+                                       float(param['bounds'][1].get())),
+                            'default_value': param['default_value'].get(),
+                            'optimal_value': param['optimal_value'].get(),
+                            'type': 'list',
+                            'calibration_strategy': param['calibration_strategy'].get()
+                        }
+                    )
+                #except ValueError:
+                #    step_result['param'].append(
+                #        {
+                #            'name': param['name'].get(), 
+                #            'bounds': (param['bounds'][0].get(), 
+                #                       param['bounds'][1].get())
+                #        }
+                #    )
+            step_result['objfunc'] = []
+            for objfunc in step['objfunc']:
+                step_result['objfunc'].append({'name': objfunc['name'].get(), 'of': objfunc['of'].get(), 'weight': float(objfunc['weight'].get()), 'data': (objfunc['data'][0].get(), objfunc['data'][1].get())})
+            result['steps'].append(step_result)
+        return result

mgpsogui/gui/PlatformTab/PlatformTab.py

@@ -5,7 +5,7 @@ import subprocess
 import customtkinter
 import platform
 
-from . import ServiceParametersView as spv
+from ..General import ParameterView as pv
 
 import tkinter as tk
 
@@ -18,7 +18,7 @@ def create_tab(self, tab):
         response_json = json.loads(response.text)
         status = response.status_code
         
-        self.option_manager.set_service_parameters(response_json)
+        self.option_manager.set_data(response_json)
         self.tabview.configure(state="enabled")
         
         self.service_status.delete('0.0', tk.END)
@@ -135,7 +135,7 @@ def create_tab(self, tab):
     
     """
 
-    self.service_param_frame = spv.ServiceParametersView(tab, option_manager=self.option_manager, label_text="Service Parameters")
+    self.service_param_frame = pv.ParameterView(tab, option_manager=self.option_manager, list_name="service_parameters", label_text="Service Parameters")
     self.service_param_frame.grid(row=0, column=0, padx=(20, 20), pady=(20, 20), sticky="nsew")
     self.service_param_frame.grid_columnconfigure(0, weight=1)
     self.service_param_frame.grid_rowconfigure(0, weight=1)

mgpsogui/gui/SetupTab/BoundsList.py

@@ -24,7 +24,7 @@ class BoundsList(CTkFrame):
         self.optParams = []
         self.option_manager = option_manager
 
-        details = self.option_manager.get_service_parameters()
+        details = self.option_manager.get("service_request_data")
         self.paramMap = {}
         if "parameter" in details:
             for param in details["parameter"]:
@@ -76,7 +76,7 @@ class BoundsList(CTkFrame):
         CTkLabel(self.containerFrame, text="Strategy:").grid(row=row, column=5, padx=(5, 5), pady=(5, 5), sticky="nsew")
         row += 1
         
-        bounds = self.option_manager.get_steps()[self.step_index]["param"]
+        bounds = self.option_manager.get_steps()[self.step_index]["parameter_objects"]
         
         for bound in bounds:
             tt1 = None
@@ -115,13 +115,13 @@ class BoundsList(CTkFrame):
                 bounds_min = CTkEntry(self.containerFrame)
                 vcmd = (self.register(self.validate_number), '%P', cc, bounds_min)
                 bounds_min.grid(row=row, column=2, padx=(5, 5), pady=(5, 5), sticky="new")
-                bounds_min.configure(textvariable=bound["bounds"][0], validate='all', validatecommand=vcmd)
+                bounds_min.configure(textvariable=bound["min_bound"], validate='all', validatecommand=vcmd)
                 self.validate_number(bounds_min.get(), cc, bounds_min)
                             
                 bounds_max = CTkEntry(self.containerFrame)
                 vcmd = (self.register(self.validate_number), '%P', cc, bounds_max)
                 bounds_max.grid(row=row, column=3, padx=(5, 5), pady=(5, 5), sticky="new")
-                bounds_max.configure(textvariable=bound["bounds"][1], validate='all', validatecommand=vcmd)
+                bounds_max.configure(textvariable=bound["max_bound"], validate='all', validatecommand=vcmd)
                 self.validate_number(bounds_max.get(), cc, bounds_max)
                 tt2 = ctt(bounds_max, delay=0.1, alpha=0.95, message="...")
                 
@@ -167,20 +167,20 @@ class BoundsList(CTkFrame):
             
     def update_type(self, index, option):
         value = option.get()
-        self.option_manager.get_steps()[self.step_index]["param"][index]["type"].set(value)
+        self.option_manager.get_steps()[self.step_index]["parameter_objects"][index]["type"].set(value)
         self.refresh()
             
     def update_values(self, index):
-        name = self.option_manager.get_steps()[self.step_index]["param"][index]["name"].get()
+        name = self.option_manager.get_steps()[self.step_index]["parameter_objects"][index]["name"].get()
         if name in self.paramMap:
             obj = self.paramMap[name]
-            self.option_manager.get_steps()[self.step_index]["param"][index]["bounds"][0].set(obj["softmin"])
-            self.option_manager.get_steps()[self.step_index]["param"][index]["bounds"][1].set(obj["softmax"])
+            self.option_manager.get_steps()[self.step_index]["parameter_objects"][index]["min_bound"].set(obj["softmin"])
+            self.option_manager.get_steps()[self.step_index]["parameter_objects"][index]["max_bound"].set(obj["softmax"])
             
     def update_tooltips(self, index):
         try:
-            name = self.option_manager.get_steps()[self.step_index]["param"][index]["name"].get()
-            bound_type = self.option_manager.get_steps()[self.step_index]["param"][index]["type"].get()
+            name = self.option_manager.get_steps()[self.step_index]["parameter_objects"][index]["name"].get()
+            bound_type = self.option_manager.get_steps()[self.step_index]["parameter_objects"][index]["type"].get()
             
             tooltips = self.tooltip_list[index]
             t3 = tooltips[0]

mgpsogui/gui/SetupTab/CustomFunctionMetrics.py

@@ -66,7 +66,7 @@ class CustomFunctionsMetricsView(CTkScrollableFrame):
                         "rmse": True,
                         "trmse": True}
 
-        equation = self.option_manager.get_steps()[self.step_index]["objfunc"][self.functions_index]["custom_function"].get()
+        equation = self.option_manager.get_steps()[self.step_index]["objective_functions"][self.functions_index]["custom_function"].get()
         
         # Example equation (0 * (1 - ns)) + (bias * 0) + (pbias * 0) + (absdiff * 0)
         try:
@@ -153,4 +153,4 @@ class CustomFunctionsMetricsView(CTkScrollableFrame):
 
         equation = equation[:-3]  # Remove the last " + "
 
-        self.option_manager.get_steps()[self.step_index]["objfunc"][self.functions_index]["custom_function"].set(equation)
+        self.option_manager.get_steps()[self.step_index]["objective_functions"][self.functions_index]["custom_function"].set(equation)

mgpsogui/gui/SetupTab/FunctionsList.py

@@ -45,7 +45,7 @@ class FunctionsList(CTkFrame):
         
         row = 1
         
-        funcs = self.option_manager.get_steps()[self.step_index]["objfunc"]
+        funcs = self.option_manager.get_steps()[self.step_index]["objective_functions"]
         
         index = 0
         for func in funcs:
@@ -78,20 +78,20 @@ class FunctionsList(CTkFrame):
                        "custom"]
             
             CTkEntry(self.containerFrame, textvariable=func["name"]).grid(row=row, column=0, padx=(5, 5), pady=(5, 5), sticky="ew")
-            CTkOptionMenu(self.containerFrame, values=columns, variable=func["of"], command=self.refresh).grid(row=row, column=1, padx=(5, 5), pady=(5, 5), sticky="ew")
+            CTkOptionMenu(self.containerFrame, values=columns, variable=func["objective_function"], command=self.refresh).grid(row=row, column=1, padx=(5, 5), pady=(5, 5), sticky="ew")
             CTkEntry(self.containerFrame, textvariable=func["weight"]).grid(row=row, column=2, padx=(5, 5), pady=(5, 5), sticky="ew")
             
             row += 1
 
-            if func["of"].get() == "custom":
+            if func["objective_function"].get() == "custom":
 
-                CTkLabel(self.containerFrame, text="Custom Function:").grid(row=row, column=0, columnspan=2, padx=(5, 5), pady=(5, 5), sticky="nsew")
-                CTkLabel(self.containerFrame, text="Target:").grid(row=row, column=2, padx=(5, 5), pady=(5, 5), sticky="nsew")
+                CTkLabel(self.containerFrame, text="Custom Function:").grid(row=row, column=0, columnspan=3, padx=(5, 5), pady=(5, 5), sticky="nsew")
+                #CTkLabel(self.containerFrame, text="Target:").grid(row=row, column=2, padx=(5, 5), pady=(5, 5), sticky="nsew")
 
                 row += 1
 
-                CTkEntry(self.containerFrame, textvariable=func["custom_function"]).grid(row=row, column=0, columnspan=2, padx=(5, 5), pady=(5, 5), sticky="ew")
-                CTkOptionMenu(self.containerFrame, values=["Positive Best", "Zero Best"], variable=func["custom_function_goal"]).grid(row=row, column=2, padx=(5, 5), pady=(5, 5), sticky="ew")
+                CTkEntry(self.containerFrame, textvariable=func["custom_function"]).grid(row=row, column=0, columnspan=3, padx=(5, 5), pady=(5, 5), sticky="ew")
+                #CTkOptionMenu(self.containerFrame, values=["Positive Best", "Zero Best"], variable=func["custom_function_goal"]).grid(row=row, column=2, padx=(5, 5), pady=(5, 5), sticky="ew")
 
                 def button_click_event(function_index):
                     dialog = CFEW(title="Edit Custom Function", step_index=self.step_index, function_index=function_index, option_manager=self.option_manager)

mgpsogui/gui/SetupTab/ListEditor.py

@@ -6,8 +6,6 @@ from customtkinter import CTkEntry
 from customtkinter import CTkOptionMenu
 import tkinter as tk
 
-global option_manager
-
 class ListEditor(CTkFrame):
     def __init__(self, *args,
                  option_manager: None,
@@ -24,7 +22,7 @@ class ListEditor(CTkFrame):
         self.parameter_name = parameter_name
         self.parameter_remove_func = parameter_remove_func
         self.parameter_add_func = parameter_add_func
-        self.key_values = option_manager.get_arguments()[self.parameter_name]
+        self.key_values = option_manager.get(self.parameter_name)
         self.edit_mode = False
         self.title = title
         

mgpsogui/gui/SetupTab/ListParametersView.py

@@ -26,8 +26,8 @@ class ListParametersView(CTkScrollableFrame):
         self.visual_name.set("name")
         
         
-        self.name = self.option_manager.get_steps()[self.step_index]["param"][bound_index]["name"].get()
-        self.default = self.option_manager.get_steps()[self.step_index]["param"][bound_index]["default_value"].get()
+        self.name = self.option_manager.get_steps()[self.step_index]["parameter_objects"][bound_index]["name"].get()
+        self.default = self.option_manager.get_steps()[self.step_index]["parameter_objects"][bound_index]["default_value"].get()
         try:
             if self.name != "" and self.default != "":
                 
@@ -75,8 +75,9 @@ class ListParametersView(CTkScrollableFrame):
         
     def open_csv(self):
         # Shell out to the terminal and run "open ./example.html"
-        info = self.option_manager.get_project_data()
-        folder = os.path.join(info['path'], info['name'])
+        #info = self.option_manager.get_project_data()
+        #folder = os.path.join(info['path'], info['name'])
+        folder = self.option_manager.get_project_folder()
         
         
         path = self.visual_name.get()
@@ -182,5 +183,5 @@ class ListParametersView(CTkScrollableFrame):
             
         default_values = default_values[:-1] + "]"
             
-        self.option_manager.get_steps()[self.step_index]["param"][self.bounds_index]["name"].set(visual_name)
-        self.option_manager.get_steps()[self.step_index]["param"][self.bounds_index]["default_value"].set(default_values)
+        self.option_manager.get_steps()[self.step_index]["parameter_objects"][self.bounds_index]["name"].set(visual_name)
+        self.option_manager.get_steps()[self.step_index]["parameter_objects"][self.bounds_index]["default_value"].set(default_values)

mgpsogui/gui/SetupTab/OptimalParameterView.py

@@ -5,8 +5,6 @@ from customtkinter import CTkButton
 from customtkinter import CTkEntry
 import tkinter as tk
 
-global option_manager
-
 class OptimalParameterView(CTkScrollableFrame):
     def __init__(self, *args,
                  option_manager: None,
@@ -27,17 +25,17 @@ class OptimalParameterView(CTkScrollableFrame):
         self.containerFrame.grid(row=0, column=0, padx=(5, 5), pady=(5, 5), sticky="nsew")
         self.containerFrame.grid_columnconfigure((0, 1), weight=1)
         
-        self.mode = self.option_manager.get_arguments()['mode'].get()
+        self.mode = self.option_manager.get_mode()
         self.steps = self.option_manager.get_steps()
 
         for step in self.steps:
             
-            if self.mode != "Sampling":
+            if self.mode != "Sampling: Random" and self.mode != "Sampling: Halton":
                 name = step['name'].get()
                 CTkLabel(self.containerFrame, text=name).grid(row=row, column=0, columnspan=1, padx=5, pady=5, sticky="")
                 row += 1
             
-            for param in step['param']:
+            for param in step['parameter_objects']:
                 CTkEntry(self.containerFrame, textvariable=param['name']).grid(row=row, column=0, padx=(5, 5), pady=(5, 5), sticky="ew")
             
                 bb = CTkEntry(self.containerFrame)