algomancy-gui 0.3.16__py3-none-any.whl

algomancy_gui/scenario_page/delete_confirmation.py

@@ -0,0 +1,29 @@
+import dash_bootstrap_components as dbc
+
+from algomancy_gui.componentids import (
+    SCENARIO_DELETE_MODAL,
+    SCENARIO_CANCEL_DELETE_BUTTON,
+    SCENARIO_CONFIRM_DELETE_BUTTON,
+)
+
+
+def delete_confirmation_modal():
+    # Delete confirmation modal
+    return dbc.Modal(
+        [
+            dbc.ModalHeader("Confirm Deletion"),
+            dbc.ModalBody("Are you sure you want to delete this scenario?"),
+            dbc.ModalFooter(
+                [
+                    dbc.Button(
+                        "Cancel", id=SCENARIO_CANCEL_DELETE_BUTTON, color="secondary"
+                    ),
+                    dbc.Button(
+                        "Delete", id=SCENARIO_CONFIRM_DELETE_BUTTON, color="danger"
+                    ),
+                ]
+            ),
+        ],
+        id=SCENARIO_DELETE_MODAL,
+        is_open=False,
+    )

algomancy_gui/scenario_page/new_scenario_creator.py

@@ -0,0 +1,104 @@
+from dash import html, dcc, get_app
+import dash_bootstrap_components as dbc
+
+from algomancy_gui.componentids import (
+    SCENARIO_TAG_INPUT,
+    SCENARIO_DATA_INPUT,
+    SCENARIO_ALGO_INPUT,
+    SCENARIO_NEW_BUTTON,
+    SCENARIO_CREATE_STATUS,
+    SCENARIO_CREATOR_MODAL,
+)
+from algomancy_gui.managergetters import get_scenario_manager
+from algomancy_gui.scenario_page.new_scenario_parameters_window import (
+    create_algo_parameters_window,
+)
+from algomancy_scenario import ScenarioManager
+from algomancy_gui.stylingconfigurator import StylingConfigurator
+
+
+def new_scenario_creator(session_id: str):
+    sm: ScenarioManager = get_scenario_manager(get_app().server, session_id)
+    sc: StylingConfigurator = get_app().server.styling_config
+
+    # Modal for creating a new scenario
+    return dbc.Modal(
+        [
+            dbc.ModalHeader(dbc.ModalTitle("Create New Scenario"), close_button=False),
+            dbc.ModalBody(
+                [
+                    dbc.Row(
+                        [
+                            dbc.Col(
+                                dbc.Input(
+                                    id=SCENARIO_TAG_INPUT, placeholder="Scenario tag"
+                                ),
+                                width=12,
+                            ),
+                        ],
+                        className="mb-2",
+                    ),
+                    dbc.Row(
+                        [
+                            dbc.Col(
+                                dcc.Dropdown(
+                                    id=SCENARIO_DATA_INPUT,
+                                    options=[
+                                        {"label": ds, "value": ds}
+                                        for ds in sm.get_data_keys()
+                                    ],
+                                    placeholder="Select dataset",
+                                ),
+                                width=12,
+                            ),
+                        ],
+                        className="mb-2",
+                    ),
+                    dbc.Row(
+                        [
+                            dbc.Col(
+                                dcc.Dropdown(
+                                    id=SCENARIO_ALGO_INPUT,
+                                    options=[
+                                        {"label": algo, "value": algo}
+                                        for algo in sm.available_algorithms
+                                    ],
+                                    placeholder="Select algorithm",
+                                ),
+                                width=12,
+                            ),
+                        ],
+                        className="mb-2",
+                    ),
+                    dbc.Row(
+                        [
+                            dbc.Col(create_algo_parameters_window(), width=12),
+                        ],
+                        className="mb-3",
+                    ),
+                    html.Div(id=SCENARIO_CREATE_STATUS, className="mt-2"),
+                ]
+            ),
+            dbc.ModalFooter(
+                [
+                    dbc.Button(
+                        "Create",
+                        id=SCENARIO_NEW_BUTTON,
+                        class_name="new-scenario-confirm-button",
+                    ),
+                    dbc.Button(
+                        "Cancel",
+                        id=f"{SCENARIO_CREATOR_MODAL}-cancel",
+                        class_name="new-scenario-cancel-button ms-auto",
+                    ),
+                ]
+            ),
+        ],
+        id=SCENARIO_CREATOR_MODAL,
+        is_open=False,
+        centered=True,
+        class_name="themed-modal",
+        style=sc.initiate_theme_colors(),
+        keyboard=False,
+        backdrop="static",
+    )

algomancy_gui/scenario_page/new_scenario_parameters_window.py

