pythonQEPest 2.0.0a2__py3-none-any.whl

pythonQEPest/dto/normalisation/Normaliser.py

@@ -0,0 +1,16 @@
+from typing import Union
+
+
+class Normaliser:
+    def __init__(self, arr: Union[tuple, list]):
+        # if len(arr) != 6:
+        #     raise ValueError(f"Array must be exact length of 6. Given: {len(arr)}")
+
+        self.arr = arr
+
+    def norm(self, d: Union[int, float], descr: int) -> float:
+        if descr > len(self.arr):
+            raise KeyError(f"Out of array. {descr} > {len(self.arr)}")
+
+        max_val = self.arr[int(descr)]
+        return d / max_val if max_val != 0 else 0.0

pythonQEPest/dto/normalisation/__init__.py

@@ -0,0 +1,3 @@
+from pythonQEPest.dto.normalisation.Normaliser import Normaliser
+
+__all__ = ["Normaliser"]

pythonQEPest/dto/pest_type/PestTypeCoefficient.py

@@ -0,0 +1,30 @@
+from typing import Any
+
+from pydantic import BaseModel, model_validator
+
+
+class PestTypeCoefficient(BaseModel):
+    mwH: tuple[float, float, float, float]
+    logpH: tuple[float, float, float, float]
+    hbaH: tuple[float, float, float, float]
+    hbdH: tuple[float, float, float, float]
+    rbH: tuple[float, float, float, float]
+    arRCH: tuple[float, float, float, float]
+
+    @model_validator(mode="before")
+    @classmethod
+    def accept_positional(cls, data: Any):
+        if isinstance(data, dict):
+            return data
+
+        if isinstance(data, (list, tuple)):
+            if len(data) != 6:
+                raise ValueError("Expected 6 items: mwH, logpH, hbaH, hbdH, rbH, arRCH")
+
+            keys = ("mwH", "logpH", "hbaH", "hbdH", "rbH", "arRCH")
+            return dict(zip(keys, data))
+
+        raise TypeError("Expected a dict or a 6-item tuple/list")
+
+    def as_set(self):
+        return [self.mwH, self.logpH, self.hbaH, self.hbdH, self.rbH, self.arRCH]

pythonQEPest/dto/pest_type/PestTypeConfig.py

@@ -0,0 +1,9 @@
+from pydantic import BaseModel
+
+from pythonQEPest.dto.pest_type.PestTypeCoefficient import PestTypeCoefficient
+
+
+class PestTypeConfig(BaseModel):
+    name: str
+    coefficients: PestTypeCoefficient
+    normaliser: tuple[float, float, float, float, float, float]

pythonQEPest/dto/pest_type/__init__.py

@@ -0,0 +1,4 @@
+from pythonQEPest.dto.pest_type.PestTypeCoefficient import PestTypeCoefficient
+from pythonQEPest.dto.pest_type.PestTypeConfig import PestTypeConfig
+
+__all__ = ["PestTypeConfig", "PestTypeCoefficient"]

pythonQEPest/gui/__init__.py

@@ -0,0 +1,7 @@
+def main():
+    from pythonQEPest.gui.gui import main as _main
+
+    return _main()
+
+
+__all__ = ["main"]

pythonQEPest/gui/actions/__init__.py

@@ -0,0 +1,9 @@
+from pythonQEPest.gui.actions.action_clicks import GUIActionsClicks
+from pythonQEPest.gui.actions.actions_crud import GUIActionsCRUD
+from pythonQEPest.gui.actions.actions_other import GUIActionsOther
+
+__all__ = [
+    "GUIActionsClicks",
+    "GUIActionsCRUD",
+    "GUIActionsOther",
+]

pythonQEPest/gui/actions/action_clicks.py

