algomancy-gui 0.3.16__py3-none-any.whl

algomancy_gui/appconfiguration.py

@@ -0,0 +1,291 @@
+import platform
+from typing import Any, Dict, List, Type
+import os
+
+from algomancy_content import LibraryManager as library
+from algomancy_data import InputFileConfiguration, BASE_DATA_BOUND, DataSource
+from algomancy_content.pages.page import (
+    HomePage,
+    ScenarioPage,
+    ComparePage,
+    OverviewPage,
+    DataPage,
+)
+from algomancy_gui.stylingconfigurator import StylingConfigurator
+from algomancy_scenario import ALGORITHM, BASE_KPI
+from algomancy_scenario.core_configuration import CoreConfiguration
+
+
+class AppConfiguration(CoreConfiguration):
+    """
+    Central configuration object for the Algomancy dashboard.
+
+    Construct with your choices, validation runs on creation. Use `as_dict()`
+    to obtain the dictionary expected by `DashLauncher.build()` and
+    `SettingsManager`.
+    """
+
+    def __init__(
+        self,
+        # === session manager configuration ===
+        use_sessions: bool = False,
+        # === path specifications ===
+        assets_path: str = "assets",  # gui
+        data_path: str = "data",
+        # === data manager configuration ===
+        has_persistent_state: bool = False,
+        save_type: str | None = "json",
+        data_object_type: type[BASE_DATA_BOUND] | None = DataSource,
+        # === scenario manager configuration ===
+        etl_factory: Any | None = None,
+        kpi_templates: Dict[str, Type[BASE_KPI]] | None = None,
+        algo_templates: Dict[str, Type[ALGORITHM]] | None = None,
+        input_configs: List[InputFileConfiguration] | None = None,
+        # === auto start/create features ===
+        autocreate: bool | None = False,
+        default_algo: str | None = None,
+        default_algo_params_values: Dict[str, Any] | None = None,
+        autorun: bool | None = False,
+        # === content functions ===
+        home_page: HomePage | str = "standard",  # gui
+        data_page: DataPage | str = "placeholder",  # gui
+        scenario_page: ScenarioPage | str = "placeholder",  # gui
+        compare_page: ComparePage | str = "placeholder",  # gui
+        overview_page: OverviewPage | str = "standard",  # gui
+        # === styling configuration ===
+        styling_config: Any | None = StylingConfigurator.get_cqm_config(),  # gui
+        use_cqm_loader: bool = False,  # gui
+        # === misc dashboard configurations ===
+        title: str = "Algomancy Dashboard",
+        host: str | None = None,  # gui/api
+        port: int | None = None,  # gui/api
+        # === page configurations ===
+        compare_default_open: List[str] | None = None,  # gui
+        compare_ordered_list_components: List[str] | None = None,  # gui
+        use_data_page_spinner: bool = True,  # gui
+        use_scenario_page_spinner: bool = True,  # gui
+        use_compare_page_spinner: bool = True,  # gui
+        allow_parameter_upload_from_file: bool = False,  # gui
+        # === authentication ===
+        use_authentication: bool = False,  # gui
+    ):
+        # initialize core part
+        super().__init__(
+            use_sessions=use_sessions,
+            data_path=data_path,
+            has_persistent_state=has_persistent_state,
+            save_type=save_type,
+            data_object_type=data_object_type,
+            etl_factory=etl_factory,
+            kpi_templates=kpi_templates,
+            algo_templates=algo_templates,
+            input_configs=input_configs,
+            autocreate=autocreate,
+            default_algo=default_algo,
+            default_algo_params_values=default_algo_params_values,
+            autorun=autorun,
+            title=title,
+        )
+
+        # paths (GUI)
+        self.assets_path = assets_path
+
+        # content + callbacks
+        self.home_page = home_page
+        self.data_page = data_page
+        self.scenario_page = scenario_page
+        self.compare_page = compare_page
+        self.overview_page = overview_page
+
+        # styling + misc
+        self.styling_config = styling_config
+        self.use_cqm_loader = use_cqm_loader
+        self.host = host or self._get_default_host()
+        self.port = port or 8050
+
+        # settings pages
+        self.compare_default_open = compare_default_open or []
+        self.compare_ordered_list_components = compare_ordered_list_components or []
+        self.show_loading_on_datapage = use_data_page_spinner
+        self.show_loading_on_scenariopage = use_scenario_page_spinner
+        self.show_loading_on_comparepage = use_compare_page_spinner
+        self.allow_parameter_upload_from_file = allow_parameter_upload_from_file
+
+        # auth
+        self.use_authentication = use_authentication
+
+        # validate GUI-specific pieces immediately (core validated in super())
+        self._validate_gui()
+
+    # public API
+    def as_dict(self) -> Dict[str, Any]:
+        return {
+            # === session manager configuration ===
+            "use_sessions": self.use_sessions,
+            # === path specifications ===
+            "assets_path": self.assets_path,
+            "data_path": self.data_path,
+            # === data manager configuration ===
+            "has_persistent_state": self.has_persistent_state,
+            "save_type": self.save_type,
+            "data_object_type": self.data_object_type,
+            # === scenario manager configuration ===
+            "etl_factory": self.etl_factory,
+            "kpi_templates": self.kpi_templates,
+            "algo_templates": self.algo_templates,
+            "input_configs": self.input_configs,
+            "autocreate": self.autocreate,
+            "default_algo": self.default_algo,
+            "default_algo_params_values": self.default_algo_params_values,
+            "autorun": self.autorun,
+            # === content functions ===
+            "home_page": self.home_page,
+            "data_page": self.data_page,
+            "scenario_page": self.scenario_page,
+            "compare_page": self.compare_page,
+            "overview_page": self.overview_page,
+            # === styling configuration ===
+            "styling_config": self.styling_config,
+            "use_cqm_loader": self.use_cqm_loader,
+            # === misc dashboard configurations ===
+            "title": self.title,
+            "host": self.host,
+            "port": self.port,
+            # === page configurations ===
+            "compare_default_open": self.compare_default_open,
+            "compare_ordered_list_components": self.compare_ordered_list_components,
+            "show_loading_on_datapage": self.show_loading_on_datapage,
+            "show_loading_on_scenariopage": self.show_loading_on_scenariopage,
+            "show_loading_on_comparepage": self.show_loading_on_comparepage,
+            "allow_param_upload_by_file": self.allow_parameter_upload_from_file,
+            # === authentication ===
+            "use_authentication": self.use_authentication,
+        }
+
+    # validation helpers (GUI layer)
+    def _validate_gui(self) -> None:
+        self._validate_paths_gui()
+        self._validate_values_gui()
+        self._validate_pages()
+        self._validate_page_configurations()
+
+    def _validate_pages(self):
+        # fetch pages that were passed as str
+        home, data, scenario, compare, overview = library.get_pages(self.as_dict())
+
+        # check home page attributes
+        assert hasattr(home, "create_content")
+        assert hasattr(home, "register_callbacks"), (
+            "home_page.register_callbacks must be a function"
+        )
+
+        # check data page attributes
+        assert hasattr(data, "create_content"), (
+            "data_page.create_content must be a function"
+        )
+        assert hasattr(data, "register_callbacks"), (
+            "data_page.register_callbacks must be a function"
+        )
+
+        # check scenario page attributes
+        assert hasattr(scenario, "create_content"), (
+            "scenario_page.create_content must be a function"
+        )
+        assert hasattr(scenario, "register_callbacks"), (
+            "scenario_page.register_callbacks must be a function"
+        )
+
+        # check compare page attributes
+        assert hasattr(compare, "create_side_by_side_content"), (
+            "compare_page.create_side_by_side_content must be a function"
+        )
+        assert hasattr(compare, "create_compare_section"), (
+            "compare_page.create_compare_section must be a function"
+        )
+        assert hasattr(compare, "create_details_section"), (
+            "compare_page.create_details_section must be a function"
+        )
+        assert hasattr(compare, "register_callbacks"), (
+            "compare_page.register_callbacks must be a function"
+        )
+
+        # check overview page attributes
+        assert hasattr(overview, "create_content"), (
+            "overview_page.create_content must be a function"
+        )
+        assert hasattr(overview, "register_callbacks"), (
+            "scenario_page.register_callbacks must be a function"
+        )
+
+    def _validate_page_configurations(self) -> None:
+        # basic type checks for collections
+        if not isinstance(self.compare_default_open, list):
+            raise ValueError("compare_default_open must be a list of strings")
+        if not isinstance(self.compare_ordered_list_components, list):
+            raise ValueError(
+                "compare_ordered_list_components must be a list of strings"
+            )
+
+        # ensure all strings are valid
+        admissible_values = ["side-by-side", "kpis", "compare", "details"]
+        for component in self.compare_default_open:
+            if not isinstance(component, str):
+                raise ValueError(
+                    f"compare_default_open must be a list of strings, but contains {component}"
+                )
+            if component not in admissible_values:
+                raise ValueError(
+                    f"compare_default_open contains invalid component: {component}"
+                )
+
+        for component in self.compare_ordered_list_components:
+            if not isinstance(component, str):
+                raise ValueError(
+                    f"compare_ordered_list_components must be a list of strings, but contains {component}"
+                )
+            if component not in admissible_values:
+                raise ValueError(
+                    f"compare_ordered_list_components contains invalid component: {component}"
+                )
+
+        # ensure all strings are unique
+        if len(self.compare_default_open) != len(set(self.compare_default_open)):
+            raise ValueError("compare_default_open contains duplicate values")
+        if len(self.compare_ordered_list_components) != len(
+            set(self.compare_ordered_list_components)
+        ):
+            raise ValueError(
+                "compare_ordered_list_components contains duplicate values"
+            )
+
+    def _validate_paths_gui(self) -> None:
+        if self.assets_path is None or self.assets_path == "":
+            raise ValueError("assets_path must be provided")
+        if not os.path.isdir(self.assets_path):
+            raise ValueError(
+                f"assets_path does not exist or is not a directory: {self.assets_path}"
+            )
+
+    def _validate_values_gui(self) -> None:
+        # booleans allowed to be False, but must not be None if specified
+        if self.use_authentication is None:
+            raise ValueError(
+                "Boolean configuration 'use_authentication' must be set to True or False, not None"
+            )
+
+        # host and port (host may be filled elsewhere; allow None)
+        if self.port is not None:
+            if not isinstance(self.port, int) or not (1 <= self.port <= 65535):
+                raise ValueError("port must be an integer between 1 and 65535")
+
+    @staticmethod
+    def _get_default_host() -> str:
+        if platform.system() == "Windows":
+            host = "127.0.0.1"  # default host for windows
+        else:
+            host = "0.0.0.1"  # default host for linux
+        return host
+
+    @classmethod
+    def from_dict(cls, config: Dict[str, Any]) -> "AppConfiguration":
+        return cls(**config)

