algomancy-gui 0.3.16__py3-none-any.whl

algomancy_gui/data_page/datamanagementsavemodal.py

@@ -0,0 +1,191 @@
+import dash
+import dash_bootstrap_components as dbc
+from dash import dcc, callback, Output, Input, no_update, State, get_app
+
+from algomancy_scenario import ScenarioManager
+
+from ..componentids import (
+    DM_SAVE_MODAL,
+    DM_SAVE_MODAL_CLOSE_BTN,
+    DM_SAVE_SET_SELECTOR,
+    DM_SAVE_SUBMIT_BUTTON,
+    DM_SAVE_OPEN_BUTTON,
+    DATA_MAN_SUCCESS_ALERT,
+    DATA_MAN_ERROR_ALERT,
+    ACTIVE_SESSION,
+)
+from algomancy_gui.managergetters import get_scenario_manager
+
+"""
+Modal component for saving derived datasets as master data.
+
+This module provides a modal dialog that allows users to select and save
+derived datasets as master data, which persists the data to disk.
+"""
+
+
+def create_derived_data_selector(sm: ScenarioManager):
+    """
+    Creates a dropdown component for selecting derived datasets.
+
+    Filters the available datasets to show only derived (non-master) datasets.
+
+    Args:
+        sm: ScenarioManager instance used to retrieve and filter datasets
+
+    Returns:
+        dcc.Dropdown: A Dash dropdown component populated with derived datasets
+    """
+    derived_options = [
+        {"label": ds, "value": ds}
+        for ds in sm.get_data_keys()
+        if not sm.get_data(ds).is_master_data()
+    ]
+
+    return dcc.Dropdown(
+        id=DM_SAVE_SET_SELECTOR,
+        value="",
+        options=derived_options,
+        placeholder="Select dataset",
+    )
+
+
+def data_management_save_modal(sm: ScenarioManager, themed_styling):
+    """
+    Creates a modal dialog component for saving derived datasets as master data.
+
+    The modal contains a dropdown to select the derived dataset to save and
+    buttons to save or cancel the operation.
+
+    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("Save"), close_button=False),
+            dbc.ModalBody(
+                ["Select derived data to save.", create_derived_data_selector(sm)]
+            ),
+            dbc.ModalFooter(
+                [
+                    dbc.Button(
+                        "Save",
+                        id=DM_SAVE_SUBMIT_BUTTON,
+                        class_name="dm-save-modal-confirm-btn",
+                    ),
+                    dbc.Button(
+                        "Close",
+                        id=DM_SAVE_MODAL_CLOSE_BTN,
+                        class_name="dm-save-modal-cancel-btn ms-auto",
+                    ),
+                ]
+            ),
+        ],
+        id=DM_SAVE_MODAL,
+        is_open=False,
+        centered=True,
+        class_name="themed-modal",
+        style=themed_styling,
+        keyboard=False,
+        backdrop="static",
+    )
+
+
+@callback(
+    Output(DM_SAVE_MODAL, "is_open"),
+    [
+        Input(DM_SAVE_OPEN_BUTTON, "n_clicks"),
+        Input(DM_SAVE_MODAL_CLOSE_BTN, "n_clicks"),
+    ],
+    [dash.dependencies.State(DM_SAVE_MODAL, "is_open")],
+)
+def toggle_modal_save(open_clicks, close_clicks, is_open):
+    """
+    Toggles the visibility of the save 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
+
+
+@callback(
+    Output(DM_SAVE_SET_SELECTOR, "value"),
+    Input(DM_SAVE_MODAL, "is_open"),
+    prevent_initial_call=True,
+)
+def reset_save_selection_on_close(modal_is_open: bool):
+    """
+    Resets the save dataset selector when the save 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_SAVE_MODAL, "is_open", 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),
+    Input(DM_SAVE_SUBMIT_BUTTON, "n_clicks"),
+    State(DM_SAVE_SET_SELECTOR, "value"),
+    State(ACTIVE_SESSION, "data"),
+    prevent_initial_call=True,
+)
+def save_derived_data(
+    n_clicks,
+    set_name: str,
+    session_id: str,
+):
+    """
+    Saves a derived dataset as master data when the save button is clicked.
+
+    Stores the dataset files to disk and updates the dataset's status to master data.
+    Displays success or error messages and closes the modal upon completion.
+
+    Args:
+        n_clicks: Number of times the submit button has been clicked
+        set_name: Name of the dataset to save
+        session_id: ID of the active session
+
+    Returns:
+        Tuple containing modal state and alert messages
+    """
+
+    sm: ScenarioManager = get_scenario_manager(get_app().server, session_id)
+
+    try:
+        data = sm.get_data(set_name)
+        data.set_to_master_data()
+
+        if sm.save_type == "json":
+            sm.store_data_as_json(set_name)
+        else:
+            raise ValueError(f"Unknown save type: {sm.save_type}")
+
+        return False, "Files saved successfully", True, "", False
+    except Exception as e:
+        sm.logger.error(f"Problem with saving: {str(e)}")
+        sm.logger.log_traceback(e)
+        return False, "", False, f"Problem with saving: {str(e)}", True

algomancy_gui/data_page/datamanagementtopbar.py

@@ -0,0 +1,123 @@
+from dash import html, dcc, get_app
+import dash_bootstrap_components as dbc
+
+from algomancy_scenario import ScenarioManager
+
+from .datamanagementdeletemodal import data_management_delete_modal
+from .datamanagementderivemodal import data_management_derive_modal
+from .datamanagementdownloadmodal import data_management_download_modal
+from .datamanagementimportmodal import data_management_import_modal
+from .datamanagementsavemodal import data_management_save_modal
+from .datamanagementuploadmodal import data_management_upload_modal
+from ..componentids import (
+    DATA_SELECTOR_DROPDOWN,
+    DATA_MAN_SUCCESS_ALERT,
+    DATA_MAN_ERROR_ALERT,
+    DM_DELETE_OPEN_BUTTON,
+    DM_DERIVE_OPEN_BTN,
+    DM_SAVE_OPEN_BUTTON,
+    DM_IMPORT_OPEN_BUTTON,
+    DM_UPLOAD_OPEN_BUTTON,
+    DM_DOWNLOAD_OPEN_BUTTON,
+    DM_LIST_UPDATER_STORE,
+)
+
+
+def top_bar(sm: ScenarioManager):
+    toolbar = create_data_management_toolbar(sm)
+    active_dataset_selector = create_datasource_selector(sm)
+
+    return html.Div(
+        [
+            dbc.Row(
+                [
+                    dcc.Store(DM_LIST_UPDATER_STORE, data=""),
+                    dbc.Col(active_dataset_selector, width=8),
+                    dbc.Col(toolbar, width=4),
+                ]
+            ),
+            dbc.Alert(
+                id=DATA_MAN_SUCCESS_ALERT,
+                color="success",
+                is_open=False,
+                dismissable=True,
+                duration=4000,
+                class_name="mt-2",
+            ),
+            dbc.Alert(
+                id=DATA_MAN_ERROR_ALERT,
+                color="danger",
+                is_open=False,
+                dismissable=True,
+                duration=4000,
+                class_name="mt-2",
+            ),
+        ]
+    )
+
+
+def create_data_management_toolbar(sm: ScenarioManager):
+    themed_styling = get_app().server.styling_config.initiate_theme_colors()
+
+    return html.Div(
+        [
+            dbc.ButtonGroup(
+                [
+                    dbc.Button(
+                        "Derive", id=DM_DERIVE_OPEN_BTN, className="me-2 dm-derive-btn"
+                    ),
+                    dbc.Button(
+                        "Delete",
+                        id=DM_DELETE_OPEN_BUTTON,
+                        className="me-2 dm-delete-btn",
+                    ),
+                    dbc.Button(
+                        "Save",
+                        id=DM_SAVE_OPEN_BUTTON,
+                        disabled=not sm.has_persistent_state,
+                        className="me-2 dm-save-btn",
+                    ),
+                    dbc.Button(
+                        "Import",
+                        id=DM_IMPORT_OPEN_BUTTON,  # adjust callback
+                        className="me-2 dm-import-btn",
+                    ),
+                    dbc.Button(
+                        "Upload",
+                        id=DM_UPLOAD_OPEN_BUTTON,  # adjust callback
+                        className="me-2 dm-upload-btn",
+                    ),
+                    dbc.Button(
+                        "Download",
+                        id=DM_DOWNLOAD_OPEN_BUTTON,  # adjust callback
+                        className="me-2 dm-download-btn",
+                    ),
+                ],
+                className="d-flex justify-content-end",
+            ),
+            data_management_derive_modal(sm, themed_styling),
+            data_management_delete_modal(sm, themed_styling),
+            data_management_save_modal(sm, themed_styling),
+            data_management_import_modal(sm, themed_styling),
+            data_management_upload_modal(sm, themed_styling),
+            data_management_download_modal(sm, themed_styling),
+        ]
+    )
+
+
+def create_datasource_selector(sm: ScenarioManager) -> html.Div:
+    dropdown = dcc.Dropdown(
+        id=DATA_SELECTOR_DROPDOWN,
+        options=[{"label": ds, "value": ds} for ds in sm.get_data_keys()],
+        placeholder="Select dataset",
+    )
+
+    return html.Div(
+        dbc.Row(
+            [
+                dbc.Col(html.P("Active dataset: "), width=2),
+                dbc.Col(dropdown, width=10),
+            ]
+        ),
+        className="mb-4",
+    )

algomancy_gui/data_page/datamanagementuploadmodal.py

@@ -0,0 +1,366 @@
+import base64
+from datetime import datetime
+
+import dash_bootstrap_components as dbc
+from dash import html, dcc, get_app, callback, Output, Input, State, no_update
+from dash.exceptions import PreventUpdate
+
+from algomancy_scenario import ScenarioManager
+from ..componentids import (
+    DM_UPLOAD_MODAL_CLOSE_BTN,
+    DM_UPLOAD_MODAL_FILEVIEWER_CARD,
+    DM_UPLOAD_MODAL_FILEVIEWER_COLLAPSE,
+    DM_UPLOAD_OPEN_BUTTON,
+    DM_UPLOAD_SUBMIT_BUTTON,
+    DM_UPLOAD_UPLOADER,
+    DM_UPLOAD_MODAL,
+    ACTIVE_SESSION,
+)
+from ..componentids import (
+    DM_UPLOAD_SUCCESS_ALERT,
+    DM_LIST_UPDATER_STORE,
+)
+from ..cqmloader import cqm_loader
+from ..defaultloader import default_loader
+from algomancy_gui.managergetters import get_scenario_manager
+from ..settingsmanager import SettingsManager
+
+
+"""
+Modal component for loading data files into the application.
+
+This module provides a modal dialog that allows users to upload CSV files,
+view file mapping information, and create new datasets from the uploaded files.
+"""
+
+
+def data_management_upload_modal(sm: ScenarioManager, themed_styling):
+    """
+    Creates a modal dialog component for loading data files.
+
+    The modal contains a file upload area, a collapsible section for displaying
+    file mapping information, an input field for naming the new dataset, and
+    an alert area for displaying messages.
+
+    Returns:
+        dbc.Modal: A Dash Bootstrap Components modal dialog
+    """
+    settings: SettingsManager = get_app().server.settings
+
+    if settings.use_cqm_loader:
+        spinner = cqm_loader(
+            "Importing data..."
+        )  # requires letter-c.svg, letter-q.svg and letter-m.svg
+    else:
+        spinner = default_loader("Importing data...")
+
+    return dbc.Modal(
+        [
+            dbc.ModalHeader(dbc.ModalTitle("Upload Cases"), close_button=False),
+            dbc.ModalBody(
+                dcc.Loading(
+                    [
+                        dbc.Label(
+                            "The uploaded file will be uploaded as a new dataset."
+                            "The name of the dataset will be the name of the uploaded file."
+                            f"The file must be in {sm.save_type} format."
+                        ),
+                        dcc.Upload(
+                            id=DM_UPLOAD_UPLOADER,
+                            children=html.Div(
+                                ["Drag and Drop or ", html.A("Select Files")]
+                            ),
+                            style={
+                                "width": "100%",
+                                "height": "60px",
+                                "lineHeight": "60px",
+                                "borderWidth": "1px",
+                                "borderStyle": "dashed",
+                                "borderRadius": "4px",
+                                "textAlign": "center",
+                            },
+                            multiple=True,
+                        ),
+                        # dcc.Store(DM_UPLOAD_DATA_STORE, data=""),
+                        dbc.Collapse(
+                            children=[
+                                dbc.Card(
+                                    dbc.CardBody(id=DM_UPLOAD_MODAL_FILEVIEWER_CARD),
+                                    className="uploaded-files-card",
+                                ),
+                            ],
+                            id=DM_UPLOAD_MODAL_FILEVIEWER_COLLAPSE,
+                            is_open=False,
+                            class_name="mt-2 mb-2",
+                        ),
+                        dbc.Alert(
+                            children="Upload successful! Close the modal to continue.",
+                            id=DM_UPLOAD_SUCCESS_ALERT,
+                            color="success",
+                            is_open=False,
+                        ),
+                        dcc.Store("dm-upload-dummy-store", data=""),
+                    ],
+                    overlay_style={
+                        "visibility": "visible",
+                        "opacity": 0.5,
+                        "backgroundColor": "white",
+                    },
+                    custom_spinner=spinner,
+                    delay_hide=50,
+                    delay_show=50,
+                )
+            ),
+            dbc.ModalFooter(
+                [
+                    dbc.Button(
+                        "Upload",
+                        id=DM_UPLOAD_SUBMIT_BUTTON,
+                        class_name="dm-upload-modal-confirm-btn",
+                    ),
+                    dbc.Button(
+                        "Close",
+                        id=DM_UPLOAD_MODAL_CLOSE_BTN,
+                        class_name="dm-upload-modal-cancel-btn ms-auto",
+                    ),
+                ]
+            ),
+        ],
+        id=DM_UPLOAD_MODAL,
+        is_open=False,
+        centered=True,
+        class_name="themed-modal",
+        style=themed_styling,
+        keyboard=False,
+        backdrop="static",
+    )
+
+
+@callback(
+    Output(DM_UPLOAD_MODAL, "is_open", allow_duplicate=True),
+    Input(DM_UPLOAD_OPEN_BUTTON, "n_clicks"),
+    Input(DM_UPLOAD_MODAL_CLOSE_BTN, "n_clicks"),
+    State(DM_UPLOAD_MODAL, "is_open"),
+    prevent_initial_call=True,
+)
+def open_close_modal(n_open, n_close, is_open):
+    """
+    Callback for opening and closing the dialog modal
+    """
+    if n_open or n_close:
+        return not is_open
+    return is_open
+
+
+@callback(
+    [
+        Output(DM_UPLOAD_MODAL_FILEVIEWER_CARD, "children", allow_duplicate=True),
+        Output(DM_UPLOAD_MODAL_FILEVIEWER_COLLAPSE, "is_open", allow_duplicate=True),
+        Output(DM_UPLOAD_UPLOADER, "disabled", allow_duplicate=True),
+        Output(DM_UPLOAD_UPLOADER, "filename", allow_duplicate=True),
+        Output(DM_UPLOAD_UPLOADER, "contents", allow_duplicate=True),
+        Output(DM_UPLOAD_SUCCESS_ALERT, "is_open", allow_duplicate=True),
+    ],
+    Input(DM_UPLOAD_MODAL, "is_open"),
+    prevent_initial_call=True,
+)
+def reset_on_close(is_open):
+    if not is_open:
+        return [], False, False, None, None, False
+    return no_update, no_update, no_update, no_update, no_update, no_update
+
+
+def _render_uploaded_files(filenames, wrong_filenames) -> html.Div:
+    """
+    Helper function to create a rendering of uploaded files
+    """
+    file_name_width = 8
+    status_width = 12 - file_name_width
+
+    header = html.Div(
+        dbc.Row(
+            [
+                dbc.Col(
+                    [
+                        html.Strong("File name"),
+                    ],
+                    width=file_name_width,
+                ),
+                dbc.Col(
+                    [
+                        html.Strong("Status"),
+                    ],
+                    width=status_width,
+                ),
+            ]
+        ),
+        className="uploaded-files-header",
+    )
+
+    body = [
+        html.Div(
+            dbc.Row(
+                [
+                    dbc.Col([f"{filename}"], width=file_name_width),
+                    dbc.Col(
+                        [
+                            dbc.Spinner(
+                                html.Div(
+                                    id={"type": "dm-upload-status", "index": filename}
+                                )
+                            )
+                        ],
+                        width=status_width,
+                    ),
+                ]
+            ),
+            className="uploaded-file-good",
+        )
+        for filename in filenames
+    ] + [
+        html.Div(
+            dbc.Row(
+                [
+                    dbc.Col(
+                        [f"{filename}"],
+                        width=file_name_width,
+                    ),
+                    dbc.Col(
+                        [
+                            dbc.Spinner(
+                                html.Div(
+                                    id={"type": "dm-upload-status", "index": filename}
+                                )
+                            )
+                        ],
+                        width=status_width,
+                    ),
+                ]
+            ),
+            className="uploaded-file-bad",
+        )
+        for filename in wrong_filenames
+    ]
+
+    table_div = html.Div([header, *body], className="uploaded-files-table")
+
+    return table_div
+
+
+def check_files(filenames, session_id: str):
+    sm: ScenarioManager = get_scenario_manager(get_app().server, session_id)
+    allowed_type = sm.save_type
+
+    filenames_with_wrong_type = [
+        file_name
+        for file_name in filenames
+        if not file_name.lower().endswith(allowed_type.lower())
+    ]
+
+    filenames_with_allowed_type = [
+        file_name
+        for file_name in filenames
+        if file_name.lower().endswith(allowed_type.lower())
+    ]
+
+    filenames_already_present = [
+        file_name
+        for file_name in filenames_with_allowed_type
+        if file_name.split(".")[0] in sm.get_data_keys()
+    ]
+
+    filenames_not_present = [
+        file_name
+        for file_name in filenames_with_allowed_type
+        if file_name.split(".")[0] not in sm.get_data_keys()
+    ]
+
+    return filenames_not_present, filenames_already_present + filenames_with_wrong_type
+
+
+@callback(
+    [
+        Output(DM_UPLOAD_MODAL_FILEVIEWER_CARD, "children", allow_duplicate=True),
+        Output(DM_UPLOAD_MODAL_FILEVIEWER_COLLAPSE, "is_open", allow_duplicate=True),
+        Output(DM_UPLOAD_UPLOADER, "disabled", allow_duplicate=True),
+    ],
+    Input(DM_UPLOAD_UPLOADER, "filename"),
+    State(ACTIVE_SESSION, "data"),
+    prevent_initial_call=True,
+)
+def update_file_viewer(filename, session_id: str):
+    """
+    Callback to respond to file upload events
+    """
+    if filename is None:
+        return [], False, False
+
+    # Allow for possible list/file array
+    if isinstance(filename, list):
+        filenames = filename
+    else:
+        filenames = [filename]
+
+    good_files, bad_files = check_files(filenames, session_id)
+
+    return html.Div([_render_uploaded_files(good_files, bad_files)]), True, True
+
+
+@callback(
+    [
+        Output(DM_LIST_UPDATER_STORE, "data", allow_duplicate=True),
+        Output(DM_UPLOAD_SUBMIT_BUTTON, "disabled", allow_duplicate=True),
+        Output(DM_UPLOAD_SUCCESS_ALERT, "is_open", allow_duplicate=True),
+        Output("dm-upload-dummy-store", "data", allow_duplicate=True),
+    ],
+    Input(DM_UPLOAD_SUBMIT_BUTTON, "n_clicks"),
+    State(DM_UPLOAD_UPLOADER, "contents"),
+    State(DM_UPLOAD_UPLOADER, "filename"),
+    State(ACTIVE_SESSION, "data"),
+    prevent_initial_call=True,
+)
+def process_uploaded_files(n_clicks, contents, filenames, session_id: str):
+    """
+    Process uploaded files when the submit button is clicked.
+
+    Returns:
+        bool: Whether to close the modal
+    """
+    if n_clicks is None or not n_clicks or contents is None or filenames is None:
+        raise PreventUpdate
+
+    sm: ScenarioManager = get_scenario_manager(get_app().server, session_id)
+
+    # Make sure we're working with lists
+    if not isinstance(filenames, list):
+        filenames = [filenames]
+        contents = [contents]
+
+    # Filter good files
+    good_files, _ = check_files(filenames, session_id)
+    files_with_content = zip(filenames, contents)
+    good_files_with_content = [
+        (filename, content)
+        for filename, content in files_with_content
+        if filename in good_files
+    ]
+
+    for filename, content in good_files_with_content:
+        try:
+            # Process the file content
+            content_type, content_string = content.split(",", 1)
+            decoded = base64.b64decode(content_string)
+            json_string = decoded.decode("utf-8")
+
+            # Add data source to scenario manager
+            sm.add_datasource_from_json(json_string)
+
+            # Log
+            sm.logger.success(f"Successfully uploaded {filename} to data manager.")
+
+        except Exception as e:
+            sm.logger.error(f"Error processing uploaded file {filename}: {e}")
+            sm.logger.log_traceback(e)
+
+    # Close the modal
+    return datetime.now(), [True], True, ""