@@ -0,0 +1,42 @@
+class GUIActionsClicks:
+    def __init__(self, menu):
+        self.menu = menu
+
+    def on_treeview_click_left(self, event):
+        tree = event.widget
+        item_id = tree.identify_row(event.y)
+        if not item_id:
+            return
+        selected = tree.selection()
+        if item_id in selected:
+            tree.selection_remove(item_id)
+        else:
+            tree.selection_set(item_id)  # [*selected, item_id]
+
+    def on_treeview_click_right(self, event):
+        tree = event.widget
+        item_id = tree.identify_row(event.y)
+        if item_id:
+            tree.selection_set(item_id)
+            self.menu.tk_popup(event.x_root, event.y_root)
+
+    def resize_columns(self, event):
+        widget = event.widget
+        region = widget.identify("region", event.x, event.y)
+        if region != "separator":
+            return
+
+        col = widget.identify_column(event.x)
+        if not col:
+            return
+
+        col_index = int(col.replace("#", "")) - 1
+        col_id = widget["columns"][col_index]
+
+        max_width = max(
+            [len(str(widget.set(k, col_id))) for k in widget.get_children("")]
+            + [len(col_id)]
+        )
+
+        pixel_width = max_width * 8
+        widget.column(col_id, width=pixel_width)

pythonQEPest/gui/actions/actions_crud.py

@@ -0,0 +1,131 @@
+from tkinter import messagebox, ttk
+
+try:
+    import pyperclip
+except ImportError:
+    pyperclip = None
+
+from pythonQEPest.gui.elements.EditWindow import EditWindow
+from pythonQEPest.gui.utility.DataManager import DataManager
+
+
+class GUIActionsCRUD:
+    def __init__(self, data_tree, result_tree, save_button, index):
+        self.index = index
+        self.data_manager = DataManager()
+        self.data_tree: ttk.Treeview = data_tree
+        self.result_tree: ttk.Treeview = result_tree
+        self.save_button = save_button
+
+    def edit_selected(self, *args, **kwargs):
+        selected = self.data_tree.selection()
+        if not selected:
+            messagebox.showwarning("Select Entry", "Select Entry for editing")
+            return
+
+        item_id = selected[0]
+        EditWindow(item_id=item_id, tree=self.data_tree, child_tree=self.result_tree)
+
+    def copy_selected(self, *args, **kwargs):
+        selected_data_tree = self.data_tree.selection()
+        selected_result_tree = self.result_tree.selection()
+
+        if not (selected_data_tree or selected_result_tree):
+            messagebox.showwarning("Select Entry", "Select Entry for coping")
+            return
+
+        rows_text = []
+        if selected_data_tree:
+            rows_text.append(
+                "\t".join(
+                    map(str, ("ID", "Name", "MW", "LogP", "HBA", "HBD", "RB", "arR"))
+                )
+            )
+            for item in selected_data_tree:
+                values = self.data_tree.item(item, "values")[1:]
+                rows_text.append("\t".join(map(str, values)))
+
+        if selected_result_tree:
+            rows_text.append("\t".join(map(str, ("ID", "Name", "QEH", "QEI", "QEF"))))
+            for item in selected_result_tree:
+                values = self.result_tree.item(item, "values")[1:]
+                rows_text.append("\t".join(map(str, values)))
+
+        data_str = "\n".join(rows_text)
+
+        if not pyperclip:
+            messagebox.showerror(
+                "Error",
+                "pyperclip module is not installed. Install it with command"
+                + "'pip install .[gui]' or 'poetry install --with ui'"
+                + "to enable copy functionality.",
+            )
+            return
+
+        pyperclip.copy(data_str)
+        messagebox.showinfo("Copied", "Data copied to clipboard.")
+
+    def paste_entries(self, *args, **kwargs):
+        if not pyperclip:
+            messagebox.showerror(
+                "Error",
+                "pyperclip module is not installed. Install it with command"
+                + "'pip install .[gui]' or 'poetry install --with ui'"
+                + "to enable copy functionality.",
+            )
+            return
+
+        clipboard_text = pyperclip.paste()
+        if not clipboard_text.strip():
+            messagebox.showwarning("Clipboard is empty", "Copy the text first.")
+            return
+
+        lines = clipboard_text.strip().splitlines()
+        count_added = 0
+
+        for line in lines:
+            parts = line.strip().split("\t")
+            if len(parts) == 7:
+                idx = self.index
+                self.data_manager.add_file((idx, *parts))
+                self.data_tree.insert("", "end", values=(idx, *parts))
+                count_added += 1
+                self.index += 1
+
+        if count_added:
+            messagebox.showinfo(
+                "Inserted",
+                f"Inserted {count_added} entries. Don't forget to process the data.",
+            )
+
+    def delete_selected(self, *args, **kwargs):
+        selected = self.data_tree.selection()
+        if not selected:
+            messagebox.showwarning("Select Entry", "Select the entry to delete.")
+            return
+
+        idxs_to_remove = []
+        for item in selected:
+            values = self.data_tree.item(item, "values")
+            idx_to_remove = int(values[0])
+            idxs_to_remove.append(idx_to_remove)
+
+            self.data_tree.delete(item)
+
+            if self.result_tree.exists(item):
+                self.result_tree.delete(item)
+
+        self.data_manager.remove_result_by_ids(idxs_to_remove)
+        self.data_manager.remove_file_by_ids(idxs_to_remove)
+
+        messagebox.showinfo("Deleted", "The selected records have been deleted.")
+
+        if not self.data_manager:
+            self.save_button.config(state="disabled")
+
+    def clear_everything(self, *args, **kwargs):
+        self.data_manager.clear_file()
+        self.data_manager.clear_result()
+
+        self.data_tree.delete(*self.data_tree.get_children())
+        self.result_tree.delete(*self.result_tree.get_children())

