mg-pso-gui 0.0.193__tar.gz → 0.0.195__tar.gz

{mg-pso-gui-0.0.193 → mg-pso-gui-0.0.195}/PKG-INFO

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

{mg-pso-gui-0.0.193 → mg-pso-gui-0.0.195}/mg_pso_gui.egg-info/PKG-INFO

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

{mg-pso-gui-0.0.193 → mg-pso-gui-0.0.195}/mgpsogui/gui/HomePage.py

@@ -26,6 +26,8 @@ import ast
 import platform
 import time
 
+from queue import Empty
+
 from ..util import PSORunner
 from ..util import GraphGenerator
 
@@ -48,6 +50,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 +347,7 @@ class App(customtkinter.CTk):
             info = self.option_manager.get_project_data()
             folder = os.path.join(info['path'], info['name'])
             
-            self.process_queue = Queue()
-            self.train_process = Process(target=PSORunner.run_process, args=(self.process_queue, 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 +408,16 @@ class App(customtkinter.CTk):
             
         if not os.path.exists(folder):
             os.makedirs(folder)
+            
+        try:
+            stdout_line = stdout_queue.get_nowait()
+            stderr_line = stderr_queue.get_nowait()
+        except Empty:
+            pass  # No output yet
+        else:
+            # Got line from the output: do something
+            print(f"Received stdout: {stdout_line}")
+            print(f"Received stderr: {stderr_line}")
         
         if (os.path.exists(os.path.join(folder, 'output.txt'))):
             with open(os.path.join(folder, 'output.txt'), 'r') as f:

{mg-pso-gui-0.0.193 → mg-pso-gui-0.0.195}/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.195/mgpsogui/util/PSORunner.py

@@ -0,0 +1,176 @@
+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'))
+    
+    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.193 → mg-pso-gui-0.0.195}/setup.py

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

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

@@ -1,74 +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(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))
-