qmenta-sdk-lib 2.2.dev3494__tar.gz → 2.2.dev3495__tar.gz

{qmenta_sdk_lib-2.2.dev3494 → qmenta_sdk_lib-2.2.dev3495}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qmenta-sdk-lib
-Version: 2.2.dev3494
+Version: 2.2.dev3495
 Summary: QMENTA SDK for tool development.
 Author: QMENTA
 Maintainer: Marc Ramos

{qmenta_sdk_lib-2.2.dev3494 → qmenta_sdk_lib-2.2.dev3495}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "qmenta-sdk-lib"
-version = "2.2.dev3494"
+version = "2.2.dev3495"
 description = "QMENTA SDK for tool development."
 authors = ["QMENTA"]
 packages = [

qmenta_sdk_lib-2.2.dev3495/python/qmenta/sdk/tool_maker/base_ui.py

@@ -0,0 +1,190 @@
+import os
+from tkinter import BOTH, CENTER, LEFT, RIGHT, TOP, YES, X, Y, messagebox
+
+import ttkbootstrap as ttk
+from PIL import Image, ImageTk
+
+# Constants for style
+FONT_HEADER = "Helvetica 16 bold"
+FONT_SUBHEADER = "Helvetica 12 bold"
+PADDING_OUTER = 20
+PADDING_ROW = 5
+
+
+class UnifiedToolWindow:
+    """
+    A unified GUI window class that provides standardized styling
+    and helper methods. Scrolling is optional.
+    """
+
+    def __init__(
+        self,
+        title="Tool GUI",
+        geometry="600x800",
+        theme="darkly",
+        scrollable=True,
+    ):
+        self.window = ttk.Window(themename=theme)
+        self.window.title(title)
+        self.window.geometry(geometry)
+
+        # Only allow resizing if specifically needed or strictly scrollable
+        self.window.resizable(True, True)
+
+        self.gui_content = {}
+        self.scrollable = scrollable
+
+        if self.scrollable:
+            self._setup_scroll_area()
+            self._setup_scroll_bindings()
+        else:
+            self._setup_static_area()
+
+    def _setup_scroll_area(self):
+        """Sets up the complex canvas and scrollbar structure."""
+        self.main_container = ttk.Frame(self.window)
+        self.main_container.pack(fill=BOTH, expand=YES)
+
+        self.canvas = ttk.Canvas(self.main_container)
+        self.vbar = ttk.Scrollbar(
+            self.main_container, orient="vertical", command=self.canvas.yview
+        )
+        self.canvas.configure(yscrollcommand=self.vbar.set)
+
+        self.vbar.pack(side=RIGHT, fill=Y)
+        self.canvas.pack(side=LEFT, fill=BOTH, expand=YES)
+
+        self.content_frame = ttk.Frame(self.canvas, padding=PADDING_OUTER)
+        self.canvas_window_id = self.canvas.create_window(
+            (0, 0), window=self.content_frame, anchor="nw", tags="inner_frame"
+        )
+
+    def _setup_static_area(self):
+        """Sets up a simple frame without scrolling."""
+        self.content_frame = ttk.Frame(self.window, padding=PADDING_OUTER)
+        self.content_frame.pack(fill=BOTH, expand=YES)
+
+    def _setup_scroll_bindings(self):
+        """
+        Sets up resize events and mousewheel scrolling
+        Only for scrollable windows
+        """
+        self.content_frame.bind(
+            "<Configure>",
+            lambda e: self.canvas.configure(
+                scrollregion=self.canvas.bbox("all")
+            ),
+        )
+        self.canvas.bind(
+            "<Configure>",
+            lambda e: self.canvas.itemconfig(
+                self.canvas_window_id, width=e.width
+            ),
+        )
+
+        def _on_mousewheel(event):
+            if event.delta:  # Windows/macOS
+                self.canvas.yview_scroll(
+                    int(-1 * (event.delta / 120)), "units"
+                )
+            elif event.num == 4:  # Linux Up
+                self.canvas.yview_scroll(-1, "units")
+            elif event.num == 5:  # Linux Down
+                self.canvas.yview_scroll(1, "units")
+
+        self.window.bind_all("<MouseWheel>", _on_mousewheel)
+        self.window.bind_all("<Button-4>", _on_mousewheel)
+        self.window.bind_all("<Button-5>", _on_mousewheel)
+
+    # --- Widget Helpers ---
+
+    def add_logo(self, relative_path="templates_tool_maker/qmenta.png"):
+        try:
+            img_path = os.path.join(os.path.dirname(__file__), relative_path)
+            if os.path.exists(img_path):
+                logo = Image.open(img_path).resize((500, 110))
+                img = ImageTk.PhotoImage(logo)
+                lbl = ttk.Label(
+                    master=self.content_frame, image=img, anchor=CENTER
+                )
+                lbl.image = img
+                lbl.pack(side=TOP, pady=(0, 20))
+        except Exception as e:
+            print(f"Image load failed: {e}")
+
+    def add_header(self, text, subtext=None, warning_text=None):
+        ttk.Label(self.content_frame, text=text, font=FONT_HEADER).pack(
+            pady=10
+        )
+        if subtext:
+            ttk.Label(self.content_frame, text=subtext, bootstyle="info").pack(
+                pady=(0, 5)
+            )
+        if warning_text:
+            ttk.Label(
+                self.content_frame, text=warning_text, bootstyle="warning"
+            ).pack(pady=(0, 20))
+
+    def add_section_label(self, text):
+        ttk.Label(self.content_frame, text=text, font=FONT_SUBHEADER).pack(
+            pady=10
+        )
+
+    def create_row(self, label_text, is_password=False, default=None):
+        frame = ttk.Frame(master=self.content_frame)
+        frame.pack(fill=X, pady=PADDING_ROW)
+
+        lbl = ttk.Label(master=frame, text=label_text, width=30)
+        lbl.pack(side=LEFT)
+
+        entry = ttk.Entry(master=frame, show="*" if is_password else None)
+        if default:
+            entry.insert(0, str(default))
+        entry.pack(side=LEFT, fill=X, expand=YES, padx=10)
+        return entry
+
+    def add_separator(self):
+        ttk.Separator(self.content_frame, orient="horizontal").pack(
+            fill=X, pady=20
+        )
+
+    def add_action_buttons(
+        self, submit_command, quit_command=None, submit_text="Publish"
+    ):
+        action_frame = ttk.Frame(master=self.content_frame)
+        action_frame.pack(pady=20)
+
+        def wrapped_submit():
+            if submit_command():
+                self.window.destroy()
+
+        def wrapped_quit():
+            if quit_command:
+                quit_command()
+            self.window.destroy()
+            exit()
+
+        ttk.Button(
+            master=action_frame,
+            text=submit_text,
+            command=wrapped_submit,
+            bootstyle="primary",
+        ).pack(side=LEFT, padx=10)
+
+        ttk.Button(
+            master=action_frame,
+            text="Quit",
+            command=wrapped_quit,
+            bootstyle="danger",
+        ).pack(side=LEFT, padx=10)
+
+    def run(self):
+        self.window.mainloop()
+
+    @staticmethod
+    def show_error(title, message):
+        messagebox.showerror(title, message)
+
+    @staticmethod
+    def show_info(title, message):
+        messagebox.showinfo(title, message)

qmenta_sdk_lib-2.2.dev3495/python/qmenta/sdk/tool_maker/integration_ui.py

@@ -0,0 +1,268 @@
+#! /usr/bin/env python
+
+import json
+import os
+import re
+from tkinter import END, LEFT, filedialog
+
+import ttkbootstrap as ttk
+from qmenta.core import platform
+from qmenta.core.auth import Needs2FAError
+from qmenta.sdk.tool_maker.make_files import raise_if_false
+
+# Import shared UI
+from base_ui import UnifiedToolWindow
+
+MIN = 0
+MAX_CORES = 10
+MAX_RAM = 16
+
+dir_name = None
+
+
+def gui_tkinter():
+    # Initialize the Shared Window
+    gui = UnifiedToolWindow(title="Tool Publishing GUI", scrollable=True)
+
+    # Logo & Headers
+    gui.add_logo()
+    gui.add_header(
+        "QMENTA Platform credentials",
+        warning_text="(*) indicates mandatory field.",
+    )
+
+    # Credential Fields
+    user_id_entry = gui.create_row("Username*")
+    password_entry = gui.create_row("Password*", is_password=True)
+
+    # Custom File Browse Row (Logic specific to this script)
+    write_dir = ttk.StringVar()
+
+    def browse_folder():
+        global dir_name
+        dir_name = filedialog.askdirectory()
+        write_dir.set(dir_name)
+        tool_id_entry.delete(0, END)
+        tool_id_entry.insert(0, os.path.basename(dir_name))
+
+        # checking version
+        version_file = os.path.join(dir_name, "version")
+        if os.path.exists(version_file):
+            with open(version_file) as fv:
+                version_ = fv.read().strip()
+            tool_version_entry.delete(0, END)
+            tool_version_entry.insert(0, version_)
+            image_name_entry.delete(0, END)
+            image_name_entry.insert(
+                0, os.path.basename(dir_name) + f":{version_}"
+            )
+
+    folder_frame = ttk.Frame(master=gui.content_frame)
+    folder_frame.pack(fill="x", pady=10)
+    ttk.Label(folder_frame, text="Select tool folder*", width=30).pack(
+        side=LEFT
+    )
+    ttk.Button(folder_frame, text="Browse Folder", command=browse_folder).pack(
+        side=LEFT, padx=10
+    )
+    ttk.Label(folder_frame, textvariable=write_dir).pack(side=LEFT, padx=10)
+
+    # Tool Info Fields
+    tool_id_entry = gui.create_row("Specify the tool ID*")
+    tool_version_entry = gui.create_row("Specify the tool version*")
+    tool_name_entry = gui.create_row("Specify the tool name*")
+    num_cores_entry = gui.create_row(
+        f"Cores required (integer, max {MAX_CORES})", default="1"
+    )
+    memory_entry = gui.create_row(
+        f"RAM required GB (integer, max {MAX_RAM})", default="1"
+    )
+    image_name_entry = gui.create_row("Docker image name")
+
+    gui.add_separator()
+
+    # Docker Registry Fields
+    gui.add_section_label("Docker Registry Credentials")
+    docker_url_entry = gui.create_row(
+        "Docker registry URL", default="hub.docker.com"
+    )
+    docker_user_entry = gui.create_row("Docker registry user")
+    docker_password_entry = gui.create_row(
+        "Docker registry password*", is_password=True
+    )
+
+    # --- Logic ---
+    gui_content = {}
+
+    def generate_output_object():
+        return {
+            "qmenta_user": user_id_entry.get(),
+            "qmenta_password": password_entry.get(),
+            "code": tool_id_entry.get(),
+            "version": tool_version_entry.get(),
+            "name": tool_name_entry.get(),
+            "cores": num_cores_entry.get(),
+            "memory": memory_entry.get(),
+            "image_name": image_name_entry.get(),
+            "docker_url": docker_url_entry.get(),
+            "docker_user": docker_user_entry.get(),
+            "docker_password": docker_password_entry.get(),
+        }
+
+    def perform_selection_check(values):
+        try:
+            raise_if_false(
+                isinstance(values["code"], str), "Tool ID must be a string."
+            )
+            raise_if_false(values["code"] != "", "Tool ID must be defined.")
+            raise_if_false(
+                " " not in values["code"], "Tool ID can't have spaces."
+            )
+            values["code"] = values["code"].lower()
+            values["short_name"] = values["code"].lower().replace(" ", "_")
+
+            raise_if_false(
+                isinstance(values["name"], str), "Tool name must be a string."
+            )
+            raise_if_false(values["name"] != "", "Tool name must be defined.")
+            raise_if_false(
+                values["version"] != "", "Tool version must be defined."
+            )
+            raise_if_false(
+                re.search(r"^(\d+\.)?(\d+\.)?(\*|\d+)$", values["version"]),
+                "Version format not valid.",
+            )
+
+            raise_if_false(values["cores"], "Number of cores must be defined.")
+            raise_if_false(
+                values["cores"].isnumeric(),
+                "Number of cores must be an integer.",
+            )
+            raise_if_false(
+                MAX_CORES >= int(values["cores"]) > MIN,
+                f"Number of cores must be between {MIN} and {MAX_CORES}.",
+            )
+
+            raise_if_false(values["memory"], "RAM must be defined.")
+            raise_if_false(
+                values["memory"].isnumeric(), "RAM must be an integer."
+            )
+            raise_if_false(
+                MAX_RAM >= int(values["memory"]) > MIN,
+                f"RAM must be {MIN} and {MAX_RAM}.",
+            )
+
+            values["memory"] = int(values["memory"])
+            values["image_name"] = (
+                values["image_name"]
+                or values["code"] + ":" + values["version"]
+            )
+            return values
+        except AssertionError as e:
+            gui.show_error("Error", f"AN EXCEPTION OCCURRED! {e}")
+            return False
+
+    def submit_form():
+        gui_content.update(generate_output_object())
+        res = perform_selection_check(gui_content)
+        if res:
+            gui_content.update(res)
+            return True  # Signal to close window
+        return False
+
+    # Add Buttons & Run
+    gui.add_action_buttons(
+        submit_form, submit_text="Publish in QMENTA Platform"
+    )
+    gui.run()
+
+    return gui_content
+
+
+def main():
+    content_build = gui_tkinter()
+    if not content_build:
+        exit()
+    # Ensure dir_name was set by browse_folder
+    if dir_name:
+        os.chdir(dir_name)
+
+    os.chdir(dir_name)
+
+    user = content_build["qmenta_user"]
+    password = content_build["qmenta_password"]
+    try:
+        auth = platform.Auth.login(
+            username=user,
+            password=password,
+            base_url="https://platform.qmenta.com",
+            ask_for_2fa_input=False,
+        )
+    except Needs2FAError as needs2faerror:
+        gui_tkinter.show_info(
+            "Message",
+            str(needs2faerror)
+            + " Please check the terminal to add the code sent to your phone.",
+        )
+        auth = platform.Auth.login(
+            username=user,
+            password=password,
+            base_url="https://platform.qmenta.com",
+            code_2fa=input("Input 2-FA code:"),
+        )
+
+    # Get information from the advanced options file.
+    advanced_options = "settings.json"
+    raise_if_false(
+        os.path.exists(advanced_options),
+        "Settings do not exist! Run the local test to create it.",
+    )
+    with open(advanced_options) as fr:
+        content_build["advanced_options"] = fr.read()
+
+    # Get information from the description file.
+    with open("description.html") as fr:
+        content_build["description"] = fr.read()
+
+    with open("results_configuration.json", "r") as file:
+        results_config = json.load(file)
+    # The screen value is expected as a string with escaped chars (dict)
+    results_config["screen"] = json.dumps(results_config["screen"])
+    content_build["results_configuration"] = json.dumps(
+        results_config
+    ).replace("{}", "")
+
+    content_build.update(
+        {
+            "start_condition_code": "output={'OK': True, 'code': 1}",
+            "entry_point": "/root/entrypoint.sh",
+            "tool_path": "tool:run",
+        }
+    )
+
+    # After creating the workflow, the ID of the workflow must be requested
+    # and added to the previous dictionary
+    # otherwise it will keep creating new workflows on the platform
+    # creating conflicts.
+    res = platform.post(
+        auth, "analysis_manager/upsert_user_tool", data=content_build
+    )
+
+    if res.json()["success"] == 1:
+        print("Tool updated successfully!")
+        print(
+            "Tool name:",
+            content_build["name"],
+            "(",
+            content_build["code"],
+            ":",
+            content_build["version"],
+            ")",
+        )
+    else:
+        print("ERROR setting the tool.")
+        print(res.json())
+
+
+if __name__ == "__main__":
+    main()