algomancy_gui/compare_page/__init__.py

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

algomancy_gui/compare_page/compare.py

@@ -0,0 +1,360 @@
+"""
+compare.py - Compare Dashboard Page
+
+This module defines the layout and components for the compare dashboard page.
+It includes scenario selection, KPI improvement displays, and secondary results sections.
+"""
+
+from typing import Any, Optional
+
+from dash import html, get_app, callback, Output, Input, State
+import dash_bootstrap_components as dbc
+
+from .kpicard import kpi_card
+from ..componentids import (
+    PERF_DETAILS_COLLAPSE,
+    COMPARE_DETAIL_VIEW,
+    PERF_COMPARE_COLLAPSE,
+    PERF_PRIMARY_RESULTS,
+    PERF_KPI_COLLAPSE,
+    KPI_IMPROVEMENT_SECTION,
+    PERF_TOGGLE_CHECKLIST_LEFT,
+    PERF_TOGGLE_CHECKLIST_RIGHT,
+    LEFT_SCENARIO_OVERVIEW,
+    LEFT_SCENARIO_DROPDOWN,
+    ACTIVE_SESSION,
+    RIGHT_SCENARIO_OVERVIEW,
+    RIGHT_SCENARIO_DROPDOWN,
+    COMPARE_PAGE,
+    PERF_SBS_RIGHT_COLLAPSE,
+    PERF_SBS_LEFT_COLLAPSE,
+)
+from ..compare_page.scenarioselector import (
+    create_side_by_side_viewer,
+    create_side_by_side_selector,
+)
+from algomancy_gui.managergetters import get_scenario_manager
+
+from ..settingsmanager import SettingsManager
+from ..contentregistry import ContentRegistry
+from algomancy_scenario import ScenarioManager, Scenario
+
+
+def compare_page():
+    return html.Div(id=COMPARE_PAGE, className="compare-page")
+
+
+@callback(
+    Output(COMPARE_PAGE, "children"),
+    Input(ACTIVE_SESSION, "data"),
+)
+def render_ordered_components(active_session_name):
+    """Creates the compare page layout with scenario management functionality."""
+
+    sm: ScenarioManager = get_scenario_manager(get_app().server, active_session_name)
+
+    settings: SettingsManager = get_app().server.settings
+
+    header = create_header(settings)
+    selector = create_side_by_side_selector(sm)
+
+    orderable_components = {
+        "kpis": create_kpi_viewer(),
+        "side-by-side": create_side_by_side_viewer(),
+        "compare": create_primary_viewer(),
+        "details": create_details_viewer(),
+    }
+
+    order = get_component_order(orderable_components, settings, sm)
+
+    ordered_components = order_components(header, order, orderable_components, selector)
+
+    page = html.Div(ordered_components, className="compare-page")
+    return page
+
+
+def order_components(
+    header: dbc.Row,
+    order: list[str],
+    orderable_components: dict[str, dbc.Row | Any],
+    selector: dbc.Row,
+) -> list[dbc.Row]:
+    # construct component list
+    ordered_components = [
+        header,
+        selector,
+    ]
+    for comp_id in order:
+        ordered_components.append(orderable_components[comp_id])
+    return ordered_components
+
+
+def validate(configured_order, orderable_components, sm: ScenarioManager) -> bool:
+    for comp_id in configured_order:
+        if comp_id not in orderable_components:
+            sm.logger.warning(
+                f"Invalid component id '{comp_id}' in compare page order list."
+            )
+            sm.logger.warning(
+                f"Expected (possibly a a subset of) {list(orderable_components.keys())}."
+            )
+            sm.logger.warning("Reverting to default component order.")
+            return False
+    return True
+
+
+def get_component_order(
+    orderable_components: dict[str, dbc.Row | Any],
+    settings: SettingsManager,
+    sm: ScenarioManager,
+) -> list[str]:
+    # set a default
+    default_order = list(orderable_components.keys())
+
+    # retrieve any custom setting
+    configured_order = settings.compare_ordered_list_components
+
+    # verify the custom setting is valid
+    if configured_order and not validate(configured_order, orderable_components, sm):
+        configured_order = None
+
+    # choose ordering
+    used_order = configured_order if configured_order else default_order
+    return used_order
+
+
+def create_details_viewer() -> dbc.Collapse:
+    return dbc.Collapse(
+        id=PERF_DETAILS_COLLAPSE,
+        children=[
+            html.H5("Detail view"),
+            html.Div(id=COMPARE_DETAIL_VIEW, className="details-view"),
+        ],
+    )
+
+
+def create_primary_viewer() -> dbc.Collapse:
+    return dbc.Collapse(
+        id=PERF_COMPARE_COLLAPSE,
+        children=[
+            html.H4("Compare Results"),
+            html.Div(id=PERF_PRIMARY_RESULTS, className="compare-view"),
+        ],
+    )
+
+
+def create_kpi_viewer() -> dbc.Collapse:
+    return dbc.Collapse(
+        id=PERF_KPI_COLLAPSE,
+        children=[
+            html.H4("KPI Improvements"),
+            html.Div(id=KPI_IMPROVEMENT_SECTION, className="kpi-cards"),
+        ],
+    )
+
+
+def create_header(settings: SettingsManager) -> dbc.Row:
+    default_open = settings.compare_default_open
+
+    return dbc.Row(
+        [
+            dbc.Col(html.H1("Compare"), width=9),
+            dbc.Col(
+                dbc.Row(
+                    [
+                        dbc.Col(
+                            dbc.Checklist(
+                                options=[
+                                    {
+                                        "label": "Show side-by-side",
+                                        "value": "side-by-side",
+                                    },
+                                    {"label": "Show KPI cards", "value": "kpis"},
+                                ],
+                                id=PERF_TOGGLE_CHECKLIST_LEFT,
+                                class_name="styled-toggle",
+                                switch=True,
+                                value=default_open,
+                            ),
+                            width=6,
+                        ),
+                        dbc.Col(
+                            dbc.Checklist(
+                                options=[
+                                    {"label": "Show compare view", "value": "compare"},
+                                    {"label": "Show details", "value": "details"},
+                                ],
+                                id=PERF_TOGGLE_CHECKLIST_RIGHT,
+                                class_name="styled-toggle",
+                                switch=True,
+                                value=default_open,
+                            ),
+                            width=6,
+                        ),
+                    ]
+                ),
+                width=3,
+            ),
+        ]
+    )
+
+
+@callback(
+    Output(LEFT_SCENARIO_OVERVIEW, "children"),
+    Input(LEFT_SCENARIO_DROPDOWN, "value"),
+    State(ACTIVE_SESSION, "data"),
+    prevent_initial_call=True,
+)
+def update_left_scenario_overview(scenario_id: str, session_id: str) -> html.Div | str:
+    if not scenario_id:
+        return "No scenario selected."
+    scenario_manager = get_scenario_manager(
+        server=get_app().server, active_session_name=session_id
+    )
+    s: Optional[Scenario] = scenario_manager.get_by_id(scenario_id)
+
+    cr: ContentRegistry = get_app().server.content_registry
+
+    if not s:
+        return "Scenario not found."
+
+    return cr.compare_side_by_side(s, "left")
+
+
+@callback(
+    Output(RIGHT_SCENARIO_OVERVIEW, "children"),
+    Input(RIGHT_SCENARIO_DROPDOWN, "value"),
+    State(ACTIVE_SESSION, "data"),
+    prevent_initial_call=True,
+)
+def update_right_scenario_overview(scenario_id, session_id) -> html.Div | str:
+    if not scenario_id:
+        return "No scenario selected."
+    scenario_manager: ScenarioManager = get_scenario_manager(
+        get_app().server, session_id
+    )
+    s = scenario_manager.get_by_id(scenario_id)
+    cr: ContentRegistry = get_app().server.content_registry
+
+    if not s:
+        return "Scenario not found."
+
+    return cr.compare_side_by_side(s, "right")
+
+
+@callback(
+    Output(PERF_PRIMARY_RESULTS, "children"),
+    Input(LEFT_SCENARIO_DROPDOWN, "value"),
+    Input(RIGHT_SCENARIO_DROPDOWN, "value"),
+    State(ACTIVE_SESSION, "data"),
+    prevent_initial_call=True,
+)
+def update_right_scenario_overview_primary(
+    left_scenario_id, right_scenario_id, session_id
+) -> html.Div:
+    sm: ScenarioManager = get_scenario_manager(get_app().server, session_id)
+    cr: ContentRegistry = get_app().server.content_registry
+
+    # check the inputs
+    if not left_scenario_id or not right_scenario_id:
+        return html.Div("Select both scenarios to create a detail view.")
+
+    # retrieve the scenarios
+    left_scenario = sm.get_by_id(left_scenario_id)
+    right_scenario = sm.get_by_id(right_scenario_id)
+
+    # check if the scenarios were found
+    if not left_scenario or not right_scenario:
+        return html.Div("One of the scenarios was not found.")
+
+    # apply the function
+    return cr.compare_compare(left_scenario, right_scenario)
+
+
+@callback(
+    Output(COMPARE_DETAIL_VIEW, "children"),
+    Input(LEFT_SCENARIO_DROPDOWN, "value"),
+    Input(RIGHT_SCENARIO_DROPDOWN, "value"),
+    State(ACTIVE_SESSION, "data"),
+    prevent_initial_call=True,
+)
+def update_right_scenario_overview_detail(
+    left_scenario_id,
+    right_scenario_id,
+    session_id: str,
+) -> html.Div | str:
+    sm: ScenarioManager = get_scenario_manager(get_app().server, session_id)
+    cr: ContentRegistry = get_app().server.content_registry
+
+    if not left_scenario_id or not right_scenario_id:
+        return "Select both scenarios to create a detail view."
+
+    if left_scenario_id == right_scenario_id:
+        return "Select two different scenarios to create a detail view."
+
+    left_scenario = sm.get_by_id(left_scenario_id)
+    right_scenario = sm.get_by_id(right_scenario_id)
+    if not left_scenario or not right_scenario:
+        return "One of the scenarios was not found."
+
+    return cr.compare_details(left_scenario, right_scenario)
+
+
+@callback(
+    Output(KPI_IMPROVEMENT_SECTION, "children"),
+    Input(LEFT_SCENARIO_DROPDOWN, "value"),
+    Input(RIGHT_SCENARIO_DROPDOWN, "value"),
+    State(ACTIVE_SESSION, "data"),
+)
+def update_kpi_comparison(left_id, right_id, active_session_name):
+    if not left_id or not right_id:
+        return html.P("Select two completed scenarios to compare KPIs.")
+    sm: ScenarioManager = get_scenario_manager(get_app().server, active_session_name)
+
+    left = sm.get_by_id(left_id)
+    right = sm.get_by_id(right_id)
+
+    if not left or not right:
+        return html.P("One or both scenarios not found.")
+
+    # Example KPI dictionaries
+    left_kpis = left.kpis
+    right_kpis = right.kpis
+
+    assert len(left_kpis) == len(right_kpis), "KPIs do not match."
+
+    cards = []
+    for tag, left_kpi in left_kpis.items():
+        right_kpi = right_kpis.get(tag)
+
+        card = kpi_card(
+            left_kpi=left_kpi,
+            right_kpi=right_kpi,
+        )
+
+        cards.append(html.Div(card, className="kpi-card-wrapper"))
+
+    return html.Div(cards, className="kpi-cards")
+
+
+@callback(
+    Output(PERF_SBS_LEFT_COLLAPSE, "is_open"),
+    Output(PERF_SBS_RIGHT_COLLAPSE, "is_open"),
+    Output(PERF_KPI_COLLAPSE, "is_open"),
+    Input(PERF_TOGGLE_CHECKLIST_LEFT, "value"),
+)
+def listen_to_left_checklist(checked):
+    sbs_open = True if "side-by-side" in checked else False
+    kpi_open = True if "kpis" in checked else False
+    return sbs_open, sbs_open, kpi_open
+
+
+@callback(
+    Output(PERF_COMPARE_COLLAPSE, "is_open"),
+    Output(PERF_DETAILS_COLLAPSE, "is_open"),
+    Input(PERF_TOGGLE_CHECKLIST_RIGHT, "value"),
+)
+def listen_to_right_checklist(checked):
+    compare_open = True if "compare" in checked else False
+    details_open = True if "details" in checked else False
+    return compare_open, details_open