pythonQEPest/gui/actions/actions_other.py

@@ -0,0 +1,126 @@
+import tkinter as tk
+from tkinter import filedialog, messagebox
+
+from pythonQEPest.dto.QEPestInput import QEPestInput
+from pythonQEPest.gui.utility.DataManager import DataManager
+
+
+class GUIActionsOther:
+    def __init__(self, root, data_tree, result_tree, save_button, qepest):
+        self.data_manager = DataManager()
+        self.root = root
+        self.data_tree = data_tree
+        self.result_tree = result_tree
+        self.save_button = save_button
+        self.qepest = qepest
+
+    def load_file(self):
+        file_path = filedialog.askopenfilename(
+            filetypes=[("Text files", "*.txt"), ("CSV files", "*.csv")]
+        )
+        if not file_path:
+            return
+
+        try:
+            with open(file_path, "r", encoding="utf-8") as file:
+                self.data_manager.clear_file()
+                self.data_tree.delete(*self.data_tree.get_children())
+
+                for idx, line in enumerate(file):
+                    parts = line.strip().split("\t")
+                    if len(parts) == 7:
+                        self.data_manager.add_file((idx, *parts))
+                        self.data_tree.insert("", "end", values=(idx, *parts))
+
+            messagebox.showinfo(
+                "File uploaded", f"Loaded {len(self.data_manager.file_data)} rows."
+            )
+        except Exception as e:
+            messagebox.showerror("Loading error", str(e))
+
+    def add_entry(self):
+        form = tk.Toplevel(self.root)
+        form.title("Add entry")
+        form.transient(self.root)
+        form.grab_set()
+
+        entries = {}
+        fields = ["Name", "MW", "LogP", "HBA", "HBD", "RB", "arR"]
+
+        for idx, field in enumerate(fields):
+            tk.Label(form, text=field).grid(
+                row=idx, column=0, padx=5, pady=5, sticky="e"
+            )
+            entry = tk.Entry(form)
+            entry.grid(row=idx, column=1, padx=5, pady=5)
+            entries[field] = entry
+
+        def submit():
+            values = []
+            for field in fields:
+                val = entries[field].get().strip()
+                if not val:
+                    messagebox.showwarning("Error", f"The field {field} not filled.")
+                    return
+                values.append(val)
+
+            idx = len(self.data_manager.file_data)
+            self.data_manager.add_file((idx, *values))
+            self.data_tree.insert("", "end", values=(idx, *values))
+            form.destroy()
+            messagebox.showinfo(
+                "Added",
+                "The entry has been added. Process the data to update the result.",
+            )
+
+        tk.Button(form, text="Add", command=submit).grid(
+            row=len(fields), column=0, columnspan=2, pady=10
+        )
+
+        form.wait_window()
+
+    def process_data(self):
+        if not self.data_manager.file_data:
+            messagebox.showwarning("No data", "Please add or upload data first.")
+            return
+
+        # self.result_data = []
+        # self.result_tree.delete(*self.result_tree.get_children())
+
+        for row in self.data_manager.file_data:
+            try:
+                result_row = [
+                    row[0],
+                    *self.qepest.compute_params(
+                        QEPestInput.from_array(row[1:])
+                    ).to_array(),
+                ]
+            except ValueError as e:
+                messagebox.showwarning("Warning!", f"Line number: {row[0]}\n{str(e)}")
+                continue
+            self.data_manager.add_result(result_row)
+            self.result_tree.insert("", "end", values=result_row)
+
+        self.save_button.config(state="normal")
+
+    def save_result(self):
+        if not self.data_manager.result_data:
+            messagebox.showwarning("No result", "Process the data first.")
+            return
+
+        save_path = filedialog.asksaveasfilename(
+            defaultextension=".txt", filetypes=[("Text files", "*.txt")]
+        )
+        if not save_path:
+            return
+
+        try:
+            with open(save_path, "w", encoding="utf-8") as file:
+                file.write("Name\tQEH\tQEI\tQEF\n")
+                for row in self.data_manager.result_data:
+                    file.write("\t".join(map(str, row)) + "\n")
+
+            messagebox.showinfo("Saved", f"The result is saved in: {save_path}")
+
+        except Exception as e:
+            messagebox.showerror("Saving error", str(e))

