mg-pso-gui 0.0.1__py3-none-any.whl

mg-pso-gui/PSORunner.py

@@ -0,0 +1,68 @@
+import csip
+import cosu
+import sys
+import multiprocessing
+import threading
+import time
+import os
+
+from cosu.pso import global_best
+
+def run_process(data, queue):
+    steps = data['steps']
+    args = data['arguments']
+    calib = data['calibration_parameters']
+    
+    calibration_map = {}
+    for param in calib:
+        param_name = param['name']
+        param_value = param['value']
+        calibration_map[param_name] = param_value
+
+    if (os.path.exists('output.txt')):
+        os.remove('output.txt')
+        
+    if (os.path.exists('error.txt')):
+        os.remove('error.txt')
+
+    sys.stdout = open('output.txt', 'w')
+    sys.stderr = open('error.txt', 'w')
+    
+    options = {}
+    oh_strategy = {}
+    
+    for key in calibration_map.keys():
+        if "options_" in key:
+            options[key.replace("options_", "")] = float(calibration_map[key])
+        if "strategy_" in key:
+            oh_strategy[key.replace("strategy_", "")] = calibration_map[key]
+
+    print("\n")
+    print(calibration_map)
+    print("\n")
+    print(options)
+    print("\n")
+    print(oh_strategy)
+    print("\n")
+
+    optimizer, trace  = global_best(steps,                 # step definition
+            rounds=(int(calibration_map['min_rounds']), int(calibration_map['max_rounds'])),                              # min/max number of rounds
+            args=args,                                  # static arguments    
+            n_particles=int(calibration_map['n_particles']),                             # number of particle candidates for each param
+            iters=int(calibration_map['iters']),                                   # max # of iterations
+            n_threads=int(calibration_map['n_threads']),                               # number of threads to use
+            # ftol=0.00000001,                          # min cost function delta for convergence
+            options=options,       # hyperparameter
+            oh_strategy=oh_strategy,   # adaptive hyperparameter adjustments based on current and max # of iterations 
+            conf={
+                'service_timeout': int(calibration_map['service_timeout']),
+                'http_retry': int(calibration_map['http_retry']),
+                'http_allow_redirects': True if calibration_map['allow_redirects'] == "True" else False,
+                'async_call': True if calibration_map['async_call'] == "True" else False,
+                'http_conn_timeout': int(calibration_map['conn_timeout']),
+                'http_read_timeout': int(calibration_map['read_timeout']),
+                'particles_fail': int(calibration_map['particles_fail'])
+                },
+            result_queue=queue
+        )  
+    

mg-pso-gui/StaticParameterView.py

@@ -0,0 +1,61 @@
+from customtkinter import CTkScrollableFrame
+from customtkinter import CTkFrame
+from customtkinter import CTkLabel
+from customtkinter import CTkButton
+from customtkinter import CTkEntry
+import tkinter as tk
+
+global option_manager
+
+class StaticParameterView(CTkScrollableFrame):
+    def __init__(self, *args,
+                 option_manager: None,
+                 **kwargs):
+        super().__init__(*args, **kwargs)
+        
+        self.option_manager = option_manager
+        self.key_values = option_manager.get_arguments()['param']
+        self.edit_mode = False
+        
+        self.render()
+
+    def clear(self):
+        self.containerFrame.destroy()
+        
+    def toggle_edit_mode(self):
+        self.clear()
+        self.edit_mode = not self.edit_mode
+        self.render()
+        
+    def render(self):
+        row = 0
+        index = 0
+        
+        self.containerFrame = CTkFrame(self)
+        self.containerFrame.grid(row=0, column=0, padx=(5, 5), pady=(5, 5), sticky="nsew")
+        self.containerFrame.grid_columnconfigure((0, 1), weight=1)
+        
+        CTkLabel(self.containerFrame, text="Name:").grid(row=row, column=0, columnspan=1, padx=5, pady=5, sticky="")
+        CTkLabel(self.containerFrame, text="Value:").grid(row=row, column=1, columnspan=1, padx=5, pady=5, sticky="")
+        row += 1
+        
+        for key_value_pair in self.key_values:
+            CTkEntry(self.containerFrame, textvariable=self.key_values[index]["name"]).grid(row=row, column=0, padx=(5, 5), pady=(5, 5), sticky="ew")
+            
+            if self.edit_mode:
+                return_func = lambda index=index: (self.clear(), self.option_manager.remove_argument(index), self.render())
+                CTkButton(self.containerFrame, text="Remove", command=return_func).grid(row=row, column=1, padx=(5, 5), pady=(5, 5), sticky="ew")
+            else:
+                bb = CTkEntry(self.containerFrame)
+                bb.grid(row=row, column=1, padx=(5, 5), pady=(5, 5), sticky="ew")
+                bb.configure(textvariable=self.key_values[index]["value"])
+            row += 1
+            index += 1
+            
+        if self.edit_mode:
+            CTkButton(self.containerFrame, text="Exit", command=self.toggle_edit_mode).grid(row=row, column=0, padx=(5, 5), pady=(5, 5), sticky="ew")
+        else:
+            CTkButton(self.containerFrame, text="Edit", command=self.toggle_edit_mode).grid(row=row, column=0, padx=(5, 5), pady=(5, 5), sticky="ew")
+            
+        add_key_func = lambda: (self.clear(), self.option_manager.add_argument("name", "value"), self.render())
+        CTkButton(self.containerFrame, text="Add Parameter", command=add_key_func).grid(row=row, column=1, padx=(5, 5), pady=(5, 5), sticky="ew")

mg-pso-gui/StepView.py

