algomancy-gui 0.3.16__py3-none-any.whl

algomancy_gui/cqmloader.py

@@ -0,0 +1,58 @@
+from dash import html
+
+
+# todo rename to cqm_loading_animation
+def cqm_loader(text="Loading...", scale: float | None = None):
+    """
+    Creates a custom CQM animated loader with three letters (C, Q, M) that fade in sequence.
+
+    Args:
+        scale (float): float to control the size of the spinner. min: 0.5, max: 5
+        text (str): The text to display below the animation
+
+    Returns:
+        html.Div: A div containing the animated loader
+    """
+    assert (
+        not scale or 0.5 <= scale <= 5
+    ), f"Invalid scale for loader: {scale}. (min: 0.5, max: 5)"
+
+    default_height = 100
+    default_width = 100
+    default_font_size = 1.5
+
+    letter_style = {}
+    if scale is not None:
+        letter_style["height"] = f"{scale * default_height}px"
+        letter_style["width"] = f"{scale * default_width}px"
+
+    text_style = {}
+    if scale is not None:
+        text_style["font-size"] = f"{scale * default_font_size}rem"
+
+    return html.Div(
+        [
+            html.Div(
+                [
+                    html.Img(
+                        src="/assets/letter-c.svg",
+                        className="cqm-letter c",
+                        style=letter_style,
+                    ),
+                    html.Img(
+                        src="/assets/letter-q.svg",
+                        className="cqm-letter q",
+                        style=letter_style,
+                    ),
+                    html.Img(
+                        src="/assets/letter-m.svg",
+                        className="cqm-letter m",
+                        style=letter_style,
+                    ),
+                ],
+                className="cqm-loader",
+            ),
+            html.Div(text, className="cqm-loader-text", style=text_style),
+        ],
+        style={"textAlign": "center", "padding": "20px"},
+    )

algomancy_gui/data_page/__init__.py

@@ -0,0 +1 @@
+# This file is intentionally left empty to make the directory a Python package.

algomancy_gui/data_page/data.py

@@ -0,0 +1,77 @@
+from dash import html, get_app, callback, Output, Input, State
+
+from algomancy_scenario import ScenarioManager
+
+from ..componentids import (
+    DATA_PAGE_CONTENT,
+    DATA_SELECTOR_DROPDOWN,
+    ACTIVE_SESSION,
+    DATA_PAGE,
+)
+from ..data_page.datamanagementtopbar import top_bar
+from algomancy_gui.managergetters import get_scenario_manager
+from ..layouthelpers import create_wrapped_content_div
+from ..contentregistry import ContentRegistry
+
+from ..data_page import dialogcallbacks  # noqa
+
+
+def data_page() -> html.Div:
+    """
+    Creates the data page layout with raw data view and warehouse layout visualization.
+
+    Returns:
+        html.Div: A Dash HTML component representing the data page
+    """
+    # Placeholder will be filled by callback
+    return html.Div(
+        id=DATA_PAGE,
+    )
+
+
+@callback(
+    Output(DATA_PAGE, "children"),
+    Input(ACTIVE_SESSION, "data"),
+)
+def render_data_page(active_session_name):
+    """Creates the data page layout with raw data view and warehouse layout visualization."""
+    if not active_session_name:
+        return html.Div("No active session selected")
+
+    sm: ScenarioManager = get_scenario_manager(get_app().server, active_session_name)
+
+    settings = get_app().server.settings
+
+    main_div = create_wrapped_content_div(
+        content_div(),
+        settings.show_loading_on_datapage,
+        settings.use_cqm_loader,
+    )
+
+    return [html.H1("Data"), top_bar(sm), main_div]
+
+
+def content_div() -> html.Div:
+    return html.Div(
+        html.Div(className="data-page-content"),  # placeholder
+        id=DATA_PAGE_CONTENT,
+    )
+
+
+@callback(
+    Output(DATA_PAGE_CONTENT, "children"),
+    Input(DATA_SELECTOR_DROPDOWN, "value"),
+    State(ACTIVE_SESSION, "data"),
+    prevent_initial_call=True,
+)
+def fill_data_page_content(data_key: str, session_id: str):
+    sm: ScenarioManager = get_scenario_manager(get_app().server, session_id)
+    cr: ContentRegistry = get_app().server.content_registry
+
+    if data_key not in sm.get_data_keys():
+        return [html.P("Select a dataset.")]
+
+    data = sm.get_data(data_key)
+    page = cr.data_content(data)
+
+    return page