pythonQEPest/gui/elements/ButtonsFrame.py

@@ -0,0 +1,50 @@
+from tkinter import Frame, Button
+
+try:
+    import pyperclip
+except ImportError:
+    pyperclip = None
+
+
+class ButtonsFrame(Frame):
+    def __init__(self, root, *args, **kwargs):
+        super().__init__(root, *args, **kwargs)
+
+        self.pack(anchor="w", fill="x", pady=5)
+
+        # TODO: select_file must have an option for CSV
+        self.select_file_button = Button(self, text="Select File")
+        self.add_entry_button = Button(self, text="Add entry")
+        self.edit_entry_button = Button(self, text="Edit entry")
+        self.delete_selected_button = Button(self, text="Delete entry")
+        self.copy_button = Button(self, text="Copy Data")
+        self.paste_button = Button(self, text="Paste Data")
+
+        self.process_data_button = Button(self, text="Process Data")
+        self.clear_button = Button(self, text="Clear Data")
+
+    def set_actions(self, actions_crud, actions_other):
+        self.select_file_button.pack(side="left", padx=(10, 4))
+        self.add_entry_button.pack(side="left", padx=4)
+        self.edit_entry_button.pack(side="left", padx=4)
+        self.delete_selected_button.pack(side="left", padx=4)
+
+        if not pyperclip:
+            self.copy_button.config(state="disabled")
+            self.paste_button.config(state="disabled")
+
+        self.copy_button.pack(side="left", padx=4)
+        self.paste_button.pack(side="left", padx=4)
+
+        self.process_data_button.pack(side="right", padx=(4, 10))
+        self.clear_button.pack(side="right", padx=4)
+
+        self.select_file_button.config(command=actions_other.load_file)
+        self.add_entry_button.config(command=actions_other.add_entry)
+        self.edit_entry_button.config(command=actions_crud.edit_selected)
+        self.delete_selected_button.config(command=actions_crud.delete_selected)
+        self.copy_button.config(command=actions_crud.copy_selected)
+        self.paste_button.config(command=actions_crud.paste_entries)
+
+        self.process_data_button.config(command=actions_other.process_data)
+        self.clear_button.config(command=actions_crud.clear_everything)

pythonQEPest/gui/elements/DataTree.py

@@ -0,0 +1,23 @@
+from tkinter.ttk import Treeview
+
+
+class DataTree(Treeview):
+    def __init__(self, root, *args, **kwargs):
+        columns = ("ID", "Name", "MW", "LogP", "HBA", "HBD", "RB", "arR")
+        super().__init__(root, *args, columns=columns, show="headings", **kwargs)
+
+        for col in columns:
+            self.heading(col, text=col)
+
+        self.pack(padx=10, pady=10, fill="both", expand=True)
+
+    def set_actions(self, sort_column, actions_clicks):
+        for col in self["columns"]:
+            self.heading(
+                col, text=col, command=lambda _col=col: sort_column(self, _col, False)
+            )
+
+        self.bind("<Button-1>", actions_clicks.on_treeview_click_left)
+        self.bind("<Button-3>", actions_clicks.on_treeview_click_right)
+
+        self.bind("<Double-1>", actions_clicks.resize_columns)

