PyPI - mg-pso-gui - Versions diffs - 0.0.1__py3-none-any.whl - Mend

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

Files changed (19) hide show

mg-pso-gui/BoundsEditorWindow.py +74 -0
mg-pso-gui/BoundsList.py +263 -0
mg-pso-gui/CTkToolTip/__init__.py +11 -0
mg-pso-gui/CTkToolTip/ctk_tooltip.py +187 -0
mg-pso-gui/CalibrationParametersView.py +61 -0
mg-pso-gui/FunctionsList.py +83 -0
mg-pso-gui/GraphGenerator.py +215 -0
mg-pso-gui/ListParametersView.py +173 -0
mg-pso-gui/OptionManager.py +259 -0
mg-pso-gui/PSORunner.py +68 -0
mg-pso-gui/StaticParameterView.py +61 -0
mg-pso-gui/StepView.py +118 -0
mg-pso-gui/__init__.py +1 -0
mg-pso-gui/main.py +485 -0
mg_pso_gui-0.0.1.dist-info/LICENSE +21 -0
mg_pso_gui-0.0.1.dist-info/METADATA +23 -0
mg_pso_gui-0.0.1.dist-info/RECORD +19 -0
mg_pso_gui-0.0.1.dist-info/WHEEL +5 -0
mg_pso_gui-0.0.1.dist-info/top_level.txt +1 -0

mg-pso-gui/GraphGenerator.py ADDED Viewed