algomancy_gui/data_page/datamanagementdeletemodal.py

@@ -0,0 +1,260 @@
+from datetime import datetime
+
+import dash
+import dash_bootstrap_components as dbc
+from dash import html, dcc, callback, Output, Input, no_update, get_app, State
+
+from algomancy_scenario import ScenarioManager
+from ..componentids import (
+    DM_DELETE_SET_SELECTOR,
+    DM_DELETE_COLLAPSE,
+    DM_DELETE_CONFIRM_INPUT,
+    DM_DELETE_SUBMIT_BUTTON,
+    DM_DELETE_CLOSE_BUTTON,
+    DM_DELETE_MODAL,
+    DM_LIST_UPDATER_STORE,
+    DATA_MAN_SUCCESS_ALERT,
+    DATA_MAN_ERROR_ALERT,
+    DM_DELETE_OPEN_BUTTON,
+    ACTIVE_SESSION,
+)
+from algomancy_gui.managergetters import get_scenario_manager
+
+"""
+Modal component for deleting datasets from the application.
+
+This module provides a modal dialog that allows users to select and delete
+datasets, with additional confirmation required for master data deletion.
+"""
+
+
+def data_management_delete_modal(sm: ScenarioManager, themed_styling):
+    """
+    Creates a modal dialog component for deleting datasets.
+
+    The modal contains a dropdown to select the dataset to delete and a confirmation
+    input field that appears when master data is selected. The confirmation field
+    requires the user to type "DELETE" to proceed with deletion of master data.
+
+    Args:
+        sm: ScenarioManager instance used to populate the dataset dropdown
+        themed_styling: Dictionary of CSS styling properties
+
+    Returns:
+        dbc.Modal: A Dash Bootstrap Components modal dialog
+    """
+    return dbc.Modal(
+        [
+            dbc.ModalHeader(dbc.ModalTitle("Delete"), close_button=False),
+            dbc.ModalBody(
+                dbc.Row(
+                    [
+                        dbc.Col(
+                            html.Div(
+                                html.P("Set to delete: "),
+                            ),
+                            width=3,
+                            className="justify-content-right",
+                        ),
+                        dbc.Col(
+                            [
+                                dcc.Dropdown(
+                                    id=DM_DELETE_SET_SELECTOR,
+                                    options=[
+                                        {"label": ds, "value": ds}
+                                        for ds in sm.get_data_keys()
+                                    ],
+                                    value="",
+                                    placeholder="Select dataset",
+                                ),
+                            ],
+                            width=9,
+                        ),
+                        dbc.Collapse(
+                            children=[
+                                html.P(
+                                    "WARNING: you are about to delete master data. "
+                                    "Associated files will be permanently removed.",
+                                    className="mt-2",
+                                ),
+                                html.P(
+                                    "Enter DELETE to confirm deletion:",
+                                ),
+                                dcc.Input(
+                                    id=DM_DELETE_CONFIRM_INPUT,
+                                    placeholder="DELETE",
+                                    className="mt-2",
+                                ),
+                            ],
+                            id=DM_DELETE_COLLAPSE,
+                            is_open=False,
+                            class_name="mt-2",
+                        ),
+                    ],
+                    className="mb-4",
+                ),
+            ),
+            dbc.ModalFooter(
+                [
+                    dbc.Button(
+                        "Delete",
+                        id=DM_DELETE_SUBMIT_BUTTON,
+                        class_name="dm-delete-modal-confirm-btn",
+                    ),
+                    dbc.Button(
+                        "Close",
+                        id=DM_DELETE_CLOSE_BUTTON,
+                        class_name="dm-delete-modal-cancel-btn ms-auto",
+                        n_clicks=0,
+                    ),
+                ]
+            ),
+        ],
+        id=DM_DELETE_MODAL,
+        is_open=False,
+        centered=True,
+        class_name="themed-modal",
+        style=themed_styling,
+        keyboard=False,
+        backdrop="static",
+    )
+
+
+@callback(
+    Output(DM_DELETE_SET_SELECTOR, "value"),
+    Input(DM_DELETE_MODAL, "is_open"),
+    prevent_initial_call=True,
+)
+def reset_on_close(modal_is_open: bool):
+    """
+    Resets the delete dataset selector when the delete modal is closed.
+
+    Args:
+        modal_is_open: Boolean indicating if the modal is open
+
+    Returns:
+        None if the modal is closed, no_update otherwise
+    """
+    if not modal_is_open:
+        return None
+    return no_update
+
+
+@callback(
+    [
+        Output(DM_DELETE_COLLAPSE, "is_open"),
+        Output(DM_DELETE_CONFIRM_INPUT, "value"),
+    ],
+    Input(DM_DELETE_SET_SELECTOR, "value"),
+    State(ACTIVE_SESSION, "data"),
+    prevent_initial_call=True,
+)
+def open_confirm_section(selected_data_key, session_id: str):
+    """
+    Controls the visibility of the confirmation section in the delete modal.
+
+    Shows the confirmation section if a dataset is selected and sets the confirmation
+    input value based on whether the selected dataset is master data.
+
+    Args:
+        selected_data_key: Key of the selected dataset
+        session_id: ID of the active session
+
+    Returns:
+        tuple: (is_open, confirm_input_value) where:
+            - is_open: Boolean indicating if the confirmation section should be visible
+            - confirm_input_value: Initial value for the confirmation input field
+    """
+    if not selected_data_key:
+        return False, ""
+    sm: ScenarioManager = get_scenario_manager(get_app().server, session_id)
+
+    is_master_data = sm.get_data(selected_data_key).is_master_data()
+    if is_master_data:
+        return True, ""
+    else:
+        return False, "DELETE"
+
+
+@callback(
+    [
+        Output(DM_LIST_UPDATER_STORE, "data", allow_duplicate=True),
+        Output(DATA_MAN_SUCCESS_ALERT, "children", allow_duplicate=True),
+        Output(DATA_MAN_SUCCESS_ALERT, "is_open", allow_duplicate=True),
+        Output(DATA_MAN_ERROR_ALERT, "children", allow_duplicate=True),
+        Output(DATA_MAN_ERROR_ALERT, "is_open", allow_duplicate=True),
+        Output(DM_DELETE_MODAL, "is_open", allow_duplicate=True),
+    ],
+    [Input(DM_DELETE_SUBMIT_BUTTON, "n_clicks")],
+    [
+        State(DM_DELETE_SET_SELECTOR, "value"),
+        State(DM_DELETE_CONFIRM_INPUT, "value"),
+        State(ACTIVE_SESSION, "data"),
+    ],
+    prevent_initial_call=True,
+)
+def delete_data_callback(n_clicks, selected_data_key, confirm_str, session_id: str):
+    """
+    Deletes the selected dataset when the delete button is clicked.
+
+    Requires confirmation by typing "DELETE" in the confirmation input field.
+    Updates dropdown options across the application with the new dataset list,
+    displays success or error messages, and closes the modal upon completion.
+
+    Args:
+        n_clicks: Number of times the submit button has been clicked
+        selected_data_key: Key of the dataset to delete
+        confirm_str: Confirmation string that must equal "DELETE" to proceed
+        session_id: ID of the active session
+
+    Returns:
+        Tuple containing updated dropdown options, alert messages, and modal state
+    """
+    if not selected_data_key:
+        return (
+            no_update,
+            no_update,
+            no_update,
+            no_update,
+            "",
+            False,
+            "Select a dataset to delete!",
+            True,
+            False,
+        )
+    if confirm_str != "DELETE":
+        return no_update, no_update, no_update, no_update, no_update, no_update
+    sm: ScenarioManager = get_scenario_manager(get_app().server, session_id)
+    try:
+        sm.delete_data(selected_data_key)
+        return datetime.now(), "Dataset deleted successfully!", True, "", False, False
+    except AssertionError as e:
+        return no_update, "", False, f"Problem with deletion: {str(e)}", True, False
+
+
+@callback(
+    Output(DM_DELETE_MODAL, "is_open"),
+    [
+        Input(DM_DELETE_OPEN_BUTTON, "n_clicks"),
+        Input(DM_DELETE_CLOSE_BUTTON, "n_clicks"),
+    ],
+    [dash.dependencies.State(DM_DELETE_MODAL, "is_open")],
+)
+def toggle_modal_delete(open_clicks, close_clicks, is_open):
+    """
+    Toggles the visibility of the delete modal dialog.
+
+    Opens the modal when the open button is clicked and closes it when
+    the close button is clicked.
+
+    Args:
+        open_clicks: Number of times the open button has been clicked
+        close_clicks: Number of times the close button has been clicked
+        is_open: Current state of the modal (open or closed)
+
+    Returns:
+        bool: New state for the modal
+    """
+    if open_clicks or close_clicks:
+        return not is_open
+    return is_open