@@ -0,0 +1,154 @@
+from algomancy_gui.managergetters import get_manager
+from algomancy_gui.sessionmanager import SessionManager
+from algomancy_gui.settingsmanager import SettingsManager
+import dash_bootstrap_components as dbc
+from dash import html, get_app, dcc
+from typing import Dict
+
+from algomancy_scenario import ScenarioManager
+from algomancy_utils.baseparameterset import (
+    TypedParameter,
+    ParameterType,
+    BaseParameterSet,
+)
+from algomancy_gui.componentids import (
+    ALGO_PARAMS_ENTRY_CARD,
+    ALGO_PARAMS_ENTRY_TAB,
+    ALGO_PARAMS_UPLOAD_TAB,
+    ALGO_PARAMS_WINDOW_ID,
+    ALGO_PARAM_INPUT,
+    ALGO_PARAM_DATE_INPUT,
+    ALGO_PARAM_INTERVAL_INPUT,
+)
+
+
+def prettify_label(key):
+    # Converts 'batch_size' -> 'Batch Size'
+    return key.replace("_", " ").title()
+
+
+def create_parameter_input_component(param: TypedParameter, param_name: str):
+    typ = param.parameter_type
+    match typ:
+        case ParameterType.STRING:
+            return dbc.Input(
+                id={"type": ALGO_PARAM_INPUT, "param": param_name}, type="text"
+            )
+        case ParameterType.INTEGER:
+            return dbc.Input(
+                id={"type": ALGO_PARAM_INPUT, "param": param_name}, type="number"
+            )
+        case ParameterType.FLOAT:
+            return dbc.Input(
+                id={"type": ALGO_PARAM_INPUT, "param": param_name}, type="number"
+            )
+        case ParameterType.BOOLEAN:
+            return dbc.Checklist(
+                options=[{"label": "On", "value": True}],
+                id={"type": ALGO_PARAM_INPUT, "param": param_name},
+                switch=True,
+            )
+        case ParameterType.ENUM:
+            return dcc.Dropdown(
+                id={"type": ALGO_PARAM_INPUT, "param": param_name},
+                options=[
+                    {"label": prettify_label(opt), "value": opt}
+                    for opt in param.choices
+                ],
+            )
+        case ParameterType.MULTI_ENUM:
+            return dcc.Dropdown(
+                id={"type": ALGO_PARAM_INPUT, "param": param_name},
+                options=[
+                    {"label": prettify_label(opt), "value": opt}
+                    for opt in param.choices
+                ],
+                multi=True,
+            )
+        case ParameterType.TIME:
+            return dcc.DatePickerSingle(
+                id={"type": ALGO_PARAM_DATE_INPUT, "param": param_name},
+                date=param.default,
+            )
+        case ParameterType.INTERVAL:
+            return dcc.DatePickerRange(
+                id={"type": ALGO_PARAM_INTERVAL_INPUT, "param": param_name},
+                start_date=param.default_start,
+                end_date=param.default_end,
+            )
+        case _:
+            raise ValueError(f"Unsupported parameter type: {typ}")
+
+
+def create_input_group(param_dict: Dict[str, TypedParameter]):
+    """
+    Given a dictionary of parameter names and Python types,
+    returns a list of input groups, each with a neat label and input.
+    """
+    form_groups = []
+    for param_name, param in param_dict.items():
+        label = prettify_label(param_name)
+
+        html_id = f"{ALGO_PARAM_INPUT}-{param_name}"
+
+        component = create_parameter_input_component(param, param_name)
+
+        form_groups.append(
+            html.Div(
+                [
+                    dbc.Label(label, html_for=html_id, className="d-block"),
+                    html.Div(
+                        component,
+                        className="",
+                        style={"display": "block", "width": "100%"},
+                    ),
+                ],
+                className="mb-3",
+            )
+        )
+
+    return form_groups
+
+
+def create_algo_parameters_entry_card_body(template_name: str) -> dbc.CardBody:
+    session_manager: SessionManager | ScenarioManager = get_manager(get_app().server)
+    algo_params: BaseParameterSet = session_manager.get_algorithm_parameters(
+        template_name
+    )
+    assert algo_params.has_inputs(), "No parameters found for algorithm template."
+    input_group = create_input_group(algo_params.get_parameters())
+
+    return dbc.CardBody(
+        input_group,
+        style={
+            "maxHeight": "60vh",  # or e.g. "420px"
+            "overflowY": "auto",
+            "overflowX": "hidden",
+        },
+    )
+
+
+def create_algo_parameters_window() -> dbc.Collapse:
+    tabs = []
+
+    param_entry_card = dbc.Card(id=ALGO_PARAMS_ENTRY_CARD, class_name="mt-3")
+    tabs.append(
+        dbc.Tab(param_entry_card, label="Fill in", tab_id=ALGO_PARAMS_ENTRY_TAB)
+    )
+
+    settings: SettingsManager = get_app().server.settings
+    if settings.allow_param_upload_by_file:
+        param_upload_card = dbc.Card(
+            dbc.CardBody(html.Strong("TO DO: file uploader.")), class_name="mt-3"
+        )
+        tabs.append(
+            dbc.Tab(param_upload_card, label="Upload", tab_id=ALGO_PARAMS_UPLOAD_TAB)
+        )
+
+    window = dbc.Collapse(
+        children=[dbc.Tabs(tabs)],
+        id=ALGO_PARAMS_WINDOW_ID,
+        is_open=False,
+    )
+
+    return window

algomancy_gui/scenario_page/scenario_badge.py