@@ -0,0 +1,215 @@
+import plotly.express as px
+import plotly.graph_objs as go
+import pandas as pd
+import numpy as np
+def best_cost_stacked(config, dataframe):
+    fig = go.Figure()
+    total_steps = len(config)
+    # Get unique values from the round_step column of the dataframe
+    for iteration in dataframe['round_step'].unique():
+        # Get best_cost and completed rounds rows for this iteration
+        df = dataframe[dataframe['round_step'] == iteration]
+        step_index = ((iteration) % total_steps)
+        round_index = ((iteration) // total_steps)
+        fig.add_trace(go.Scatter(x=df['completed_rounds'], y=df['best_cost'], name='Round ' + str(round_index + 1) +  ' Step ' + str(step_index + 1)))
+    fig.update_layout(
+        title="",
+        xaxis_title="Iteration",
+        yaxis_title="Best Cost",
+        font=dict(color='white'),
+        paper_bgcolor='rgba(42, 42, 42, 0)',
+        plot_bgcolor='rgb(62, 62, 62)',
+        xaxis=dict(
+            gridcolor='rgb(72, 72, 72)',
+            gridwidth=1
+        ),
+        yaxis=dict(
+            range=[0, 0.6],
+            autorange='reversed',
+            gridcolor='rgb(72, 72, 72)',
+            gridwidth=0.1
+        )
+    )
+    fig.write_image("./best_cost_stacked.png", width=1280, height=720)
+    fig.write_html("./best_cost_stacked.html", include_plotlyjs='cdn', auto_open=False)
+    with open("./best_cost_stacked.html", "r") as f:
+        html = f.read()
+        html = html.replace("<body>", "<body bgcolor='#2a2a2a'>")
+    with open("./best_cost_stacked.html", "w") as f:
+        f.write(html)
+    return fig
+def table(config, dataframe):
+    # Create a plotly table with the values in the dataframe
+    fig = go.Figure(data=[go.Table(
+        header=dict(
+            values=list(dataframe.columns),
+            font=dict(color='black'),
+            align="left"
+        ),
+        cells=dict(
+            values=[dataframe[k].tolist() for k in dataframe.columns],
+            font=dict(color='black'),
+            align = "left")
+    )])
+    fig.update_layout(
+        title="",
+        xaxis_title="Iteration",
+        yaxis_title="Best Cost",
+        font=dict(color='white'),
+        paper_bgcolor='rgba(42, 42, 42, 0)',
+        plot_bgcolor='rgb(62, 62, 62)',
+        xaxis=dict(
+            gridcolor='rgb(72, 72, 72)',
+            gridwidth=1
+        ),
+        yaxis=dict(
+            range=[0, 0.6],
+            autorange='reversed',
+            gridcolor='rgb(72, 72, 72)',
+            gridwidth=0.1
+        )
+    )
+    fig.write_image("./table.png", width=1280, height=720)
+    fig.write_html("./table.html", include_plotlyjs='cdn', auto_open=False)
+    with open("./table.html", "r") as f:
+        html = f.read()
+        html = html.replace("<body>", "<body bgcolor='#2a2a2a'>")
+    with open("./table.html", "w") as f:
+        f.write(html)
+    return fig
+def best_cost_by_round(config, dataframe):
+    fig = go.Figure()
+    total_steps = len(config)
+    # Get unique values from the round_step column of the dataframe
+    for iteration in dataframe['round_step'].unique():
+        # Get best_cost and completed rounds rows for this iteration
+        df = dataframe[dataframe['round_step'] == iteration]
+        step_index = ((iteration) % total_steps)
+        round_index = ((iteration) // total_steps)
+        fig.add_trace(go.Scatter(x=df['completed_rounds'] + (df['total_rounds'] * round_index), y=df['best_cost'], name='Step ' + str(step_index + 1)))
+        xx = np.max(df['completed_rounds']) + (np.max(df['total_rounds']) * round_index)
+        fig.add_shape(
+            type='line',
+            x0=xx,
+            y0=0,
+            x1=xx,
+            y1=1,
+            yref='paper',
+            line=dict(
+                color='rgb(102, 102, 102)',
+                width=2
+            )
+        )
+        fig.add_annotation(
+            x=xx + 0.5,
+            y=1,
+            yref='paper',
+            text='Round ' + str(round_index + 1),
+            showarrow=False,
+            yshift=-10
+        )
+    fig.update_layout(
+        title="",
+        xaxis_title="Iteration",
+        yaxis_title="Best Cost",
+        font=dict(color='white'),
+        paper_bgcolor='rgba(42, 42, 42, 0)',
+        plot_bgcolor='rgb(62, 62, 62)',
+        xaxis=dict(
+            gridcolor='rgb(72, 72, 72)',
+            gridwidth=1
+        ),
+        yaxis=dict(
+            range=[0, 0.6],
+            autorange='reversed',
+            gridcolor='rgb(72, 72, 72)',
+            gridwidth=0.1
+        )
+    )
+    fig.write_image("./best_cost_by_round.png", width=1280, height=720)
+    fig.write_html("./best_cost_by_round.html", include_plotlyjs='cdn', auto_open=False)
+    with open("./best_cost_by_round.html", "r") as f:
+        html = f.read()
+        html = html.replace("<body>", "<body bgcolor='#2a2a2a'>")
+    with open("./best_cost_by_round.html", "w") as f:
+        f.write(html)
+    return fig
+def calibrated_params_by_round(config, list_of_objs):
+    fig = go.Figure()
+    total_steps = len(config)
+    datalines = {"step": [], "round": []}
+    step = 1
+    round = 1
+    for index, obj in enumerate(list_of_objs):
+        if (obj == {}):
+            continue
+        for key in obj.keys():
+            if key not in datalines:
+                datalines[key] = []
+            datalines[key].append(obj[key])
+        datalines["step"].append(step)
+        datalines['round'].append(round)
+        step += 1
+        if (step > total_steps):
+            step = 1
+            round += 1
+    # Get unique values from the round_step column of the dataframe
+    for key in datalines.keys():
+        # Get best_cost and completed rounds rows for this iteration
+        if key == 'step' or key == 'round':
+            continue
+        fig.add_trace(go.Scatter(x=datalines['round'], y=datalines[key], name=key))
+    fig.update_layout(
+        title="",
+        xaxis_title="Round",
+        yaxis_title="Particle Parameters",
+        font=dict(color='white'),
+        paper_bgcolor='rgba(42, 42, 42, 0)',
+        plot_bgcolor='rgb(62, 62, 62)',
+        xaxis=dict(
+            gridcolor='rgb(72, 72, 72)',
+            gridwidth=1
+        ),
+        yaxis=dict(
+            gridcolor='rgb(72, 72, 72)',
+            gridwidth=0.1
+        )
+    )
+    fig.write_image("./calibrated_params_by_round.png", width=1280, height=720)
+    fig.write_html("./calibrated_params_by_round.html", include_plotlyjs='cdn', auto_open=False)
+    with open("./calibrated_params_by_round.html", "r") as f:
+        html = f.read()
+        html = html.replace("<body>", "<body bgcolor='#2a2a2a'>")
+    with open("./calibrated_params_by_round.html", "w") as f:
+        f.write(html)
+    return fig

mg-pso-gui/ListParametersView.py ADDED Viewed

@@ -0,0 +1,173 @@
+from customtkinter import CTkScrollableFrame
+from customtkinter import CTkFrame
+from customtkinter import CTkLabel
+from customtkinter import CTkButton
+from customtkinter import CTkEntry
+import tkinter as tk
+import subprocess
+global option_manager
+class ListParametersView(CTkScrollableFrame):
+    def __init__(self, *args,
+                 option_manager: None,
+                 step_index: 0,
+                 bound_index: 0,
+                 **kwargs):
+        super().__init__(*args, **kwargs)
+        self.option_manager = option_manager
+        self.step_index = step_index
+        self.bounds_index = bound_index
+        self.key_values = []
+        self.visual_name = tk.StringVar()
+        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()
+        try:
+            if self.name != "" and self.default != "":
+                self.visual_name.set(self.name.rsplit('/', 1)[0] + '/')
+                self.names = self.name.split('/')
+                self.rows = self.names[-1].split(';')
+                self.defaults = self.default.replace("[", "").replace("]", "").replace("(", "").replace(")", "").replace(" ", "").split(",")
+                print("rows", self.rows)
+                print("defaults", self.defaults)
+                index = 0
+                for name in self.rows:
+                    obj = {"name": tk.StringVar(), "value": tk.StringVar()}
+                    obj['name'].set(name)
+                    obj['value'].set(self.defaults[index])
+                    self.key_values.append(obj)
+                    index += 1
+        except Exception as e:
+            print(e)
+        if (len(self.key_values) == 0):
+            self.add_key()
+        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 add_key(self, key="0000", value="0"):
+        obj = {"name": tk.StringVar(), "value": tk.StringVar()}
+        obj['name'].set(key)
+        obj['value'].set(value)
+        self.key_values.append(obj)
+    def remove_key(self, index):
+        self.key_values.pop(index)
+    def open_csv(self):
+        # Shell out to the terminal and run "open ./example.html"
+        path = self.visual_name.get()
+        path = path.replace(" ", "")
+        file_path = path.split("/")[0]
+        subprocess.run(["open", "./" + file_path])
+    def import_csv(self):
+        # Get data from the clipboard using Tkinter
+        data = self.clipboard_get()
+        lines = data.split('\n')
+        # Initialize empty lists for the two columns
+        column1 = []
+        column2 = []
+        # Loop through each line and split it into two values
+        for line in lines:
+            if line.strip() != '':
+                values = line.split()
+                column1.append(values[0])
+                column2.append(values[1])
+        # Print the two columns
+        print(column1)
+        print(column2)
+        if (len(column1) == len(column2)):
+            self.clear()
+            index = 0
+            for name in column1:
+                self.add_key(name, column2[index])
+                index += 1
+            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="Path:").grid(row=row, column=0, columnspan=2, padx=5, pady=5, sticky="")
+        row += 1
+        self.path_name = CTkEntry(self.containerFrame, textvariable=self.visual_name)
+        self.path_name.grid(row=row, column=0, columnspan=2, padx=(5, 5), pady=(5, 5), sticky="ew")
+        row += 1
+        CTkButton(self.containerFrame, text="Open", command=self.open_csv).grid(row=row, column=0, padx=(5, 5), pady=(5, 5), sticky="ew")
+        CTkButton(self.containerFrame, text="Import", command=self.import_csv).grid(row=row, column=1, padx=(5, 5), pady=(5, 5), sticky="ew")
+        row += 1
+        CTkLabel(self.containerFrame, text="Row:").grid(row=row, column=0, columnspan=1, padx=5, pady=5, sticky="")
+        CTkLabel(self.containerFrame, text="Default:").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.remove_key(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.add_key(), self.render())
+        CTkButton(self.containerFrame, text="Add", command=add_key_func).grid(row=row, column=1, padx=(5, 5), pady=(5, 5), sticky="ew")
+        row += 1
+    def push_to_option_manager(self):
+        visual_name = self.visual_name.get()
+        default_values = "["
+        first = True
+        for key_value_pair in self.key_values:
+            if first:
+                visual_name += key_value_pair['name'].get()
+                first = False
+            else:
+                visual_name += ";" + key_value_pair['name'].get()
+            default_values += key_value_pair['value'].get() + ","
+        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)