@@ -0,0 +1,118 @@
+from customtkinter import CTkScrollableFrame
+from customtkinter import CTkFrame
+from customtkinter import CTkLabel
+from customtkinter import CTkButton
+from customtkinter import CTkEntry
+from customtkinter import CTkTextbox
+from customtkinter import CTkImage
+from PIL import Image
+import os
+
+import BoundsList
+import FunctionsList
+
+
+class StepView(CTkScrollableFrame):
+    def __init__(self, *args,
+                 option_manager: None,
+                 **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.option_manager = option_manager
+        
+        self.render()
+
+    def clear(self):
+        self.containerFrame.destroy()
+
+    def create_new_step(self):
+
+        self.clear()
+        example_step = [{    # step 1
+            'param': [
+                {
+                    'name': 'soilOutLPS',
+                    'bounds': (0.0, 2.0)
+                },
+                {
+                    'name': 'lagInterflow',
+                    'bounds': (10.0, 80.0)
+                }
+            ],
+            'objfunc': [
+                {
+                    'name': 'ns',
+                    'of': 'ns',
+                    'data': ('obs_data02_14.csv/obs/orun[1]',
+                             'output/csip_run/out/Outlet.csv/output/catchmentSimRunoff')
+                }
+            ],
+            'open': True
+        }]
+        self.option_manager.add_steps(example_step)
+
+        self.render()
+
+    def render(self):
+
+        row = 0
+        index = 0
+
+        self.containerFrame = CTkFrame(self)
+        self.containerFrame.grid(row=0, column=0, padx=(
+            10, 10), pady=(10, 10), sticky="nsew")
+        self.containerFrame.grid_columnconfigure((0, 1), weight=1)
+
+        self.steps = self.option_manager.get_steps()
+
+        for step in self.steps:
+
+            up_image = CTkImage(Image.open(os.path.join("./images", "up.png")), size=(20, 20))
+            down_image = CTkImage(Image.open(os.path.join("./images", "down.png")), size=(20, 20))
+            trash_image = CTkImage(Image.open(os.path.join("./images", "trash.png")), size=(20, 20))
+            expand_image = CTkImage(Image.open(os.path.join("./images", "expand.png")), size=(20, 20))
+            collapse_image = CTkImage(Image.open(os.path.join("./images", "collapse.png")), size=(20, 20))
+
+
+            expand_func = lambda index=index: (self.clear(), self.option_manager.toggle_step_open(index), self.render())
+            up_func = lambda index=index: (self.clear(), self.option_manager.move_step_up(index), self.render())
+            down_func = lambda index=index: (self.clear(), self.option_manager.move_step_down(index), self.render())
+            remove_func = lambda index=index: (self.clear(), self.option_manager.remove_step(index), self.render())
+            
+            #CTkLabel(self.containerFrame, text="Step:").grid(row=row, column=0, padx=10, pady=5, sticky="nsew")
+            
+            button_container = CTkFrame(self.containerFrame, width=200)
+            button_container.grid(row=row, column=1, sticky="nse", padx=(10, 10), pady=(10, 10))
+            button_container.grid_rowconfigure(0, weight=1)
+            button_container.grid_columnconfigure(0, weight=1)
+            
+            CTkEntry(self.containerFrame, textvariable=step['name'], width=500).grid(row=row, column=0, padx=(20, 20), pady=(20, 20), sticky="nsw")
+            #CTkLabel(self.containerFrame, textvariable=step['message']).grid(row=row, column=1, padx=(20, 20), pady=(20, 20), sticky="nsew")
+            CTkButton(button_container, width=30, text=None, image=expand_image if not step['open'] else collapse_image, command=expand_func).grid(row=0, column=0, padx=(10, 10), pady=(10, 10), sticky="nsew")
+            CTkButton(button_container, width=30, text=None, image=up_image, state="disabled" if index==0 else "normal", fg_color="gray" if index==0 else None, command=up_func).grid(row=0, column=1, padx=(10, 10), pady=(10, 10), sticky="nsew")
+            CTkButton(button_container, width=30, text=None, image=down_image, state="disabled" if index==(len(self.steps)-1) else "normal", fg_color="gray" if index==(len(self.steps)-1) else None, command=down_func).grid(row=0, column=2, padx=(10, 10), pady=(10, 10), sticky="nsew")
+            CTkButton(button_container, width=30, text=None, image=trash_image, command=remove_func).grid(row=0, column=3, padx=(10, 10), pady=(10, 10), sticky="nsew")
+
+            row += 1
+
+            if step['open']:
+                bounds = BoundsList.BoundsList(
+                    self.containerFrame, option_manager=self.option_manager, step_index=index)
+                bounds.grid(row=row, column=0, padx=(10, 10),
+                            pady=(10, 10), sticky="nsew")
+                bounds.grid_columnconfigure(0, weight=1)
+                bounds.grid_rowconfigure(0, weight=1)
+                
+                funcs = FunctionsList.FunctionsList(
+                    self.containerFrame, option_manager=self.option_manager, step_index=index)
+                funcs.grid(row=row, column=1, padx=(10, 10),
+                            pady=(10, 10), sticky="nsew")
+                funcs.grid_columnconfigure(0, weight=1)
+                funcs.grid_rowconfigure(0, weight=1)
+                
+            row += 1
+            index += 1
+
+        # Create an "Add step button that is centered
+        CTkButton(self.containerFrame, text="Add Step", command=self.create_new_step).grid(
+            row=row, columnspan=2, column=0, padx=(10, 10), pady=(10, 10), sticky="ew")

mg-pso-gui/__init__.py

@@ -0,0 +1 @@
+from main import start