@@ -0,0 +1,36 @@
+"""
+scenario_badge.py - Scenario Status Badge Component
+
+This module defines a function for creating styled status badges for scenarios,
+providing visual indicators of a scenario's current status.
+"""
+
+import dash_bootstrap_components as dbc
+
+from algomancy_scenario import ScenarioStatus
+
+
+def status_badge(status):
+    """
+    Transforms a given status value into a styled badge with the appropriate color coding,
+    enhancing the display of statuses for visual purposes.
+
+    :param status: The current status of a scenario, which must be one of the predefined
+        values in the ScenarioStatus enumeration.
+    :type status: ScenarioStatus
+    :return: A Dash Bootstrap Component (dbc) Badge element styled according to the status value.
+    :rtype: Dbc.Badge
+    """
+    color_map = {
+        ScenarioStatus.CREATED: "secondary",
+        ScenarioStatus.QUEUED: "info",
+        ScenarioStatus.PROCESSING: "warning",
+        ScenarioStatus.COMPLETE: "success",
+        ScenarioStatus.FAILED: "danger",
+    }
+    return dbc.Badge(
+        status.capitalize(),
+        color=color_map.get(status, "dark"),
+        className="ms-1",
+        pill=True,
+    )

algomancy_gui/scenario_page/scenario_cards.py

@@ -0,0 +1,119 @@
+"""
+scenario_cards.py - Scenario Card Components
+
+This module defines functions for creating and styling scenario cards for the scenario page.
+These cards display scenario information and provide buttons for processing and deleting scenarios.
+"""
+
+from dash import html, dcc
+import dash_bootstrap_components as dbc
+
+from algomancy_scenario.scenariomanager import ScenarioManager, Scenario
+from algomancy_scenario import ScenarioStatus
+
+
+from .scenario_badge import status_badge
+from ..componentids import (
+    SCENARIO_PROCESS_BUTTON,
+    SCENARIO_DELETE_BUTTON,
+    SCENARIO_CARD,
+)
+
+
+def hidden_card():
+    dummy_scenario = Scenario("dummy", None, None, None)
+    return scenario_card(dummy_scenario, is_hidden=True)
+
+
+def scenario_card(s: Scenario, is_hidden: bool = False):
+    # Determine process button appearance based on scenario status
+    if s.status == ScenarioStatus.CREATED:
+        status = "created"
+        btn_text = "Process"
+    elif s.status in (ScenarioStatus.QUEUED, ScenarioStatus.PROCESSING):
+        status = "queued"
+        btn_text = "Cancel"
+    elif s.status in (ScenarioStatus.COMPLETE, ScenarioStatus.FAILED):
+        status = "completed"
+        btn_text = "Refresh"
+    else:  # never
+        status = "standard"
+        btn_text = "Process"
+
+    return html.Div(
+        [
+            # Top row: Scenario tag
+            dbc.Row([dbc.Col(html.P(html.Strong(s.tag), className="mb-1"), width=12)]),
+            # Bottom row: Badge and buttons
+            dbc.Row(
+                [
+                    dbc.Col(
+                        # Left: Badge
+                        html.Div(
+                            [
+                                html.Div(
+                                    status_badge(s.status),
+                                    id={
+                                        "type": "SCENARIO_STATUS_BADGE_INNER",
+                                        "index": s.id,
+                                    },
+                                ),
+                                dcc.Store(
+                                    id={
+                                        "type": "scenario-status-badge-store",
+                                        "index": s.id,
+                                    }
+                                ),
+                            ],
+                            className="d-flex align-items-center",
+                        ),
+                        width=6,
+                    ),
+                    # Right: Buttons
+                    dbc.Col(
+                        dbc.ButtonGroup(
+                            [
+                                dbc.Button(
+                                    btn_text,
+                                    id={"type": SCENARIO_PROCESS_BUTTON, "index": s.id},
+                                    size="sm",
+                                    n_clicks=0,
+                                    class_name="scenario-multi-btn-" + status,
+                                ),
+                                dbc.Button(
+                                    "Delete",
+                                    id={"type": SCENARIO_DELETE_BUTTON, "index": s.id},
+                                    size="sm",
+                                    n_clicks=0,
+                                    class_name="scenario-delete-btn-" + status,
+                                ),
+                            ]
+                        ),
+                        width=6,
+                        className="d-flex align-items-center justify-content-end",
+                    ),
+                ]
+            ),
+        ],
+        id={"type": SCENARIO_CARD, "index": s.id},
+        n_clicks=0,
+        className="scenario-card" if not is_hidden else "scenario-card hidden",
+    )
+
+
+def scenario_cards(scenario_manager: ScenarioManager, selected_id=None):
+    """
+    Creates a list of scenario cards for display.
+
+    Args:
+        scenario_manager: The scenario manager containing the scenarios to display
+        selected_id: ID of the currently selected scenario, if any
+
+    Returns:
+        list: A list of HTML Div components representing scenario cards
+    """
+    cards = []
+    for scenario in scenario_manager.list_scenarios():
+        card = scenario_card(scenario)
+        cards.append(card)
+    return cards