pythonQEPest/gui/elements/EditWindow.py

@@ -0,0 +1,63 @@
+import tkinter as tk
+from tkinter.ttk import Treeview
+
+from pythonQEPest.gui.utility.DataManager import DataManager
+
+
+class EditWindow(tk.Toplevel):
+    def __init__(self, tree: Treeview, child_tree: Treeview, item_id, *args, **kwargs):
+        super().__init__(*args, master=tree, **kwargs)
+
+        self.title("Edit Entry")
+        # self.geometry("200x300")
+
+        self.data_manager = DataManager()
+
+        values = tree.item(item_id, "values")
+        old_id = values[0]
+
+        entries = []
+        columns = tree["columns"]
+
+        self.grid_columnconfigure(0, weight=0)
+        self.grid_columnconfigure(1, weight=3)
+        self.resizable(True, False)
+
+        for idx, col in enumerate(columns):
+            tk.Label(self, text=col).grid(
+                row=idx, column=0, padx=5, pady=5, sticky="ew"
+            )
+            entry = tk.Entry(self)
+            entry.insert(0, values[idx])
+            entry.grid(row=idx, column=1, padx=(5, 5), pady=5, sticky="ew")
+            entries.append(entry)
+
+        def save_changes() -> None:
+            new_values = [entry.get() for entry in entries]
+
+            if child_tree.exists(item_id):
+                new_child_values = list(child_tree.item(item_id, "values"))
+                if new_child_values[0] != new_values[0]:
+                    new_child_values[0] = new_values[0]
+                    child_tree.item(item_id, values=new_child_values)
+
+            tree.item(item_id, values=new_values)
+
+            # Fix it someday plz
+            new_values[0] = int(new_values[0])
+            update_file_data(new_values)
+
+        def update_file_data(values: list) -> None:
+            element = list(
+                filter(lambda x: str(x[0]) == str(old_id), self.data_manager.file_data)
+            )[0]
+            if element:
+                self.data_manager.update_file(index=element[0], new_entry=values)
+            self.destroy()
+
+        tk.Button(self, text="Save", command=save_changes).grid(
+            row=len(columns), column=0, columnspan=2, pady=10
+        )
+
+        self.grab_set()
+        self.wait_window()

pythonQEPest/gui/elements/Menu.py

@@ -0,0 +1,12 @@
+from tkinter import Menu as tkMenu
+
+
+class Menu(tkMenu):
+    def __init__(self, root, *args, **kwargs):
+        super().__init__(root, *args, **kwargs, tearoff=0)
+
+    def set_actions(self, actions_crud):
+        self.add_command(label="Copy", command=actions_crud.copy_selected)
+        self.add_command(label="Edit", command=actions_crud.edit_selected)
+        self.add_command(label="Paste", command=actions_crud.paste_entries)
+        self.add_command(label="Delete", command=actions_crud.delete_selected)

pythonQEPest/gui/elements/ResultTree.py

@@ -0,0 +1,22 @@
+from tkinter.ttk import Treeview
+
+
+class ResultTree(Treeview):
+    def __init__(self, root, *args, **kwargs):
+        columns = ("ID", "Name", "QEH", "QEI", "QEF")
+        super().__init__(root, *args, columns=columns, show="headings", **kwargs)
+
+        for col in columns:
+            self.heading(col, text=col)
+        self.pack(padx=10, pady=10, fill="both", expand=True)
+
+    def set_actions(self, sort_column, actions_clicks):
+        for col in self["columns"]:
+            self.heading(
+                col, text=col, command=lambda _col=col: sort_column(self, _col, False)
+            )
+
+        self.bind("<Button-1>", actions_clicks.on_treeview_click_left)
+        self.bind("<Button-3>", actions_clicks.on_treeview_click_right)
+
+        self.bind("<Double-1>", actions_clicks.resize_columns)

