simian-examples 3.3.0__py3-none-any.whl

simian/examples/workshop_example.json

@@ -0,0 +1,211 @@
+{
+    "components": [
+        {
+            "label": "Load GAP Minder data",
+            "showValidations": false,
+            "disableOnInvalid": true,
+            "tableView": false,
+            "key": "loadData",
+            "type": "button",
+            "action": "event",
+            "input": true,
+            "event": "LoadData"
+        },
+        {
+            "label": "No data",
+            "content": "<b>No data loaded.</b>",
+            "refreshOnChange": false,
+            "key": "noData",
+            "customConditional": "show = !('availableYears' in data) || data.availableYears.length == 0;",
+            "type": "htmlelement",
+            "input": false,
+            "tableView": false
+        },
+        {
+            "label": "Available continents",
+            "key": "availableContinents",
+            "type": "hidden",
+            "input": true,
+            "tableView": false
+        },
+        {
+            "label": "Select continent(s)",
+            "labelPosition": "left-left",
+            "widget": "choicesjs",
+            "tableView": true,
+            "multiple": true,
+            "dataSrc": "custom",
+            "data": {
+                "custom": "values=data.availableContinents"
+            },
+            "key": "selectContinents",
+            "customConditional": "show = 'availableContinents' in data && data.availableContinents.length != 0",
+            "type": "select",
+            "input": true
+        },
+        {
+            "label": "Tabs",
+            "components": [
+                {
+                    "label": "Data",
+                    "key": "dataTab",
+                    "components": [
+                        {
+                            "label": "Data Columns",
+                            "columns": [
+                                {
+                                    "components": [
+                                        {
+                                            "label": "Available years",
+                                            "key": "availableYears",
+                                            "type": "hidden",
+                                            "input": true,
+                                            "tableView": false
+                                        },
+                                        {
+                                            "label": "Select year(s)",
+                                            "labelPosition": "left-left",
+                                            "widget": "choicesjs",
+                                            "tableView": true,
+                                            "multiple": true,
+                                            "dataSrc": "custom",
+                                            "data": {
+                                                "custom": "values=data.availableYears;"
+                                            },
+                                            "key": "selectYears",
+                                            "customConditional": "show = 'availableYears' in data && data.availableYears.length != 0;",
+                                            "type": "select",
+                                            "input": true
+                                        },
+                                        {
+                                            "label": "GAP table",
+                                            "customClass": "table-sm table-striped",
+                                            "hideLabel": true,
+                                            "tableView": false,
+                                            "key": "gapTable",
+                                            "type": "customdatatables",
+                                            "input": true
+                                        }
+                                    ],
+                                    "width": 6,
+                                    "offset": 0,
+                                    "push": 0,
+                                    "pull": 0,
+                                    "size": "md",
+                                    "currentWidth": 6
+                                },
+                                {
+                                    "components": [
+                                        {
+                                            "label": "Number of selected years",
+                                            "labelPosition": "left-left",
+                                            "mask": false,
+                                            "disabled": true,
+                                            "tableView": false,
+                                            "delimiter": false,
+                                            "requireDecimal": false,
+                                            "inputFormat": "plain",
+                                            "truncateMultipleSpaces": false,
+                                            "clearOnHide": false,
+                                            "calculateValue": "value = data.selectYears.length;",
+                                            "key": "numberSelectedYears",
+                                            "type": "number",
+                                            "input": true
+                                        },
+                                        {
+                                            "label": "Plot",
+                                            "aspectRatio": 1.3333333333333333,
+                                            "hideLabel": true,
+                                            "tableView": false,
+                                            "key": "plot",
+                                            "type": "customplotly",
+                                            "input": true
+                                        }
+                                    ],
+                                    "width": 6,
+                                    "offset": 0,
+                                    "push": 0,
+                                    "pull": 0,
+                                    "size": "md",
+                                    "currentWidth": 6
+                                }
+                            ],
+                            "key": "dataColumns",
+                            "type": "columns",
+                            "input": false,
+                            "tableView": false
+                        }
+                    ]
+                },
+                {
+                    "label": "Scenarios",
+                    "key": "scenariosTab",
+                    "components": [
+                        {
+                            "label": "'Calculate' Scenarios",
+                            "showValidations": false,
+                            "tableView": false,
+                            "key": "updateScenarios",
+                            "type": "button",
+                            "action": "event",
+                            "input": true,
+                            "event": "RunScenarios"
+                        },
+                        {
+                            "label": "Scenarios",
+                            "tableView": false,
+                            "rowDrafts": false,
+                            "key": "scenarios",
+                            "type": "editgrid",
+                            "displayAsTable": false,
+                            "input": true,
+                            "components": [
+                                {
+                                    "label": "Selected year",
+                                    "labelPosition": "left-left",
+                                    "placeholder": "yyyy",
+                                    "applyMaskOn": "change",
+                                    "mask": false,
+                                    "tableView": true,
+                                    "delimiter": false,
+                                    "requireDecimal": false,
+                                    "inputFormat": "plain",
+                                    "truncateMultipleSpaces": false,
+                                    "validate": {
+                                        "custom": "valid = data.availableYears.includes(input);"
+                                    },
+                                    "errors": {
+                                        "custom": "Year must be one of the years in the dataset."
+                                    },
+                                    "key": "inputYear",
+                                    "type": "number",
+                                    "input": true
+                                },
+                                {
+                                    "label": "Total population",
+                                    "labelPosition": "left-left",
+                                    "applyMaskOn": "change",
+                                    "mask": false,
+                                    "disabled": true,
+                                    "tableView": true,
+                                    "delimiter": false,
+                                    "requireDecimal": false,
+                                    "inputFormat": "plain",
+                                    "truncateMultipleSpaces": false,
+                                    "key": "totalPop",
+                                    "type": "number",
+                                    "input": true
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
+            "hideLabel": true,
+            "key": "tabs",
+            "type": "tabs",
+            "input": false,
+            "tableView": false
+        }
+    ]
+}

simian/examples/workshop_example.py

@@ -0,0 +1,219 @@
+"""Workshop Example application.
+
+Built for simian.gui 3.0.0.
+"""
+
+import logging
+import numbers
+
+import plotly.express
+from pandas import DataFrame as pandas_DataFrame
+from simian.gui import Form, component, utils
+
+# Import the GAP Minder data from the Plotly Express module.
+# The resulting GAP_DATA is a pandas.DataFrame. The columns that will be used are:
+# "year" and "continents"
+GAP_DATA = plotly.express.data.gapminder()
+GAP_DATA.insert(0, "id", GAP_DATA.index)  # 'id' is needed in DataTables, so we are adding it here.
+
+
+if __name__ == "__main__":
+    # Run as a script
+    from simian.local import run
+
+    run(
+        "simian.examples.workshop_example",
+        window_title="Workshop application",
+        debug=True,
+        show_refresh=True,
+    )
+
+
+def gui_init(_meta_data: dict) -> dict:
+    """Initializes the form.
+
+    Initialization of the form and the components therein.
+
+    Returns:
+        payload:    Form definition.
+    """
+    # Setup component initializers and create the Form from the definition in the .json file.
+    Form.componentInitializer(
+        gapTable=init_gap_table,
+        selectContinents=make_trigger_happy,
+        selectYears=make_trigger_happy,
+    )
+    form = Form(from_file=__file__)
+
+    # Put the form in the outputs.
+    payload = {
+        "form": form,
+        "navbar": {
+            "title": "Workshop Application",
+            "subtitle": "<small>Simian Demo</small>",
+        },
+        "showChanged": True,  # Flag changes to the settings in the UI.
+    }
+
+    return payload
+
+
+def init_gap_table(gap_table: component.DataTables):
+    """Initializer function for the gapTable."""
+    table_column_names = list(GAP_DATA.columns)
+
+    gap_table.setColumns(
+        titles=[i_name.capitalize() for i_name in table_column_names],
+        keys=table_column_names,
+        className=["noneditable"] * len(table_column_names),
+        visible=[False] + [True] * (len(table_column_names) - 1),
+    )
+
+
+def make_trigger_happy(comp):
+    """Initializer to make input components triggerHappy."""
+    comp.properties["triggerHappy"] = "FilterChange"
+
+
+def gui_event(meta_data: dict, payload: dict) -> dict:
+    """Event handling of the application.
+
+    Args:
+        meta_data:      Form meta data.
+        payload:        Current status of the Form's contents.
+
+    Returns:
+        payload:        Updated Form contents.
+    """
+    # Register the events with their functions.
+    Form.eventHandler(
+        LoadData=load_data,
+        RunScenarios=update_scenarios,
+        FilterChange=filter_changed,
+    )
+    try:
+        caller = utils.getEventFunction(meta_data, payload)
+        payload = caller(meta_data, payload)
+
+    except ImportError as exc:
+        # No method with matching name found in the current namespace. May be used to have
+        # custom event routing. Here we only log the occurrence.
+        logging.exception(exc)
+
+    # Lower the "Form has changes" flag.
+    payload["pristine"] = True
+
+    return payload
+
+
+def filter_changed(meta_data: dict, payload: dict) -> dict:
+    """Continent or Year selection change callback."""
+    # Continent or year selection changed. Update the table and plot.
+    update_table_and_plot(payload)
+
+    # Trigger a recalculate of the scenarios.
+    update_scenarios(meta_data, payload)
+
+    return payload
+
+
+def filter_data(selected_continents: list, selected_years: list) -> pandas_DataFrame:
+    """Filter GAP data based on selected continents and years."""
+    if isinstance(selected_continents, str):
+        # Selected continent is a string. Put in a list for use in the filtering.
+        selected_continents = [selected_continents]
+
+    if isinstance(selected_years, numbers.Number):
+        # Selected year is a number. Put in a list for use in the filtering.
+        selected_years = [selected_years]
+
+    # Filter the GAP data.
+    new_gap = GAP_DATA[
+        GAP_DATA["continent"].isin(selected_continents) & GAP_DATA["year"].isin(selected_years)
+    ]
+
+    return new_gap
+
+
+def load_data(_meta_data: dict, payload: dict) -> dict:
+    """Put the Gap Minder data in the table."""
+    utils.setSubmissionData(payload, "gapTable", GAP_DATA)
+
+    # Put the available continents in the Select component.
+    gap_continents = sorted(set(GAP_DATA["continent"]))
+    utils.setSubmissionData(payload, "selectContinents", gap_continents)
+    utils.setSubmissionData(payload, "availableContinents", gap_continents)
+
+    # Put the available years in the Select component and select the last year.
+    gap_years = sorted(set(GAP_DATA["year"]))
+    utils.setSubmissionData(payload, "selectYears", [gap_years[-1]])
+    utils.setSubmissionData(payload, "availableYears", gap_years)
+
+    # Plot the loaded data.
+    update_table_and_plot(payload)
+
+    return payload
+
+
+def update_scenarios(_meta_data: dict, payload: dict) -> dict:
+    """Update the scenario results in the scenario list."""
+    scenario_list, _ = utils.getSubmissionData(payload, key="scenarios")
+
+    for scenario_row in scenario_list:
+        # Loop over the scenario rows.
+        selected_year = scenario_row["inputYear"]
+
+        # Get the selected continents and filter the GAP data for the scenario year.
+        selected_continents, _ = utils.getSubmissionData(payload, "selectContinents")
+        filtered_gap_data = filter_data(selected_continents, selected_year)
+
+        # Calculate the Total population of all nations in the selection.
+        scenario_row["totalPop"] = float(filtered_gap_data["pop"].sum())
+
+    utils.setSubmissionData(payload, "scenarios", scenario_list)
+
+    return payload
+
+
+def update_table_and_plot(payload: dict) -> None:
+    """Put the GAP data in the table and plot."""
+    selected_year, _ = utils.getSubmissionData(payload, "selectYears")
+
+    # Get the selected continents and filter the GAP data for the selected years.
+    selected_continents, _ = utils.getSubmissionData(payload, "selectContinents")
+    filtered_gap_data = filter_data(selected_continents, selected_year)
+
+    # Fill table with GAP data.
+    utils.setSubmissionData(payload, "gapTable", filtered_gap_data)
+
+    update_plot(payload, filtered_gap_data=filtered_gap_data)
+
+
+def update_plot(payload: dict, filtered_gap_data: pandas_DataFrame = GAP_DATA) -> None:
+    """Update the plot with a 'filtered' set of data."""
+    # Recreate the Plotly object.
+    plot_obj = utils.getSubmissionData(payload, key="plot")[0]
+
+    # Plot the new newly calculated x and y values, append the legend and put the plotly
+    # object in the submission data.
+    if len(filtered_gap_data) == 0:
+        # No data. Empty the plot.
+        plot_obj.figure = None
+
+    else:
+        # Fill the plot with data.
+        # https://plotly.com/python/line-and-scatter/
+        plot_obj.figure = plotly.express.scatter(
+            filtered_gap_data,
+            x="gdpPercap",
+            log_x=True,
+            y="lifeExp",
+            symbol="year",
+            size="pop",
+            size_max=60,
+            color="continent",
+            hover_name="country",
+        )
+
+    # Put the new plot contents in the payload.
+    utils.setSubmissionData(payload, "plot", plot_obj)

simian/examples/wrapped_thrower.py

@@ -0,0 +1,233 @@
+"""Simian Wrapped Ball Thrower app.
+
+Built for simian.gui 3.1.0.
+"""
+
+import math
+
+import numpy as np
+import simian.examples.ballthrower as throw_gui
+import simian.gui
+from simian.examples.ballthrower import (
+    COLLAPSE_PANEL,
+    LABEL_LEFT,
+    causeError,
+    clearHistory,
+    gui_event,
+)
+from simian.gui import component, utils
+
+try:
+    from monkeyproof.modelwrapper.mwapp.application import Application
+except ImportError as exc:
+    raise RuntimeError("Simian wrapper could not be found. Is it installed?") from exc
+
+
+if __name__ == "__main__":
+    # Run as a script
+    from simian.entrypoint import assert_simian_gui_imports
+
+    assert_simian_gui_imports()
+    from simian.local import run
+
+    run("simian.examples.wrapped_thrower", window_title="Wrapped Ball Thrower", debug=False)
+
+
+def gui_init(meta_data) -> dict:
+    """Initializes the form.
+
+    Initialization of the form and the components therein.
+
+    Returns:
+        payload:    Form definition.
+    """
+    app = Application("examples.thrower.ballthrower_model.ThrowerModel")
+    app.populate(
+        userData={
+            "Resources_XLS": {
+                "SelectedBall": {"value": "None"},
+                "SpeedHorizontal": {"value": 10 / math.sqrt(2)},
+                "SpeedVertical": {"value": 10 / math.sqrt(2)},
+            }
+        }
+    )
+    utils.setCache(meta_data, "app", app)
+
+    # Get the list of balls from the wrapped model.
+    balls_list = app.model.dataStore.resources.getValue("DefinedBalls")
+
+    # Create a form and add a label.
+    form_obj = simian.gui.Form("form")
+
+    # Create tabs in the form.
+    tabs = component.Tabs(key="tabs", parent=form_obj)
+    tab_inputs, tab_settings = tabs.setContent(labels=["Inputs", "Used settings"])
+
+    # Create a Columns object and fill it with two empty columns.
+    col = component.Columns(key="inputColumns", parent=tab_inputs)
+    left_column, right_column = col.setContent(components=[], widths=[6, 6])
+
+    # Add Throw speed and angle controls.
+    created_components = throw_gui.add_throw_speed_controls(left_column)
+
+    # Put a Ball selector component in the throw options panel
+    ball_selector = component.Select("ballSelector", created_components["throwPanel"])
+    ball_selector.label = "Selected Ball"
+    ball_selector.tooltip = "Ball to throw."
+    ball_selector.setRequired()
+    ball_selector.labelPosition = "left-left"
+
+    # Fill the Balls selector with the list of balls from the wrapped model.
+    ball_selector.setValues(balls_list["Name"], balls_list.to_dict("records"))
+
+    # Add the options panels and controls.
+    left_dis_opts = {"disabled": True, **LABEL_LEFT}
+
+    def ball_prop(name: str) -> dict:
+        return {
+            "calculateValue": f"""
+            if (data.ballSelector) {{
+                value=data.ballSelector['{name}']
+            }} else {{
+                value = 0
+            }}""",
+            **left_dis_opts,
+        }
+
+    ball_mass_opts = ball_prop("Weight [kg]")
+    ball_radius_opts = ball_prop("Diameter [m]")
+    ball_drag_opts = ball_prop("Drag Coefficient [-]")
+
+    utils.addComponentsFromTable(
+        parent=left_column,
+        build_table=[
+            # key               class       level   options             default label                               tooltip
+            ["ballPanel",       "Panel",    1,      COLLAPSE_PANEL,     None,   "Ball settings",                    None],
+            ["ballMass",        "Number",   2,      ball_mass_opts,     0,      "Mass [kg]:",                       "Mass of the ball."],
+            ["ballRadius",      "Number",   2,      ball_radius_opts,   0,      "Radius [m]:",                      "Radius of the ball."],
+            ["dragCoefficient", "Number",   2,      ball_drag_opts,     0,      "Drag coefficient [-]:",            "Drag coefficient of the ball."],
+            ["constantsPanel",  "Panel",    1,      COLLAPSE_PANEL,     None,   "Constants",                        None],
+            ["gravity",         "Number",   2,      left_dis_opts,      9.81,   "Gravity [m/s<sup>2</sup>]:",       "Gravitational accelleration acting on the ball."],
+            ["airDensity",      "Number",   2,      left_dis_opts,      1.29,   "Air density [kg/m<sup>3</sup>]:",  "Density of the air through which the ball moves."]  # fmt: skip
+        ],
+    )
+
+    # Show Scenario information.
+    scenario_grid = component.HtmlTable(
+        "scenario_info", left_column, column_names=["Scenario Name", "Wind speed"]
+    )
+    scenario_grid.setDefaultValue(
+        [[i_scen.name, i_scen.getValue("Wind")[0][0]] for i_scen in app.model.dataStore.scenarios]
+    )
+
+    # Fill the right column.
+    throw_gui.fill_right_column(right_column)
+
+    # Fill the Settings tab.
+    _fill_settings_tab(tab_settings)
+
+    # Put the form in the outputs.
+    payload = {
+        "form": form_obj,
+        "navbar": {
+            "title": "Wrapped Ball Thrower",
+            "subtitle": "<small>Simian demo</small>",
+        },
+        "showChanged": True,  # Flag changes to the settings in the UI.
+    }
+
+    return payload
+
+
+def throwing(meta_data: dict, payload: dict) -> dict:
+    """Simulate throwing a ball.
+
+    Get the settings from the payload.
+    """
+    throw_speed, _ = utils.getSubmissionData(payload, key="throwSpeed")
+    throw_angle, _ = utils.getSubmissionData(payload, key="throwAngle")
+    selected_ball, _ = utils.getSubmissionData(payload, key="ballSelector")
+
+    # Convert the speed and angle to the speed components.
+    ver_speed = throw_speed * math.sin(throw_angle / 180 * math.pi)
+    hor_speed = throw_speed * math.cos(throw_angle / 180 * math.pi)
+
+    app, _ = utils.getCache(meta_data, "app")
+
+    resources = app.model.dataStore.resources
+    resources.setValue("SelectedBall", selected_ball["Name"], overload=True)
+    resources.setValue("SpeedHorizontal", hor_speed, overload=True)
+    resources.setValue("SpeedVertical", ver_speed, overload=True)
+    app.model.run()
+
+    trajectories = app.model.dataStore.custom["trajectories"]
+
+    # Create a Plotly object from the information in the payload.
+    plot_obj, _ = utils.getSubmissionData(payload, key="plot")
+
+    # Plot the new newly calculated x and y values, append the legend and put the plotly
+    # object in the submission data.
+    nr = int(len(plot_obj.figure.data) / 4 + 1)
+
+    for i_scen, i_res in trajectories.items():
+        plot_obj.figure.add_scatter(
+            x=i_res["x"], y=i_res["y"], name=f"Attempt {nr} - {i_scen}", mode="lines"
+        )
+    utils.setSubmissionData(payload, key="plot", data=plot_obj)
+
+    # Get the maximum thrown distances.
+    distances = [d[-1] for d in app.model.dataStore.results.getValue("Distance")[1:]]
+
+    # Update the table with the settings used for the throws.
+    new_row = [
+        nr,
+        nr,
+        round(hor_speed, 3),
+        round(ver_speed, 3),
+        selected_ball["Weight [kg]"],
+        selected_ball["Diameter [m]"] / 2,
+        selected_ball["Drag Coefficient [-]"],
+        round(min(distances), 3),
+        round(max(distances), 3),
+        round(np.mean(distances), 3),
+        round(max(distances) - min(distances), 3),
+    ]
+
+    if nr == 1:
+        # First throw. Only put the new row in the table.
+        new_table_values = [new_row]
+    else:
+        # Extra row. Append the row to the DataFrame from the submission data.
+        new_table_values, _ = utils.getSubmissionData(payload, key="summary")
+        new_table_values.append(dict(zip(new_table_values[0].keys(), new_row)))
+
+    utils.setSubmissionData(payload, key="summary", data=new_table_values)
+
+    return payload
+
+
+def _fill_settings_tab(tab_settings):
+    """Fill Settings tab."""
+    # Create a table to store the throw settings in.
+    table_out = component.DataTables(key="summary", parent=tab_settings)
+    table_out.setColumns(
+        *[
+            list(x)
+            for x in zip(
+                ["Id", "id"],
+                ["Attempt", "attempt"],
+                ["Horizontal speed", "hor_speed"],
+                ["Vertical speed", "ver_speed"],
+                ["Ball mass", "ball_mass"],
+                ["Radius", "radius"],
+                ["Drag Coeff.", "drag"],
+                ["Min. distance", "min_dist"],
+                ["Max. distance", "max_dist"],
+                ["Mean distance", "mean_dist"],
+                ["Spread distance", "spread_dist"],
+            )
+        ],
+        visible=[False] + [True] * 10,
+    )
+    table_out.label = "Used settings per throw"
+    table_out.setFeatures(searching=False, ordering=False, paging=False)

simian_examples-3.3.0.dist-info/METADATA

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: simian-examples
+Version: 3.3.0
+Summary: Simian Examples for Python
+Author-email: "MonkeyProof Solutions B.V." <info@simiansuite.com>
+License-Expression: MIT
+Project-URL: homepage, https://simiansuite.com
+Project-URL: documentation, https://doc.simiansuite.com/simian-gui/index.html
+Project-URL: releasenotes, https://doc.simiansuite.com/simian-gui/release_notes.html
+Project-URL: issues, https://github.com/Simian-Web-Apps/Issue-Tracker
+Project-URL: github, https://github.com/Simian-Web-Apps
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: Unix
+Requires-Python: >=3.10
+Requires-Dist: simian-gui==3.3.0
+Requires-Dist: scipy
+Provides-Extra: local
+Requires-Dist: simian-local==3.3.0; extra == "local"
+Dynamic: provides-extra
+Dynamic: requires-dist