algomancy-gui 0.3.16__py3-none-any.whl

algomancy_gui/data_page/dialogcallbacks.py

@@ -0,0 +1,51 @@
+from dash import Input, Output, State, callback, get_app
+
+
+from ..componentids import (
+    DATA_SELECTOR_DROPDOWN,
+    DM_DERIVE_SET_SELECTOR,
+    DM_DELETE_SET_SELECTOR,
+    DM_SAVE_SET_SELECTOR,
+    DM_DOWNLOAD_CHECKLIST,
+    DM_LIST_UPDATER_STORE,
+    ACTIVE_SESSION,
+)
+from algomancy_gui.managergetters import get_scenario_manager
+
+"""
+Callback functions for data management dialogs in the dashboard application.
+
+This module contains all the callback functions that handle interactions with
+the data management modals, including deriving, deleting, loading, and saving data.
+Each callback is associated with specific UI components and manages the state
+and data flow between the UI and the backend ScenarioManager.
+"""
+
+
+@callback(
+    [
+        Output(DATA_SELECTOR_DROPDOWN, "options", allow_duplicate=True),
+        Output(DM_DERIVE_SET_SELECTOR, "options", allow_duplicate=True),
+        Output(DM_DELETE_SET_SELECTOR, "options", allow_duplicate=True),
+        Output(DM_SAVE_SET_SELECTOR, "options", allow_duplicate=True),
+        Output(DM_DOWNLOAD_CHECKLIST, "options", allow_duplicate=True),
+    ],
+    [
+        Input(DM_LIST_UPDATER_STORE, "data"),
+    ],
+    [
+        State(ACTIVE_SESSION, "data"),
+    ],
+    prevent_initial_call=True,
+)
+def get_options_for_lists(data, session_id: str):
+    sm = get_scenario_manager(get_app().server, session_id)
+
+    options = [{"label": ds, "value": ds} for ds in sm.get_data_keys()]
+    derived_options = [
+        {"label": ds, "value": ds}
+        for ds in sm.get_data_keys()
+        if not sm.get_data(ds).is_master_data()
+    ]
+
+    return options, options, options, derived_options, options

algomancy_gui/data_page/filenamematcher.py

@@ -0,0 +1,109 @@
+from typing import List, Dict
+from itertools import zip_longest
+
+from algomancy_data import InputFileConfiguration
+
+
+def hamming_distance(s1, s2):
+    """
+    Calculates the Hamming distance between two strings.
+
+    The Hamming distance is defined as the number of differing characters between
+    two strings of equal length. If the strings are of different lengths, it will
+    compare them up to the length of the shorter string and count differing
+    characters, considering any excess characters in the longer string as
+    additional differences.
+
+    Args:
+        s1: The first string to compare.
+        s2: The second string to compare.
+
+    Returns:
+        int: The Hamming distance between the two strings.
+    """
+    return sum(c1 != c2 for c1, c2 in zip_longest(s1, s2))
+
+
+def find_closest_match(
+    file_names: List[str], file_configuration: InputFileConfiguration
+) -> str:
+    """
+    Finds the closest match to a file configuration's reference name.
+
+    Finds the file name from a list that is the closest match to a given file configuration's
+    reference name using the Hamming distance as the measure of similarity.
+
+    Args:
+        file_names (List[str]): A list of file names to evaluate.
+        file_configuration (InputFileConfiguration): Configuration object containing
+            the reference file name for comparison.
+
+    Returns:
+        str: The file name from the list that is the closest match to the reference
+            file name.
+    """
+    return min(
+        file_names,
+        key=lambda x: hamming_distance(
+            x.lower(), file_configuration.file_name_with_extension.lower()
+        ),
+    )
+
+
+def is_bijective_mapping(mapping: Dict[str, str]) -> bool:
+    """
+    Determines if the input mapping is bijective.
+
+    A mapping is bijective if every element of the domain is mapped to a unique
+    element of the codomain, and every element of the codomain is uniquely
+    mapped back to an element in the domain. This function checks the bijection
+    by verifying that the lengths of the mapping's values and keys are equal
+    to the mapping itself.
+
+    Args:
+        mapping (Dict[str, str]): A dictionary representing the mapping between
+            two sets where keys represent the domain and values represent the
+            codomain.
+
+    Returns:
+        bool: True if the mapping is bijective, otherwise False.
+    """
+    return len(mapping) == len(set(mapping.values())) and len(mapping) == len(
+        set(mapping.keys())
+    )
+
+
+def match_file_names(
+    file_configurations: List[InputFileConfiguration], file_names: List[str]
+) -> Dict[str, str]:
+    """
+    Matches file configurations to file names and attempts to create a bijective mapping.
+
+    This function takes a list of file configurations and file names and tries to match
+    each configuration to the closest corresponding name. The result will be a dictionary
+    representing a bijective mapping between the file configurations and the file names.
+    An exception is raised if such a bijective mapping cannot be established.
+
+    Args:
+        file_configurations: List of InputFileConfiguration objects to match.
+        file_names: List of available file names.
+
+    Raises:
+        AssertionError: If the number of file_names is less than or greater than the number
+            of file_configurations.
+        Exception: If a bijective mapping between file configurations and file names cannot
+            be established.
+
+    Returns:
+        A dictionary mapping file configuration names to file names.
+    """
+    assert len(file_names) >= len(file_configurations), "Missing input files"
+    assert len(file_names) <= len(file_configurations), "Too many input files"
+
+    initial_guess = {
+        fc.file_name: find_closest_match(file_names, fc) for fc in file_configurations
+    }
+    if is_bijective_mapping(initial_guess):
+        return initial_guess
+
+    raise Exception("Could not find bijective mapping.")

