OpenOrchestrator 1.0.2__py3-none-any.whl → 1.2.0__py3-none-any.whl

OpenOrchestrator/database/triggers.py

@@ -8,6 +8,8 @@ import uuid
 from sqlalchemy import String, ForeignKey, Engine
 from sqlalchemy.orm import Mapped, DeclarativeBase, mapped_column
 
+from OpenOrchestrator.common import datetime_util
+
 # All classes in this module are effectively dataclasses without methods.
 # pylint: disable=too-few-public-methods
 
@@ -55,6 +57,17 @@ class Trigger(Base):
     def __repr__(self) -> str:
         return f"{self.trigger_name}: {self.type.value}"
 
+    def to_row_dict(self) -> dict[str, str]:
+        """Convert trigger to a row dictionary for display in a table."""
+        return {
+            "Trigger Name": self.trigger_name,
+            "Type": self.type.value,
+            "Status": self.process_status.value,
+            "Process Name": self.process_name,
+            "Last Run": datetime_util.format_datetime(self.last_run, "Never"),
+            "ID": str(self.id)
+        }
+
 
 class SingleTrigger(Trigger):
     """A class representing single trigger objects in the ORM."""
@@ -65,24 +78,10 @@ class SingleTrigger(Trigger):
 
     __mapper_args__ = {"polymorphic_identity": TriggerType.SINGLE}
 
-    def to_tuple(self) -> tuple:
-        """Convert the trigger to a tuple of values.
-
-        Returns:
-            tuple: A tuple of all the triggers values.
-        """
-        return (
-            self.trigger_name,
-            self.process_status.value,
-            self.process_name,
-            self.last_run,
-            self.next_run,
-            self.process_path,
-            self.process_args,
-            self.is_git_repo,
-            self.is_blocking,
-            self.id
-        )
+    def to_row_dict(self) -> dict[str, str]:
+        row_dict = super().to_row_dict()
+        row_dict["Next Run"] = datetime_util.format_datetime(self.next_run)
+        return row_dict
 
 
 class ScheduledTrigger(Trigger):
@@ -95,25 +94,10 @@ class ScheduledTrigger(Trigger):
 
     __mapper_args__ = {"polymorphic_identity": TriggerType.SCHEDULED}
 
-    def to_tuple(self) -> tuple:
-        """Convert the trigger to a tuple of values.
-
-        Returns:
-            tuple: A tuple of all the triggers values.
-        """
-        return (
-            self.trigger_name,
-            self.process_status.value,
-            self.process_name,
-            self.cron_expr,
-            self.last_run,
-            self.next_run,
-            self.process_path,
-            self.process_args,
-            self.is_git_repo,
-            self.is_blocking,
-            self.id
-        )
+    def to_row_dict(self) -> dict[str, str]:
+        row_dict = super().to_row_dict()
+        row_dict["Next Run"] = datetime_util.format_datetime(self.next_run)
+        return row_dict
 
 
 class QueueTrigger(Trigger):
@@ -126,25 +110,10 @@ class QueueTrigger(Trigger):
 
     __mapper_args__ = {"polymorphic_identity": TriggerType.QUEUE}
 
-    def to_tuple(self) -> tuple:
-        """Convert the trigger to a tuple of values.
-
-        Returns:
-            tuple: A tuple of all the triggers values.
-        """
-        return (
-            self.trigger_name,
-            self.process_status.value,
-            self.process_name,
-            self.queue_name,
-            self.min_batch_size,
-            self.last_run,
-            self.process_path,
-            self.process_args,
-            self.is_git_repo,
-            self.is_blocking,
-            self.id
-        )
+    def to_row_dict(self) -> dict[str, str]:
+        row_dict = super().to_row_dict()
+        row_dict["Next Run"] = "N/A"
+        return row_dict
 
 
 def create_tables(engine: Engine):

OpenOrchestrator/orchestrator/application.py

@@ -1,41 +1,94 @@
 """This module is the entry point for the Orchestrator app. It contains a single class
 that when created starts the application."""
 
-import tkinter
-from tkinter import ttk
+import socket
 
-from OpenOrchestrator.orchestrator import logging_tab, settings_tab, trigger_tab, constants_tab
+from nicegui import ui, app
 