pythonQEPest/gui/elements/SaveButton.py

@@ -0,0 +1,10 @@
+from tkinter import Button
+
+
+class SaveButton(Button):
+    def __init__(self, root, *args, **kwargs):
+        super().__init__(root, *args, text="Save Results", state="disabled", **kwargs)
+        self.pack(padx=10, pady=10, side="right")
+
+    def set_actions(self, actions_other):
+        self.config(command=actions_other.save_result)

pythonQEPest/gui/elements/__init__.py

@@ -0,0 +1,17 @@
+from pythonQEPest.gui.elements import (
+    ResultTree,
+    DataTree,
+    ButtonsFrame,
+    Menu,
+    SaveButton,
+    EditWindow,
+)
+
+__all__ = [
+    "ResultTree",
+    "DataTree",
+    "ButtonsFrame",
+    "Menu",
+    "SaveButton",
+    "EditWindow",
+]

pythonQEPest/gui/gui.py

@@ -0,0 +1,87 @@
+import tkinter as tk
+
+from dotenv import load_dotenv
+
+from pythonQEPest.logger import init_logger
+
+try:
+    import pyperclip
+except ImportError:
+    pyperclip = None
+
+from pythonQEPest.gui.actions import GUIActionsCRUD
+from pythonQEPest.gui.actions import GUIActionsClicks
+from pythonQEPest.gui.actions import GUIActionsOther
+from pythonQEPest.gui.elements.ButtonsFrame import ButtonsFrame
+from pythonQEPest.gui.elements.DataTree import DataTree
+from pythonQEPest.gui.elements.Menu import Menu
+from pythonQEPest.gui.elements.ResultTree import ResultTree
+from pythonQEPest.gui.elements.SaveButton import SaveButton
+from pythonQEPest.gui.gui_meta import QEPestMeta
+
+
+# TODO: Outdated. Must be dynamic
+class GUI(QEPestMeta):
+    def treeview_sort_column(self, treeview, col, reverse):
+        treeview_lst = [(treeview.set(k, col), k) for k in treeview.get_children("")]
+        try:
+            treeview_lst.sort(key=lambda t: float(t[0]), reverse=reverse)
+        except ValueError:
+            treeview_lst.sort(key=lambda t: t[0], reverse=reverse)
+
+        for index, (_, k) in enumerate(treeview_lst):
+            treeview.move(k, "", index)
+
+        treeview.heading(
+            col, command=lambda: self.treeview_sort_column(treeview, col, not reverse)
+        )
+
+    def build_gui(self):
+        self.file_data = []
+        self.index = 0
+
+        self.buttons_frame = ButtonsFrame(root=self.root)
+        self.data_tree = DataTree(root=self.root)
+        self.result_tree = ResultTree(root=self.root)
+        self.save_button = SaveButton(root=self.root)
+        self.menu = Menu(root=self.root)
+
+        self.actions_clicks = GUIActionsClicks(menu=self.menu)
+        self.actions_crud = GUIActionsCRUD(
+            data_tree=self.data_tree,
+            result_tree=self.result_tree,
+            save_button=self.save_button,
+            index=self.index,
+        )
+
+        self.actions_other = GUIActionsOther(
+            data_tree=self.data_tree,
+            result_tree=self.result_tree,
+            qepest=self.qepest,
+            root=self.root,
+            save_button=self.save_button,
+        )
+
+        self.buttons_frame.set_actions(self.actions_crud, self.actions_other)
+        self.data_tree.set_actions(self.treeview_sort_column, self.actions_clicks)
+        self.result_tree.set_actions(self.treeview_sort_column, self.actions_clicks)
+        self.save_button.set_actions(self.actions_other)
+        self.menu.set_actions(self.actions_crud)
+
+        if pyperclip:
+            self.root.bind("<Control-v>", self.actions_crud.paste_entries)
+            self.root.bind("<Control-c>", self.actions_crud.copy_selected)
+
+
+def main() -> int:
+    load_dotenv()
+    init_logger()
+
+    root = tk.Tk()
+    GUI(root)
+    root.mainloop()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())