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

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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