-class Application(tkinter.Tk):
-    """The main application object of the Orchestrator app.
-    Extends the tkinter.Tk object.
+from OpenOrchestrator.orchestrator.tabs.trigger_tab import TriggerTab
+from OpenOrchestrator.orchestrator.tabs.settings_tab import SettingsTab
+from OpenOrchestrator.orchestrator.tabs.logging_tab import LoggingTab
+from OpenOrchestrator.orchestrator.tabs.constants_tab import ConstantTab
+from OpenOrchestrator.orchestrator.tabs.queue_tab import QueueTab
+
+
+class Application():
+    """The main application of Orchestrator.
+    It contains a header and the four tabs of the application.
     """
-    def __init__(self):
-        # Disable pylint duplicate code error since it
-        # mostly reacts to the layout code being similar.
-        # pylint: disable=R0801
-        super().__init__()
-        self.title("OpenOrchestrator")
-        self.geometry("850x600")
-        style = ttk.Style(self)
-        style.theme_use('vista')
-
-        notebook = ttk.Notebook(self)
-        notebook.pack(expand=True, fill='both')
-
-        trig_tab = trigger_tab.create_tab(notebook)
-        log_tab = logging_tab.create_tab(notebook)
-        const_tab = constants_tab.create_tab(notebook)
-        set_tab = settings_tab.create_tab(notebook)
-
-        notebook.add(trig_tab, text="Triggers")
-        notebook.add(log_tab, text="Logs")
-        notebook.add(const_tab, text="Constants")
-        notebook.add(set_tab, text="Settings")
-
-        notebook.select(3)
-
-        self.mainloop()
-
-if __name__=='__main__':
+    def __init__(self) -> None:
+        with ui.header():
+            with ui.tabs() as self.tabs:
+                ui.tab('Triggers')
+                ui.tab('Logs')
+                ui.tab('Constants')
+                ui.tab('Queues')
+                ui.tab('Settings')
+
+            ui.space()
+            ui.button(icon="contrast", on_click=ui.dark_mode().toggle)
+            ui.button(icon='refresh', on_click=self.update_tab)
+
+        with ui.tab_panels(self.tabs, value='Settings', on_change=self.update_tab).classes('w-full') as self.tab_panels:
+            self.t_tab = TriggerTab('Triggers')
+            self.l_tab = LoggingTab("Logs")
+            self.c_tab = ConstantTab("Constants")
+            self.q_tab = QueueTab("Queues")
+            SettingsTab('Settings')
+
+        self._define_on_close()
+
+        app.on_connect(self.update_loop)
+        app.on_disconnect(app.shutdown)
+        app.on_exception(lambda exc: ui.notify(exc, type='negative'))
+        ui.run(title="Orchestrator", favicon='🤖', native=False, port=get_free_port(), reload=False)
+
+    def update_tab(self):
+        """Update the date in the currently selected tab."""
+        match self.tab_panels.value:
+            case 'Triggers':
+                self.t_tab.update()
+            case 'Logs':
+                self.l_tab.update()
+            case 'Constants':
+                self.c_tab.update()
+            case 'Queues':
+                self.q_tab.update()
+
+    async def update_loop(self):
+        """Update the selected tab on a timer but only if the page is in focus."""
+        try:
+            in_focus = await ui.run_javascript("document.hasFocus()")
+            if in_focus:
+                self.update_tab()
+        except TimeoutError:
+            pass
+
+        ui.timer(10, self.update_loop, once=True)
+
+    def _define_on_close(self) -> None:
+        """Tell the browser to ask for confirmation before leaving the page."""
+        ui.add_body_html('''
+            <script>
+                window.addEventListener("beforeunload", (event) => event.preventDefault());
+            </script>
+            ''')
+
+
+def get_free_port():
+    """Get a free port by creating a new socket and bind it
+    on port 0 allowing the os to select the port.
+    https://docs.python.org/3/library/socket.html#socket.create_connection
+
+    Returns:
+        A port number that should be free to use.
+    """
+    with socket.socket() as sock:
+        sock.bind(("", 0))
+        port = sock.getsockname()[1]
+
+    return port
+
+
+if __name__ in {'__main__', '__mp_main__'}:
     Application()

OpenOrchestrator/orchestrator/datetime_input.py

@@ -0,0 +1,75 @@
+"""This module provides an input element for entering a datetime."""
+
+from datetime import datetime
+from typing import Optional, Callable, Any
+
+from nicegui import ui
+
+
+class DatetimeInput(ui.input):
+    """A datetime input with a button to show a date and time picker dialog."""
+    PY_FORMAT = "%d-%m-%Y %H:%M"
+    VUE_FORMAT = "DD-MM-YYYY HH:mm"
+
+    def __init__(self, label: str, on_change: Optional[Callable[..., Any]] = None, allow_empty: bool = False) -> None:
+        """Create a new DatetimeInput.
+
+        Args:
+            label: The label for the input element.
+            on_change: A callable to execute on change. Defaults to None.
+            allow_empty: Whether to allow an empty input on validation. Defaults to False.
+        """
+        super().__init__(label, value=None, on_change=on_change)
+        self.props("clearable")
+
+        # Define dialog
+        with ui.dialog() as self._dialog, ui.card():
+            date_input = ui.date(mask=self.VUE_FORMAT).props("today-btn first-day-of-week=1")
+            time_input = ui.time(mask=self.VUE_FORMAT).props("format24h")
+
+        # Define input
+        with self:
+            ui.button(icon="event", on_click=self._dialog.open).props("flat")
+            self.on("click", self._dialog.open)
+
+        # Bind inputs together
+        self.bind_value(date_input)
+        self.bind_value(time_input)
+
+        self._define_validation(allow_empty)
+
+    def _define_validation(self, allow_empty: bool):
+        if not allow_empty:
+            self.validation = {
+                "Please enter a datetime": bool,
+                f"Invalid datetime: {self.PY_FORMAT}": lambda v: self.get_datetime() is not None
+            }
+
+        else:
+            def validate(value: str):
+                if value is None:
+                    return True
+
+                return self.get_datetime() is not None
+
+            self.validation = {f"Invalid datetime: {self.PY_FORMAT}": validate}
+
+    def get_datetime(self) -> datetime | None:
+        """Get the text from the input as a datetime object, if
+        the current text in the input is valid else None.
+
+        Returns:
+            datetime: The value as a datetime object if any.
+        """
+        try:
+            return datetime.strptime(self.value, self.PY_FORMAT)
+        except (TypeError, ValueError):
+            return None
+
+    def set_datetime(self, value: datetime) -> None:
+        """Set the value of the datetime input.
+
+        Args:
+            value: The new datetime value.
+        """
+        self.value = value.strftime(self.PY_FORMAT)

OpenOrchestrator/orchestrator/popups/constant_popup.py

@@ -1,77 +1,95 @@
 """This module is responsible for the layout and functionality of the 'New constant' popup."""
 
-# Disable pylint duplicate code error since it
-# mostly reacts to the layout code being similar.
-# pylint: disable=R0801
+from __future__ import annotations
+from typing import TYPE_CHECKING
 
-import tkinter
-from tkinter import ttk, messagebox
+from nicegui import ui
 
 from OpenOrchestrator.database import db_util
+from OpenOrchestrator.database.constants import Constant
+from OpenOrchestrator.orchestrator.popups.generic_popups import question_popup
+
+if TYPE_CHECKING:
+    from OpenOrchestrator.orchestrator.tabs.constants_tab import ConstantTab
+
+
+# pylint: disable-next=too-few-public-methods
+class ConstantPopup():
+    """A popup for creating/updating queue triggers."""
+    def __init__(self, constant_tab: ConstantTab, constant: Constant = None):
+        """Create a new popup.
+        If a constant is given it will be updated instead of creating a new constant.
+
+        Args:
+            constant: The constant to update if any.
+        """
+        self.constant_tab = constant_tab
+        self.constant = constant
+        title = 'Update Constant' if constant else 'New Constant'
+        button_text = "Update" if constant else "Create"
+
+        with ui.dialog(value=True).props('persistent') as self.dialog, ui.card().classes('w-full'):
+            ui.label(title).classes("text-xl")
+            self.name_input = ui.input("Constant Name").classes("w-full")
+            self.value_input = ui.input("Constant Value").classes("w-full")
+
+            with ui.row():
+                ui.button(button_text, on_click=self._create_constant)
+                ui.button("Cancel", on_click=self.dialog.close)
+
+                if constant:
+                    ui.button("Delete", color='red', on_click=self._delete_constant)
+
+        self._define_validation()
+
+        if constant:
+            self._pre_populate()
+
+    def _define_validation(self):
+        """Define validation rules for input elements."""
+        self.name_input.validation = {"Please enter a name": bool}
+        self.value_input.validation = {"Please enter a value": bool}
+
+    def _pre_populate(self):
+        """Pre populate the inputs with an existing constant."""
+        self.name_input.value = self.constant.name
+        self.name_input.disable()
+        self.value_input.value = self.constant.value
+
+    def _create_constant(self):
+        """Creates a new constant in the database using the data from the
+        UI.
+        """
+        self.name_input.validate()
+        self.value_input.validate()
+
+        if self.name_input.error or self.value_input.error:
+            return
+
+        name = self.name_input.value
+        value = self.value_input.value
 
-def show_popup(name=None, value=None):
-    """Creates and shows a popup to create a new constant.
-
-    Returns:
-        tkinter.TopLevel: The created Toplevel object (Popup Window).
-    """
-    window = tkinter.Toplevel()
-    window.grab_set()
-    window.title("New Constant")
-    window.geometry("300x300")
-
-    ttk.Label(window, text="Name:").pack()
-    name_entry = ttk.Entry(window)
-    name_entry.pack()
-
-    ttk.Label(window, text="Value:").pack()
-    value_entry = ttk.Entry(window)
-    value_entry.pack()
-
-    def create_command():
-        create_constant(window, name_entry,value_entry)
-    ttk.Button(window, text='Create', command=create_command ).pack()
-    ttk.Button(window, text='Cancel', command=window.destroy).pack()
-
-    if name:
-        name_entry.insert('end', name)
-    if value:
-        value_entry.insert('end', value)
-
-    return window
-
-def create_constant(window, name_entry: ttk.Entry, value_entry: ttk.Entry):
-    """Creates a new constant in the database using the data from the
-    UI.
-
-    Args:
-        window: The popup window.
-        name_entry: The name entry.
-        value_entry: The value entry.
-    """
-    name = name_entry.get()
-    value = value_entry.get()
-
-    if not name:
-        messagebox.showerror('Error', 'Please enter a name')
-        return
-
-    if not value:
-        messagebox.showerror('Error', 'Please enter a value')
-        return
-
-    try:
-        db_util.get_constant(name)
-        exists = True
-    except ValueError:
-        exists = False
-
-    if exists:
-        if messagebox.askyesno('Error', 'A constant with that name already exists. Do you want to overwrite it?'):
+        if self.constant:
             db_util.update_constant(name, value)
         else:
-            return
-    else:
-        db_util.create_constant(name, value)
-
-    window.destroy()
+            # Check if constant already exists
+            try:
+                db_util.get_constant(name)
+                exists = True
+            except ValueError:
+                exists = False
+
+            if exists:
+                ui.notify("A constant with that name already exists.", type='negative')
+                return
+
+            db_util.create_constant(name, value)
+
+        self.dialog.close()
+        self.constant_tab.update()
+
+    async def _delete_constant(self):
+        if await question_popup(f"Delete constant '{self.constant.name}?", "Delete", "Cancel", color1='red'):
+            db_util.delete_constant(self.constant.name)
+            self.dialog.close()
+            self.constant_tab.update()

OpenOrchestrator/orchestrator/popups/credential_popup.py

@@ -1,89 +1,99 @@
-"""This module is responsible for the layout and functionality of the 'New credential' popup."""
+"""This module is responsible for the layout and functionality of the 'New constant' popup."""
 
-# Disable pylint duplicate code error since it
-# mostly reacts to the layout code being similar.
-# pylint: disable=R0801
+from __future__ import annotations
+from typing import TYPE_CHECKING
 
-
-import tkinter
-from tkinter import ttk, messagebox
+from nicegui import ui
 
 from OpenOrchestrator.database import db_util
+from OpenOrchestrator.database.constants import Credential
+from OpenOrchestrator.orchestrator.popups.generic_popups import question_popup
+
+if TYPE_CHECKING:
+    from OpenOrchestrator.orchestrator.tabs.constants_tab import ConstantTab
+
+
+# pylint: disable-next=too-few-public-methods
+class CredentialPopup():
+    """A popup for creating/updating queue triggers."""
+    def __init__(self, constant_tab: ConstantTab, credential: Credential = None):
+        """Create a new popup.
+        If a credential is given it will be updated instead of creating a new credential.
+
+        Args:
+            constant_tab: The tab that is opening this popup.
+            credential: The credential to update if any.
+        """
+        self.constant_tab = constant_tab
+        self.credential = credential
+        title = 'Update Credential' if credential else 'New Credential'
+        button_text = "Update" if credential else "Create"
+
+        with ui.dialog(value=True).props('persistent') as self.dialog, ui.card().classes('w-full'):
+            ui.label(title).classes("text-xl")
+            self.name_input = ui.input("Credential Name").classes("w-full")
+            self.username_input = ui.input("Username").classes("w-full")
+            self.password_input = ui.input("Password").classes("w-full")
+
+            with ui.row():
+                ui.button(button_text, on_click=self._save_credential)
+                ui.button("Cancel", on_click=self.dialog.close)
+
+                if credential:
+                    ui.button("Delete", color='red', on_click=self._delete_credential)
+
+        self._define_validation()
+
+        if credential:
+            self._pre_populate()
+
+    def _define_validation(self):
+        """Define validation functions for ui elements."""
+        self.name_input.validation = {"Please enter a name": bool}
+        self.username_input.validation = {"Please enter a username": bool}
+        self.password_input.validation = {"Please enter a password": bool}
+
+    def _pre_populate(self):
+        """Pre populate the inputs with an existing credential."""
+        self.name_input.value = self.credential.name
+        self.name_input.disable()
+        self.username_input.value = self.credential.username
+
+    def _save_credential(self):
+        """Create or update a credential in the database using the data from the UI."""
+        self.name_input.validate()
+        self.username_input.validate()
+        self.password_input.validate()
+
+        if self.name_input.error or self.username_input.error or self.password_input.error:
+            return
+
+        name = self.name_input.value
+        username = self.username_input.value
+        password = self.password_input.value
 
-def show_popup(name=None, username=None):
-    """Creates and shows a popup to create a new credential.
-
-    Returns:
-        tkinter.TopLevel: The created Toplevel object (Popup Window).
-    """
-    window = tkinter.Toplevel()
-    window.grab_set()
-    window.title("New Credential")
-    window.geometry("300x300")
-
-    ttk.Label(window, text="Name:").pack()
-    name_entry = ttk.Entry(window)
-    name_entry.pack()
-
-    ttk.Label(window, text="Username:").pack()
-    username_entry = ttk.Entry(window)
-    username_entry.pack()
-
-    ttk.Label(window, text="Password:").pack()
-    password_entry = ttk.Entry(window)
-    password_entry.pack()
-
-    def create_command():
-        create_credential(window, name_entry,username_entry, password_entry)
-    ttk.Button(window, text='Create', command=create_command).pack()
-    ttk.Button(window, text='Cancel', command=window.destroy).pack()
-
-    if name:
-        name_entry.insert('end', name)
-    if username:
-        username_entry.insert('end', username)
-
-    return window
-
-def create_credential(window: tkinter.Toplevel, name_entry: ttk.Entry,
-                      username_entry: ttk.Entry, password_entry:ttk.Entry):
-    """Creates a new credential in the database using the data from the
-    UI. The password is encrypted before sending it to the database.
-
-    Args:
-        window: The popup window.
-        name_entry: The name entry.
-        username_entry: The username entry.
-        password_entry: The password entry.
-    """
-    name = name_entry.get()
-    username = username_entry.get()
-    password = password_entry.get()
-
-    if not name:
-        messagebox.showerror('Error', 'Please enter a name')
-        return
-
-    if not username:
-        messagebox.showerror('Error', 'Please enter a username')
-        return
-
-    if not password:
-        messagebox.showerror('Error', 'Please enter a password')
-        return
-
-    try:
-        db_util.get_credential(name)
-        exists = True
-    except ValueError:
-        exists = False
-
-    if exists:
-        if messagebox.askyesno('Error', 'A credential with that name already exists. Do you want to overwrite it?'):
+        if self.credential:
             db_util.update_credential(name, username, password)
         else:
-            return
-    else:
-        db_util.create_credential(name, username, password)
-
-    window.destroy()
+            # Check if credential already exists
+            try:
+                db_util.get_credential(name)
+                exists = True
+            except ValueError:
+                exists = False
+
+            if exists:
+                ui.notify("A credential with that name already exists.", type='negative')
+                return
+
+            db_util.create_credential(name, username, password)
+
+        self.dialog.close()
+        self.constant_tab.update()
+
+    async def _delete_credential(self):
+        """Delete the selected credential."""
+        if await question_popup(f"Delete credential '{self.credential.name}'?", "Delete", "Cancel", color1='red'):
+            db_util.delete_credential(self.credential.name)
+            self.dialog.close()
+            self.constant_tab.update()