mg-pso-gui 0.0.192__tar.gz → 0.0.194__tar.gz

{mg-pso-gui-0.0.192 → mg-pso-gui-0.0.194}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mg-pso-gui
-Version: 0.0.192
+Version: 0.0.194
 Summary: GUI for MG-PSO
 Author: Robert Cordingly
 Author-email: <rcording@uw.ed>

{mg-pso-gui-0.0.192 → mg-pso-gui-0.0.194}/mg_pso_gui.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mg-pso-gui
-Version: 0.0.192
+Version: 0.0.194
 Summary: GUI for MG-PSO
 Author: Robert Cordingly
 Author-email: <rcording@uw.ed>

{mg-pso-gui-0.0.192 → mg-pso-gui-0.0.194}/mgpsogui/gui/HomePage.py

@@ -48,6 +48,10 @@ from ..util.CTkToolTip import CTkToolTip as ctt
 customtkinter.set_appearance_mode("Dark")  # Modes: "System" (standard), "Dark", "Light"
 customtkinter.set_default_color_theme("blue")  # Themes: "blue" (standard), "green", "dark-blue"
 
+results_queue = Queue()
+stdout_queue = Queue()
+stderr_queue = Queue()
+
 class App(customtkinter.CTk):
     def __init__(self):
         super().__init__()
@@ -341,8 +345,7 @@ class App(customtkinter.CTk):
             info = self.option_manager.get_project_data()
             folder = os.path.join(info['path'], info['name'])
             
-            
-            self.train_process = Process(target=PSORunner.run_process, args=(metrics, folder))
+            self.train_process = Process(target=PSORunner.run_process, args=(stdout_queue, stderr_queue, results_queue, metrics, folder))
             self.train_process.daemon = True
             self.train_process.start()
             self.after(1000, self.watch_loop)
@@ -403,6 +406,11 @@ class App(customtkinter.CTk):
             
         if not os.path.exists(folder):
             os.makedirs(folder)
+            
+        if (stdout_queue.qsize() > 0):
+            val = stdout_queue.get()
+            self.textbox.insert("0.0", val)
+            print(val)
         
         if (os.path.exists(os.path.join(folder, 'output.txt'))):
             with open(os.path.join(folder, 'output.txt'), 'r') as f:
@@ -504,6 +512,16 @@ class App(customtkinter.CTk):
         if self.train_process.is_alive():
             self.after(1000, self.watch_loop)
         else:
+            # Check if queue is empty
+            if (self.process_queue.empty()):
+                print("PROCESS FINISHED BUT WE GOT NO OBJECTS :(")
+                self.footer_progress_label.configure(text="Failed")
+            else:
+                self.final_results = self.process_queue.get()
+                print("PROCESS FINISHED WE GOT THINGS")
+                print(self.final_results)
+                self.footer_progress_label.configure(text="Finished")
+            
             #self.progress_bar.stop()
             self.footer_progress_bar.stop()
             #self.progress_bar.configure(mode="indeterminate")
@@ -513,7 +531,6 @@ class App(customtkinter.CTk):
             self.progress_message_left.configure(text="")
             self.progress_message_middle.configure(text="Calibration finished!")
             self.progress_message_right.configure(text="")
-            self.footer_progress_label.configure(text="Finished")
             self.textbox.insert("0.0", "\nCalibration finished!\n")
 
 def start():

{mg-pso-gui-0.0.192 → mg-pso-gui-0.0.194}/mgpsogui/gui/VisualizeTab/VisualizeTab.py

@@ -61,11 +61,11 @@ def create_tab(self, tab):
     
     self.graph_selector_value = tk.StringVar()
     self.graph_selector_value.set("Best Cost Stacked")
-    self.graph_selector = customtkinter.CTkOptionMenu(self.graph_sidebar, values=["Best Cost Stacked", "Best Cost by Round", "Calibrated Parameters", "Iteration Table"], variable=self.graph_selector_value, command=self.update_graph)
+    self.graph_selector = customtkinter.CTkOptionMenu(self.graph_sidebar, width=250, values=["Best Cost Stacked", "Best Cost by Round", "Calibrated Parameters", "Iteration Table"], variable=self.graph_selector_value, command=self.update_graph)
     self.graph_selector.grid(row=0, column=0, padx=(20, 20), pady=(20, 20), sticky="nsew")
     
     # Add a button to call open_graph_in_browser
-    self.graph_button = customtkinter.CTkButton(self.graph_sidebar, text="Open Graph in Browser", command=open_graph_in_browser)
+    self.graph_button = customtkinter.CTkButton(self.graph_sidebar, text="Open in Browser", width=250, command=open_graph_in_browser)
     self.graph_button.grid(row=9, column=0, padx=(20, 20), pady=(20, 20), sticky="nsew")
     
     self.graph_image_obj = Image.open(os.path.join("./images", "refresh_hd.png"))