algomancy_gui/data_page/datamanagementderivemodal.py

@@ -0,0 +1,201 @@
+import re
+from datetime import datetime
+
+import dash
+import dash_bootstrap_components as dbc
+from dash import html, dcc, callback, Output, Input, State, no_update, get_app
+
+from algomancy_scenario import ScenarioManager
+from ..componentids import (
+    DM_DERIVE_SET_SELECTOR,
+    DM_DERIVE_MODAL_SUBMIT_BTN,
+    DM_DERIVE_SET_NAME_INPUT,
+    DM_DERIVE_MODAL_CLOSE_BTN,
+    DM_DERIVE_MODAL,
+    DM_LIST_UPDATER_STORE,
+    DATA_MAN_SUCCESS_ALERT,
+    DATA_MAN_ERROR_ALERT,
+    DM_DERIVE_OPEN_BTN,
+    ACTIVE_SESSION,
+)
+from algomancy_gui.managergetters import get_scenario_manager
+
+"""
+Modal component for deriving new datasets from existing ones.
+
+This module provides a modal dialog that allows users to create derived datasets
+by selecting an existing dataset and providing a name for the new derived dataset.
+"""
+
+
+def data_management_derive_modal(sm: ScenarioManager, themed_styling):
+    """
+    Creates a modal dialog component for deriving new datasets.
+
+    The modal contains a dropdown to select the source dataset and an input field
+    for naming the new derived dataset, along with submit and close buttons.
+
+    Args:
+        sm: ScenarioManager instance used to populate the dataset dropdown
+
+    Returns:
+        dbc.Modal: A Dash Bootstrap Components modal dialog
+    """
+
+    return dbc.Modal(
+        [
+            dbc.ModalHeader(dbc.ModalTitle("Derive"), close_button=False),
+            dbc.ModalBody(
+                html.Div(
+                    [
+                        dbc.Row(
+                            [
+                                dbc.Col(
+                                    html.Div(
+                                        html.P("Set to derive: "),
+                                    ),
+                                    width=3,
+                                    className="justify-content-right",
+                                ),
+                                dbc.Col(
+                                    [
+                                        dcc.Dropdown(
+                                            id=DM_DERIVE_SET_SELECTOR,
+                                            options=[
+                                                {"label": ds, "value": ds}
+                                                for ds in sm.get_data_keys()
+                                            ],
+                                            value=sm.get_data_keys()[0]
+                                            if sm.get_data_keys()
+                                            else "",
+                                            placeholder="Select dataset",
+                                        ),
+                                    ],
+                                    width=9,
+                                ),
+                            ],
+                            className="mb-4",
+                        ),
+                        dbc.Row(
+                            [
+                                dbc.Col(html.Div(html.P("Name: ")), width=3),
+                                dbc.Col(
+                                    dbc.Input(
+                                        id=DM_DERIVE_SET_NAME_INPUT,
+                                        placeholder="Name of new dataset",
+                                    ),
+                                    width=9,
+                                ),
+                            ]
+                        ),
+                    ]
+                )
+            ),
+            dbc.ModalFooter(
+                [
+                    dbc.Button(
+                        "Derive",
+                        id=DM_DERIVE_MODAL_SUBMIT_BTN,
+                        class_name="dm-derive-modal-confirm-btn",
+                    ),
+                    dbc.Button(
+                        "Close",
+                        id=DM_DERIVE_MODAL_CLOSE_BTN,
+                        class_name="dm-derive-modal-cancel-btn ms-auto",
+                        n_clicks=0,
+                    ),
+                ]
+            ),
+        ],
+        id=DM_DERIVE_MODAL,
+        is_open=False,
+        centered=True,
+        class_name="themed-modal",
+        style=themed_styling,
+        keyboard=False,
+        backdrop="static",
+    )
+
+
+def _sanitize(name: str) -> str:
+    # keep ascii-safe filename characters only
+    return re.sub(r"[^A-Za-z0-9_.-]", "_", name)
+
+
+@callback(
+    [
+        Output(DM_LIST_UPDATER_STORE, "data", allow_duplicate=True),
+        Output(DATA_MAN_SUCCESS_ALERT, "children", allow_duplicate=True),
+        Output(DATA_MAN_SUCCESS_ALERT, "is_open", allow_duplicate=True),
+        Output(DATA_MAN_ERROR_ALERT, "children", allow_duplicate=True),
+        Output(DATA_MAN_ERROR_ALERT, "is_open", allow_duplicate=True),
+        Output(DM_DERIVE_MODAL, "is_open", allow_duplicate=True),
+    ],
+    [Input(DM_DERIVE_MODAL_SUBMIT_BTN, "n_clicks")],
+    [
+        State(DM_DERIVE_SET_SELECTOR, "value"),
+        State(DM_DERIVE_SET_NAME_INPUT, "value"),
+        State(ACTIVE_SESSION, "data"),
+    ],
+    prevent_initial_call=True,
+)
+def derive_data_callback(n_clicks, selected_data_key, derived_name, session_id: str):
+    """
+    Creates a derived dataset from an existing one when the derive button is clicked.
+
+    Updates dropdown options across the application with the new dataset list,
+    displays success or error messages, and closes the modal upon completion.
+
+    Args:
+        n_clicks: Number of times the submit button has been clicked
+        selected_data_key: Key of the dataset to derive from
+        derived_name: Name for the new derived dataset
+        session_id: ID of the active session
+
+    Returns:
+        Tuple containing updated dropdown options, alert messages, and modal state
+    """
+    if not selected_data_key or not derived_name:
+        return no_update, "", False, "Choose a dataset and enter a name!", True, False
+    sm: ScenarioManager = get_scenario_manager(get_app().server, session_id)
+    try:
+        sanitized_name = _sanitize(derived_name)
+        sm.derive_data(selected_data_key, sanitized_name)
+        return (
+            datetime.now(),
+            "Successfully created derived dataset!",
+            True,
+            "",
+            False,
+            False,
+        )
+    except Exception as e:
+        return no_update, "", False, f"Problem with deriving: {str(e)}", True, False
+
+
+@callback(
+    Output(DM_DERIVE_MODAL, "is_open"),
+    [
+        Input(DM_DERIVE_OPEN_BTN, "n_clicks"),
+        Input(DM_DERIVE_MODAL_CLOSE_BTN, "n_clicks"),
+    ],
+    [dash.dependencies.State(DM_DERIVE_MODAL, "is_open")],
+)
+def toggle_modal_derive(open_clicks, close_clicks, is_open):
+    """
+    Toggles the visibility of the derive modal dialog.
+
+    Opens the modal when the open button is clicked and closes it when
+    the close button is clicked.
+
+    Args:
+        open_clicks: Number of times the open button has been clicked
+        close_clicks: Number of times the close button has been clicked
+        is_open: Current state of the modal (open or closed)
+
+    Returns:
+        bool: New state for the modal
+    """
+    if open_clicks or close_clicks:
+        return not is_open
+    return is_open