mg-pso-gui/OptionManager.py ADDED Viewed

@@ -0,0 +1,259 @@
+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": sv()}
+        self.arguments = {"param": [],
+                 "url": sv(),
+                 "files": {},
+                 "calibration_parameters": []}
+        self.steps = []
+        self.service_parameters = {}
+    def clear(self):
+        self.arguments['param'].clear()
+        self.arguments['url'].set("")
+        self.arguments['files'] = {}
+        self.arguments['calibration_parameters'].clear()
+        self.steps = []
+        self.service_parameters = {}
+    def add_arguments(self, arguments):
+        if ("url" in arguments):
+            self.arguments["url"].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)
+    def add_steps(self, steps):
+        for step in steps:
+            obj = {"param": [], "objfunc": [], "name": sv(), "message": sv(), "open": False}
+            obj["name"].set("Step " + str(len(self.steps) + 1))
+            obj["message"].set("Wow")
+            for param in step["param"]:
+                param_obj = {
+                    "name": sv(),
+                    "bounds": (sv(), sv()),
+                    "default_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 "calibration_strategy" in param:
+                    param_obj["calibration_strategy"].set(param["calibration_strategy"])
+                else:
+                    param_obj["calibration_strategy"].set("none")
+                obj["param"].append(param_obj)
+            for objfunc in step["objfunc"]:
+                objfunc_obj = {"name": sv(), "of": sv(), "weight": sv(), "data": (sv(), sv())}
+                objfunc_obj["name"].set(objfunc["name"])
+                objfunc_obj["of"].set(objfunc["of"])
+                if ("weight" in objfunc):
+                    objfunc_obj["weight"].set(objfunc["weight"])
+                else:
+                    objfunc_obj["weight"].set(1)
+                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(), "data": (sv(), sv())}
+        obj["name"].set("ns")
+        obj["of"].set("ns")
+        obj["weight"].set(1)
+        obj["data"][0].set("")
+        obj["data"][1].set("")
+        self.steps[step_index]["objfunc"].append(obj)
+    def remove_function(self, step_index, index):
+        self.steps[step_index]["objfunc"].pop(index)
+    def add_bound(self, step_index,
+                  name="name",
+                  min=0,
+                  max=1,
+                  type="float",
+                  default_value=1,
+                  calibration_strategy="none"):
+        obj = {
+            "name": sv(),
+            "bounds": (sv(), sv()),
+            "default_value": sv(),
+            "type": sv(),
+            "calibration_strategy": sv()
+        }
+        obj["name"].set(name)
+        obj["type"].set(type)
+        obj["default_value"].set(default_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_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 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_step(self, index):
+        self.steps.pop(index)
+    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 get_metrics(self):
+        result = {}
+        result['arguments'] = {}
+        result['calibration_parameters'] = []
+        for key, value in self.arguments.items():
+            if key == 'url':
+                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()})
+        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()),
+                            '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(),
+                            '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