{mg-pso-gui-0.0.192 → mg-pso-gui-0.0.194}/mgpsogui/util/GraphGenerator.py

@@ -4,7 +4,7 @@ import pandas as pd
 import numpy as np
 import os
 
-def best_cost_stacked(config, dataframe, option_manager):
+def best_coststacked(config, dataframe, option_manager):
     fig = go.Figure()
         
     total_steps = len(config)

mg-pso-gui-0.0.194/mgpsogui/util/PSORunner.py

@@ -0,0 +1,179 @@
+import csip
+import cosu
+import sys
+from multiprocessing import Process, Queue
+from queue import Empty
+import threading
+import time
+import os
+
+from cosu.pso import global_best
+
+def enqueue_output(out, queue):
+    for line in iter(out.readline, b''):
+        queue.put(line)
+    out.close()
+
+def run_process(stdout_queue, stderr_queue, results_queue, data, folder):
+    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 not os.path.exists(folder):
+        os.makedirs(folder)
+
+    if (os.path.exists(os.path.join(folder, 'output.txt'))):
+        os.remove(os.path.join(folder, 'output.txt'))
+        
+    if (os.path.exists(os.path.join(folder, 'error.txt'))):
+        os.remove(os.path.join(folder, 'error.txt'))
+
+    #sys.stdout = open(os.path.join(folder, 'output.txt'), 'w', buffering=1)
+    #sys.stderr = open(os.path.join(folder, 'error.txt'), 'w', buffering=1)
+    
+    old_stdout = sys.stdout
+    old_stderr = sys.stderr
+    
+    read_stdout, write_stdout = os.pipe()
+    read_stderr, write_stderr = os.pipe()
+    
+    sys.stdout = os.fdopen(write_stdout, 'w')
+    sys.stderr = os.fdopen(write_stderr, 'w')
+    
+    stdour_thread = threading.Thread(target=enqueue_output, args=(os.fdopen(read_stdout, 'r'), stdout_queue))
+    stderr_thread = threading.Thread(target=enqueue_output, args=(os.fdopen(read_stderr, 'r'), stderr_queue))
+    stdour_thread.daemon = True
+    stderr_thread.daemon = True
+    stdour_thread.start()
+    stderr_thread.start()
+    
+    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")
+    
+    print("Running global_best...\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'])
+                },
+        )  
+    
+    stdour_thread.join()
+    stderr_thread.join()
+    
+    sys.stdout = old_stdout
+    sys.stderr = old_stderr
+    results_queue.put((optimizer, trace))
+
+
+
+
+"""import csip
+import cosu
+import sys
+import multiprocessing
+import threading
+import time
+import os
+
+from cosu.pso import global_best
+
+def run_process(process_queue, data, folder):
+    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 not os.path.exists(folder):
+        os.makedirs(folder)
+
+    if (os.path.exists(os.path.join(folder, 'output.txt'))):
+        os.remove(os.path.join(folder, 'output.txt'))
+        
+    if (os.path.exists(os.path.join(folder, 'error.txt'))):
+        os.remove(os.path.join(folder, 'error.txt'))
+
+    sys.stdout = open(os.path.join(folder, 'output.txt'), 'w', buffering=1)
+    sys.stderr = open(os.path.join(folder, 'error.txt'), 'w', buffering=1)
+    
+    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")
+    
+    print("Running global_best...\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'])
+                },
+        )  
+    
+    process_queue.put((optimizer, trace))
+
+"""

{mg-pso-gui-0.0.192 → mg-pso-gui-0.0.194}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 import codecs
 import os
 
-VERSION = '0.0.192'
+VERSION = '0.0.194'
 DESCRIPTION = 'GUI for MG-PSO'
 LONG_DESCRIPTION = open('../README.md').read()
 

mg-pso-gui-0.0.192/mgpsogui/util/PSORunner.py

@@ -1,72 +0,0 @@
-import csip
-import cosu
-import sys
-import multiprocessing
-import threading
-import time
-import os
-
-from cosu.pso import global_best
-
-def run_process(data, folder):
-    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 not os.path.exists(folder):
-        os.makedirs(folder)
-
-    if (os.path.exists(os.path.join(folder, 'output.txt'))):
-        os.remove(os.path.join(folder, 'output.txt'))
-        
-    if (os.path.exists(os.path.join(folder, 'error.txt'))):
-        os.remove(os.path.join(folder, 'error.txt'))
-
-    sys.stdout = open(os.path.join(folder, 'output.txt'), 'w', buffering=1)
-    sys.stderr = open(os.path.join(folder, 'error.txt'), 'w', buffering=1)
-    
-    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")
-    
-    print("Running global_best...\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'])
-                },
-        )  
-