algomancy_gui/defaultloader.py

@@ -0,0 +1,36 @@
+from dash import html
+import dash_bootstrap_components as dbc
+
+
+def default_loader(text: str = "Loading... ", scale: float | None = None) -> html.Div:
+    """
+    Creates a default loading with animated spinner
+
+    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_font_size = 1.5
+    default_spinner_w = 1.5
+    default_spinner_h = 1.5
+
+    text_style = {}
+    spinner_style = {}
+    if scale is not None:
+        text_style["font-size"] = f"{default_font_size * scale}rem"
+        spinner_style["width"] = f"{default_spinner_w * scale}rem"
+        spinner_style["height"] = f"{default_spinner_h * scale}rem"
+    return html.Div(
+        html.H2(
+            [text, dbc.Spinner(spinner_style=spinner_style)],
+            style=text_style,
+            className="default-spinner",
+        ),
+    )

algomancy_gui/gui_launcher.py

@@ -0,0 +1,183 @@
+from typing import Dict, Any, Union
+import importlib.metadata
+import os
+
+from waitress import serve
+import dash_auth
+from dash import get_app, Dash, html, dcc
+from dash_bootstrap_components.themes import BOOTSTRAP
+
+from .layout import LayoutCreator
+from .contentregistry import ContentRegistry
+from .settingsmanager import SettingsManager
+from .sessionmanager import SessionManager
+from .componentids import ACTIVE_SESSION
+from .appconfiguration import AppConfiguration
+from algomancy_content.librarymanager import LibraryManager as lm
+from algomancy_scenario import ScenarioManager
+from algomancy_utils.logger import MessageStatus
+
+
+class GuiLauncher:
+    @staticmethod
+    def build(cfg: Union[AppConfiguration, Dict[str, Any]]) -> Dash:
+        # Normalize configuration to AppConfiguration for a single source of truth
+        if isinstance(cfg, dict):
+            cfg_obj = AppConfiguration(**cfg)
+        elif isinstance(cfg, AppConfiguration):
+            cfg_obj = cfg
+        else:
+            raise TypeError("DashLauncher.build expects AppConfiguration or dict")
+
+        if cfg_obj.use_sessions:
+            manager: SessionManager = SessionManager.from_config(cfg_obj)
+        else:
+            manager: ScenarioManager = ScenarioManager.from_config(cfg_obj)
+
+        # Create the app
+        app = GuiLauncher._construct(
+            cfg=cfg_obj,
+            manager=manager,
+        )
+
+        # register authentication if enabled
+        if cfg_obj.use_authentication:
+            if not os.getenv("APP_USERNAME") or not os.getenv("APP_PASSWORD"):
+                raise ValueError(
+                    "Environment variables 'APP_USERNAME' and 'APP_PASSWORD' must be set"
+                )  # todo document where to set username and password
+
+            # add authentication to the app
+            dash_auth.BasicAuth(
+                app,
+                [[os.getenv("APP_USERNAME"), os.getenv("APP_PASSWORD")]],
+                secret_key="secret-key",
+            )
+
+        return app
+
+    @staticmethod
+    def _construct(
+        cfg: AppConfiguration,
+        manager: SessionManager | ScenarioManager,
+    ) -> Dash:
+        # Initialize the app
+        external_stylesheets = [
+            BOOTSTRAP,
+            "https://use.fontawesome.com/releases/v5.15.4/css/all.css",
+        ]
+
+        from pathlib import Path
+
+        assets_path = Path(os.getcwd()) / Path(cfg.assets_path)
+
+        app = Dash(
+            external_stylesheets=external_stylesheets,
+            suppress_callback_exceptions=True,
+            assets_folder=str(assets_path),
+        )
+        app.title = cfg.title
+
+        # register the scenario manager on the app object
+        if isinstance(manager, SessionManager):
+            app.server.session_manager = manager
+            app.server.use_sessions = True
+            default_session_name = app.server.session_manager.start_session_name
+        elif isinstance(manager, ScenarioManager):
+            app.server.scenario_manager = manager
+            app.server.use_sessions = False
+            default_session_name = None
+        else:
+            raise TypeError(
+                "DashLauncher._construct expects SessionManager or ScenarioManager"
+            )
+
+        # register the styling configuration on the app object
+        app.server.styling_config = cfg.styling_config
+
+        # register the settings manager on the app object for access in callbacks
+        app.server.settings = SettingsManager(cfg.as_dict())
+
+        # fetch standard pages
+        home_page, data_page, scenario_page, compare_page, overview_page = lm.get_pages(
+            cfg.as_dict()
+        )
+
+        # register the content register functions
+        content_registry = ContentRegistry()
+        app.server.content_registry = content_registry
+
+        # register pages
+        content_registry.register_pages(
+            home_page, data_page, scenario_page, compare_page, overview_page
+        )
+
+        # fill and run the app
+        app.layout = html.Div(
+            [
+                LayoutCreator.create_layout(cfg.styling_config),
+                dcc.Store(
+                    id=ACTIVE_SESSION,
+                    storage_type="session",
+                    data=default_session_name,
+                ),
+            ]
+        )
+
+        return app
+
+    @staticmethod
+    def run(
+        app: Dash,
+        host: str,
+        port: int,
+        threads: int = 8,
+        connection_limit: int = 100,
+        debug: bool = False,
+    ) -> None:
+        server = get_app().server
+        if hasattr(server, "session_manager"):
+            manager = server.session_manager
+        elif hasattr(server, "scenario_manager"):
+            manager = server.scenario_manager
+        else:
+            raise Exception("No manager available")
+
+        algomancy_version = importlib.metadata.version("algomancy")
+        manager.log(f"Algomancy version: {algomancy_version}", MessageStatus.INFO)
+
+        if not debug:
+            manager.log(
+                "--------------------------------------------------------------------",
+                MessageStatus.SUCCESS,
+            )
+            manager.log(
+                f"Starting Dashboard server with Waitress on {host}:{port}...",
+                MessageStatus.SUCCESS,
+            )
+            manager.log(
+                f"  threads:{threads}, connection limit: {connection_limit}",
+                MessageStatus.SUCCESS,
+            )
+            manager.log(
+                "--------------------------------------------------------------------",
+                MessageStatus.SUCCESS,
+            )
+            serve(
+                app.server,
+                host=host,
+                port=port,
+                threads=threads,
+                connection_limit=connection_limit,
+            )
+        else:
+            manager.log(
+                f"Starting Dashboard server in debug mode on {host}:{port}...",
+                MessageStatus.SUCCESS,
+            )
+            app.run(
+                debug=debug,
+                host=host,
+                port=port,
+                dev_tools_silence_routes_logging=False,
+            )

algomancy_gui/home_page/__init__.py

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

algomancy_gui/home_page/home.py

@@ -0,0 +1,16 @@
+from dash import html, get_app
+
+from algomancy_gui.contentregistry import ContentRegistry
+
+from ..componentids import HOME_PAGE_CONTENT
+
+
+def home_page():
+    """
+    Creates the home page layout.
+
+    Returns:
+        html.Div: A Dash HTML component representing the home page
+    """
+    cr: ContentRegistry = get_app().server.content_registry
+    return html.Div(cr.home_content(), id=HOME_PAGE_CONTENT)

algomancy_gui/layout.py

@@ -0,0 +1,199 @@
+from typing import Any
+
+
+import dash_bootstrap_components as dbc
+from dash import html, Output, callback, Input, State, dcc
+from dash.html import Div
+
+from algomancy_gui.stylingconfigurator import StylingConfigurator, LayoutSelection
+from algomancy_gui.componentids import (
+    SIDEBAR_TOGGLE,
+    SIDEBAR,
+    PAGE_CONTENT,
+    SIDEBAR_COLLAPSED,
+)
+
+from algomancy_gui.home_page.home import home_page
+from algomancy_gui.data_page.data import data_page
+from algomancy_gui.scenario_page.scenarios import scenario_page
+from algomancy_gui.compare_page.compare import compare_page
+from algomancy_gui.admin_page.admin import admin_page
+from algomancy_gui.overview_page.overview import overview_page
+
+
+class LayoutCreator:
+    @staticmethod
+    def _create_menu_sidebar(styling: StylingConfigurator):
+        # Create toggle button
+        toggle_button = html.Button(
+            html.I(className="fas fa-chevron-left"),
+            id=SIDEBAR_TOGGLE,
+            className="btn toggle-sidebar-button",
+        )
+
+        # Create the sidebar (build children list dynamically based on available images)
+        sidebar_children: list[Any] = [toggle_button]
+        if styling.logo_url is not None or styling.button_url is not None:
+            logos = []
+            if styling.logo_url is not None:
+                logos.append(
+                    html.Img(
+                        src=styling.logo_url,
+                        width="210px",
+                        className="mb-2 expanded-logo sidebar-content-fade",
+                        id="sidebar-logo",
+                    )
+                )
+
+            if styling.button_url is not None:
+                logos.append(
+                    html.Img(
+                        src=styling.button_url,
+                        width="40px",
+                        className="mb-2 collapsed-logo",
+                        id="sidebar-icon",
+                    )
+                )
+            sidebar_children.extend(
+                [
+                    html.Div(
+                        logos,
+                        className="sidebar-logo-wrapper",
+                        id="sidebar-logo-wrapper",
+                    ),
+                    html.Hr(className="bg-light"),
+                ]
+            )
+
+        nav_items = [
+            {"icon": "fas fa-home", "label": "Home", "href": "/", "index": 1},
+            {"icon": "fas fa-database", "label": "Data", "href": "/data", "index": 2},
+            {
+                "icon": "fas fa-project-diagram",
+                "label": "Scenarios",
+                "href": "/scenarios",
+                "index": 3,
+            },
+            {
+                "icon": "fas fa-chart-line",
+                "label": "Compare",
+                "href": "/compare",
+                "index": 4,
+            },
+            {
+                "icon": "fas fa-table",
+                "label": "Overview",
+                "href": "/overview",
+                "index": 5,
+            },
+            {
+                "icon": "fas fa-user-shield",
+                "label": "Admin",
+                "href": "/admin",
+                "index": 6,
+            },
+        ]
+
+        sidebar_nav = dbc.Nav(
+            [
+                dbc.NavLink(
+                    [
+                        html.I(className=f"{item['icon']} me-2"),
+                        html.Span(
+                            item["label"],
+                            id={"type": "sidebar-text", "index": item["index"]},
+                            className="sidebar-content-fade",
+                        ),
+                    ],
+                    href=item["href"],
+                    className="sidebar-link",
+                    id={"type": "sidebar-link", "index": item["index"]},
+                    active="exact",
+                )
+                for item in nav_items
+            ],
+            vertical=True,
+            pills=True,
+            className="sidebar-nav",
+        )
+
+        sidebar_children.append(sidebar_nav)
+
+        # Create sidebar
+        sidebar = html.Div(
+            sidebar_children,
+            id=SIDEBAR,
+            className="expanded sidebar-layout",
+        )
+
+        # Routing callback
+        @callback(Output("page-content", "children"), Input("url", "pathname"))
+        def display_page(pathname):
+            if pathname == "/":
+                return home_page()
+            elif pathname == "/data":
+                return data_page()
+            elif pathname == "/scenarios":
+                return scenario_page()
+            elif pathname == "/compare":
+                return compare_page()
+            elif pathname == "/overview":
+                return overview_page()
+            elif pathname == "/admin":
+                return admin_page()
+            else:
+                return html.H1("404 - Page not found")
+
+        @callback(
+            Output(SIDEBAR, "className"),
+            Output(PAGE_CONTENT, "className"),
+            Input(SIDEBAR_TOGGLE, "n_clicks"),
+            State(SIDEBAR, "className"),
+            State(PAGE_CONTENT, "className"),
+        )
+        def update_sidebar_class(
+            n_clicks, current_sidebar_className, current_page_content_className
+        ):
+            if n_clicks is None:
+                return current_sidebar_className, current_page_content_className
+            is_expanded = "collapsed" not in current_sidebar_className
+            if is_expanded:
+                return "collapsed sidebar-layout", "collapsed page-content"
+            else:
+                return "expanded sidebar-layout", "expanded page-content"
+
+        return sidebar
+
+    @staticmethod
+    def _create_sidebar_layout(styling: StylingConfigurator) -> html.Div:
+        themed_styling = styling.initiate_theme_colors()
+
+        layout = html.Div(
+            [
+                dcc.Location(id="url", refresh=False),
+                dcc.Store(id=SIDEBAR_COLLAPSED, data=False),
+                html.Div(
+                    [
+                        LayoutCreator._create_menu_sidebar(styling),
+                        html.Div(id=PAGE_CONTENT, className="expanded page-content"),
+                    ],
+                    className="layout-container",
+                ),
+            ],
+            style=themed_styling,
+        )
+
+        return layout
+
+    @staticmethod
+    def create_layout(styling_config: StylingConfigurator) -> Div | None:
+        match styling_config.layout_selection:
+            case LayoutSelection.SIDEBAR:
+                return LayoutCreator._create_sidebar_layout(styling_config)
+            case LayoutSelection.TABBED:
+                raise NotImplementedError
+            case LayoutSelection.FULLSCREEN:
+                raise NotImplementedError
+            case LayoutSelection.CUSTOM:
+                raise NotImplementedError
+        return None

algomancy_gui/layouthelpers.py

@@ -0,0 +1,30 @@
+from dash import html, dcc
+
+from algomancy_gui.cqmloader import cqm_loader
+from algomancy_gui.defaultloader import default_loader
+
+
+def create_wrapped_content_div(
+    content_div: html.Div,
+    show_loading: bool,
+    cqm: bool,
+    spinner_scale: float = 2,
+) -> html.Div:
+    if show_loading:
+        spinner = (
+            cqm_loader(scale=spinner_scale)
+            if cqm
+            else default_loader(scale=spinner_scale)
+        )
+        return html.Div(
+            dcc.Loading(
+                content_div,
+                overlay_style={"visibility": "visible", "filter": "blur(2px)"},
+                custom_spinner=spinner,
+                delay_hide=0,
+                delay_show=200,
+                className="loading-wrapper",
+            ),
+        )
+    else:
+        return content_div

algomancy_gui/managergetters.py

@@ -0,0 +1,28 @@
+from algomancy_scenario import ScenarioManager
+
+
+def get_scenario_manager(
+    server, active_session_name: str | None = None
+) -> ScenarioManager:
+    """Returns the scenario manager.
+    When sessions are enabled, this will return the active scenario manager via the session manager.
+    When sessions are disabled, this will return the scenario manager which was registered on the server object
+    """
+    if hasattr(server, "session_manager"):
+        sm: ScenarioManager = server.session_manager.get_scenario_manager(
+            active_session_name
+        )
+    elif hasattr(server, "scenario_manager"):
+        sm: ScenarioManager = server.scenario_manager
+    else:
+        raise Exception("No sessionmanager or scenario manager available")
+    return sm
+
+
+def get_manager(server):
+    if hasattr(server, "session_manager"):
+        return server.session_manager
+    elif hasattr(server, "scenario_manager"):
+        return server.scenario_manager
+    else:
+        raise Exception("No sessionmanager or scenario manager available")

algomancy_gui/overview_page/__init__.py

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

algomancy_gui/overview_page/overview.py

@@ -0,0 +1,20 @@
+from dash import html, get_app
+
+from algomancy_gui.componentids import OVERVIEW_PAGE_CONTENT
+from algomancy_gui.contentregistry import ContentRegistry
+
+
+def overview_page():
+    """
+    Creates the overview page layout with a table of completed scenarios and their KPIs.
+
+    This page displays a table where rows represent completed scenarios and columns represent KPIs.
+
+    Returns:
+        html.Div: A Dash HTML component representing the overview page
+    """
+    cr: ContentRegistry = get_app().server.content_registry
+
+    page = html.Div(cr.overview_content(), id=OVERVIEW_PAGE_CONTENT)
+
+    return page