def Classification_Options(options): """ Generate the layout of the dashboard. Args: options (list(dict)): Available datasets as options for `dcc.Dropdown`. Returns: A Dash element or list of elements. """ return html.Div(children=[ # Choose a dataset html.Div(create_dropdown("Available datasets", options, multi=False, id="dataset_choice_classification"), className="horizontal_dropdowns"), # Choose an algorithm html.Div(create_dropdown("Choose algorithm type", options=[ {'label': 'Logistic Regression', 'value': 'logr'}, {'label': 'XGBoost', 'value': 'xgb'}, ], multi=False, id="algo_choice_classification"), className="horizontal_dropdowns"), ## Two empty divs to be filled by callbacks # Available choices for fitting html.Div(id="variable_choices_classification"), # The results html.Div(id="training_results_classification"), dcc.Graph(id="classification_results") ])
def inspect_node(selected, user_id, elems): if selected is None or "parent" not in selected: # No need to show info for parent nodes as # they are there just for show raise PreventUpdate() # Defaults multi = False dataset_choice = None if len(selected): func = node_options[selected["node_type"]]["func"] arguments = list(func.modifiable_params.keys()) # func is a SKLEARN-like class if isinstance(func(), pipeline_classes.GenericInput): arguments = ["dataset"] options = [{"label": arg, "value": arg} for arg in arguments] if isinstance(func(), pipeline_classes.FeatureMaker): # 1) Select appropriate elements and make the graph # 2) Create pipelines # 3) Iterate over them to find the one with FeatureMaker node # 4) Iterate over that again to find its input node input_node = pipeline_creator.find_input_node(elems) try: dataset_choice = input_node.dataset except AttributeError: return [ html.H4("Something went wrong with the input"), # for debugging a global callback *create_dropdown("", [], id="modify_option_dropdown", style={"display": "none"}), *debugger_layout, ] df = get_data(dataset_choice, user_id) # Truncate labels so they don't fill the whole dropdown options = [{'label': col[:35], 'value': col} for col in df.columns] multi = True return [ html.Div([ *create_dropdown( "Options", options, id="modify_option_dropdown", multi=multi), html.Div([], id="other_menus"), # here only to debug the modify_graph callback *debugger_layout, ]), ]
def Pipeline_Options(options, user_id): """ Generate the layout of the dashboard. Args: options (list(dict)): Available datasets as options for `dcc.Dropdown`. Returns: A Dash element or list of elements. """ if user_id.startswith("python_generated_ssid"): # Trim id user_id = user_id.split("-")[-1] available_pipelines = { k.decode(): r.get(k) for k in r.keys(f'{user_id}_pipeline_*') } return html.Div(children=[ # Dataset is defined in the ModelBuilder # Choose an algorithm html.Div(create_dropdown("Choose algorithm type", options=[{ 'label': f'Pipeline --> {pipe_name}', 'value': pipe_name } for pipe_name in available_pipelines], multi=False, id="algo_choice_pipeline"), className="horizontal_dropdowns"), # Available choices for fitting html.Div( id="variable_choices_pipeline", children=[ # Debuggers html.Button("Fit model", id="fit_model", n_clicks=0, style={"display": "none"}), html.Div( create_dropdown("", [], multi=True, id="xvars_pipeline", style={"display": "none"})), html.Div( create_dropdown("", [], multi=True, id="yvars_pipeline", style={"display": "none"})), ]), # The results html.Div(id="training_results_pipeline"), ])
def render_choices(problem_type, dataset_choice): """ Create a menu for fitting options, depending of the problem type. It \ returns dropdowns with algorithm choices. Args: problem_type (str): One of: regression, classification, clustering. dataset_choice (str): Name of the dataset. Returns: A Dash element or list of elements. """ if problem_type is None or dataset_choice is None: raise PreventUpdate() # Load the schema for the dataset df_schema = get_data_schema(dataset_choice, redis_conn)["types"] # From the schema take the dataset's column names var_options = [ {"label": col, "value": col} for col in df_schema.keys() ] disabled_y = False algo_options = None # Depending on the problem type, show the available algorithms if problem_type in ["regression", "classification", "clustering"]: disabled_y = False algo_options = [ {'label': estimator["label"], 'value': estimator["node_type"]} for estimator in all_classes if (estimator["parent"] == "models" and estimator["problem"] == problem_type) ] if problem_type == "clustering": disabled_y = True return html.Div([ html.Div(create_dropdown("Choose algorithm type", options=algo_options, multi=False, id="algo_choice")), html.Div(create_dropdown("Choose variable(s) X", options=var_options, multi=True, id="xvars")), html.Div(create_dropdown("Choose target variable Y", options=var_options, multi=False, id="yvars", disabled=disabled_y)), ])
def Exploration3D_Options(options): """ Generate the layout of the dashboard. Args: options (list(dict)): Available datasets as options for `dcc.Dropdown`. Returns: A Dash element or list of elements. """ return html.Div( children=[ html.Div( [ # Choose a dataset html.Div(create_dropdown("Available datasets", options, multi=False, id="dataset_choice_3d"), className="vertical_dropdowns"), # Available buttons and choices for plotting html.Div(id="variable_choices_3d", children=[ html.Div(create_dropdown(f"{dim} variable", options=[], multi=False, id=f"{dim}vars_3d"), className="vertical_dropdowns") for dim in ["x", "y", "z"] ]), # Export graph config html.Div([ html.Br(), html.Button("Export graph config 1", id="export_graph1"), html.Button("Export graph config 2", id="export_graph2"), ], className="vertical_dropdowns"), ], className="col-sm-4"), # The graph itself html.Div([ dcc.Graph(id="graph_3d"), ], className="col-sm-8"), ], className="row")
def Exploration_Options(options): """ Generate the layout of the dashboard. Args: options (list(dict)): Available datasets as options for `dcc.Dropdown`. Returns: A Dash element or list of elements. """ return html.Div(children=[ # Choose a dataset html.Div(create_dropdown( "Available datasets", options, multi=False, id="dataset_choice_2d"), className="horizontal_dropdowns"), # Holds the name AND opens a modal for graph selection html.Button( "Choose a graph...", id="graph_choice_exploration", n_clicks=0), # modal with buttons for graphs html.Div([ dbc.Modal([ dbc.ModalHeader("Choose a graph type"), dbc.ModalBody(["2D graphs: ", html.Div(buttons)]), dbc.ModalFooter( dbc.Button( "Close", id="close_choose_graph", className="ml-auto")) ], id="modal_choose_graph") ]), # Available buttons and choices for plotting html.Div(id="variable_choices_2d", children=[ html.Div(create_dropdown( "X variable", options=[], multi=False, id="xvars_2d"), className="horizontal_dropdowns"), html.Div(create_dropdown( "Y variable", options=[], multi=False, id="yvars_2d"), className="horizontal_dropdowns"), ]), # The graph itself dcc.Graph(id="graph_2d"), ])
def Clustering_Options(options): """ Generate the layout of the dashboard. Args: options (list(dict)): Available datasets as options for `dcc.Dropdown`. Returns: A Dash element or list of elements. """ return html.Div(children=[ # Choose a dataset html.Div(create_dropdown("Available datasets", options, multi=False, id="dataset_choice_clustering"), className="horizontal_dropdowns"), # Choose an algorithm html.Div(create_dropdown("Choose algorithm type", options=[ { 'label': 'DBSCAN', 'value': 'dbscan' }, { 'label': 'K-Means Clustering', 'value': 'kmc' }, ], multi=False, id="algo_choice_clustering"), className="horizontal_dropdowns"), ## Two empty divs to be filled by callbacks # Available choices for fitting html.Div(id="variable_choices_clustering"), #Available number of clusters html.P("Number of clusters:"), daq.NumericInput(id='clusters_input', min=0, value=3, max=10), # The results html.Div(id="training_results_clustering"), # The graph dcc.Graph(id="clustering_results"), ])
def single_model_options(options): """ Generate the layout of the dashboard. Args: options (list(dict)): Available datasets as options for `dcc.Dropdown`. Returns: A Dash element or list of elements. """ return [ # The main content html.Div(children=[ # Choose type of metric to display dcc.Tabs(id="results_tabs", value='metrics', children=[ dcc.Tab(label='Metrics', value='metrics'), dcc.Tab(label='Visualizations', value='visualizations'), ]), # Hidden divs for the intermediate results html.Div(id="hidden_results_metrics", style={"display": "none"}), html.Div(id="hidden_results_visualizations", style={"display": "none"}), # The fitting results (target of the tab menu) html.Div(id="fitting_report") ], id="training_results_div"), # The tab menu html.Div([ # Choose a dataset html.Div(create_dropdown("Available datasets", options, multi=False, id="dataset_choice")), # Choose problem learning type html.Div(create_dropdown("Choose problem learning type", options=[ {'label': 'Regression', 'value': 'regression'}, {'label': 'Classification', 'value': 'classification'}, {'label': 'Clustering', 'value': 'clustering'}, ], multi=False, id="problem_type")), html.Div(id="variable_choices"), ], id="single_model_menu"), ]
def _render_variable_choices(dataset_choice, algo_choice, user_id, tab=tab): """ Create a menu of dcc components for the user to choose fitting options. \ This function is similar for all menus in the analyze tab, and only needs \ the `app.callback` applied to it Args: dataset_choice (str): Name of dataset. algo_choice (str): The choice of algorithm type. user_id (str): Session/user id. tab (str): The tab you're currently on. Must be the same as the one \ the other callbacks are listening to. Returns: list: Dash elements. """ df = get_data(dataset_choice, user_id) # Make sure all variables have a value before returning choices if any(x is None for x in [df, dataset_choice, algo_choice]): return [html.H4("Select dataset and algorithm first.")] # Truncate labels so they don't fill the whole dropdown options = [{'label': col[:35], 'value': col} for col in df.columns] layout = [ html.Div(create_dropdown("X variable(s)", options, multi=True, id=f"xvars_{tab}"), className="horizontal_dropdowns"), html.Div(create_dropdown("Y variable", options, multi=False, id=f"yvars_{tab}"), className="horizontal_dropdowns"), ] return layout
def Regression_Options(options): """ Generate the layout of the dashboard. Args: options (list(dict)): Available datasets as options for `dcc.Dropdown`. Returns: A Dash element or list of elements. """ return html.Div(children=[ # Choose a dataset html.Div(create_dropdown("Available datasets", options, multi=False, id="dataset_choice_regression"), className="horizontal_dropdowns"), # Choose an algorithm html.Div(create_dropdown("Choose algorithm type", options=[{ 'label': 'Linear Regression', 'value': 'linr' }, { 'label': 'SVM Regression', 'value': 'svr' }, { 'label': 'Decision Tree Regression', 'value': 'dtr' }], multi=False, id="algo_choice_regression"), className="horizontal_dropdowns"), ## Two empty divs to be filled by callbacks # Available choices for fitting html.Div(id="variable_choices_regression"), # The results html.Div(id="training_results_regression"), ])
def KPI_Options(options): """ Generate the layout of the dashboard. Args: options (list(dict)): Available datasets as options for `dcc.Dropdown`. Returns: A Dash element or list of elements. """ return html.Div(children=[ html.Div(create_dropdown("Available datasets", options, multi=False, id="dataset_choice_kpi"), className="horizontal_dropdowns"), # TODO: use this for kpi/graph selection ? html.Div(create_dropdown("Choose graph type", options, multi=False, id="graph_choice_kpi", disabled=True), className="horizontal_dropdowns"), html.Div( id="variable_choices_kpi", children=[ html.Div(create_dropdown( "X variables", options=[], multi=False, id="xvars_kpi"), className="horizontal_dropdowns"), html.Div(create_dropdown( "Y variable", options=[], multi=True, id="yvars_kpi"), className="horizontal_dropdowns"), html.Div(create_dropdown("Bar Chart variable", options=[], multi=False, id="secondary_yvars_kpi"), className="horizontal_dropdowns"), ]), dcc.Graph(id="graph_kpi"), ])
def KPI_Options(options): """ Generate the layout of the dashboard. Args: options (list(dict)): Available datasets as options for `dcc.Dropdown`. Returns: A Dash element or list of elements. """ return [ # The main content html.Div(dcc.Graph(id="graph_kpi"), className="main-content-graph"), # The tab menu html.Div([ # Choose a dataset html.Div(create_dropdown("Available datasets", options, multi=False, id="dataset_choice_kpi")), # TODO: use this for kpi/graph selection ? html.Div(create_dropdown("Choose graph type", options, multi=False, id="graph_choice_kpi", disabled=True)), # Available buttons and choices for plotting html.Div(id="variable_choices_kpi", children=[ html.Div(create_dropdown("X variables", options=[], multi=False, id="xvars_kpi")), html.Div(create_dropdown("Y variable", options=[], multi=True, id="yvars_kpi")), html.Div(create_dropdown("Bar Chart variable", options=[], multi=False, id="secondary_yvars_kpi")), ]) ], id="kpi_menu"), ]
def Exploration_Options(options): """ Generate the layout of the dashboard. Args: options (list(dict)): Available datasets as options for `dcc.Dropdown`. Returns: Two divs with Dash elements or lists of elements. """ modals, divs = list( zip(*[make_trace_menu(x) for x in range(1, max_traces + 1)])) return [ # The main content html.Div(dcc.Graph(id="graph"), className="main-content-graph"), # The tab menu html.Div([ html.Div( [ html.Button("Add trace", id="add_trace", n_clicks=0), html.Button("Remove trace", id="remove_trace", n_clicks=0), html.Br(), html.Br(), dcc.Input(id="export_graph_name", placeholder="Graph name..."), html.Button( "Export graph as...", id="export_graph", n_clicks=0), html.Div(id="export_throwaway_div", style={"display": "none"}), html.Div(modals, id="modals"), # Choose a dataset html.Div( create_dropdown("Available datasets", options, multi=False, id="dataset_choice")), # The variable choices html.Div([*divs], id="traces", className="traces-list"), html.Div(id="traces_maker"), # This is here to count the children html.Div(0, id="hidden_div", style={"display": "none"}), ], id="chartmaker_menu") ]) ]
def make_trace_menu(n): """ Helper function to create modals and trace menus. Args: n (int): The number/id of trace menu. Notes: Each trace needs a modal with buttons, a menu for choices, \ and a callback to update the graph (probably with a "plot" button). """ buttons = [] for graph_type, (label, *_) in graph2d_configs.items(): buttons.append(create_button(graph_type, label, n)) # modal with buttons for graphs modal = html.Div([ dbc.Modal([ dbc.ModalHeader("Choose a graph type"), dbc.ModalBody(["2D graphs: ", html.Div(buttons)]), dbc.ModalFooter( dbc.Button("Close", id=f"close_choose_graph_{n}", className="ml-auto")) ], id=f"modal_choose_graph_{n}") ]) # Traces menus div = html.Div( [ # Menu header html.Div([ html.P(f"trace {n}", className="trace-title-text"), ], className="trace-title"), # Available buttons and choices for plotting # Holds the name AND opens a modal for graph selection html.Div([ html.Div("Type", className="trace-variable-name"), html.Button("Scatterplot", value="scatterplot", id=f"graph_choice_{n}", n_clicks=0, className="plot-menu-input-button"), ], className="trace-menu-row"), # Available variable choices html.Div(create_dropdown( "X", options=[], type_="trace", multi=False, id=f"xvars_{n}"), className="plot-menu-input-div"), html.Div(create_dropdown( "Y", options=[], type_="trace", multi=False, id=f"yvars_{n}"), className="plot-menu-input-div"), # Z-vars are not always needed, so keep them disabled and hidden html.Div(create_dropdown("Z", options=[], disabled=True, type_="trace", multi=False, id=f"zvars_{n}"), className="plot-menu-input-div", style={"display": "none"}, id=f"z_vars_div_{n}"), ], style={"display": "none"}, id=f"trace_{n}", className="trace-container") return modal, div
def render_variable_choices_pipeline(pipeline_choice): """ Create a menu of dcc components to select pipeline and variables. Args: algo_choice_pipeline (str): Choice among (pre)defined pipelines. Returns: list: Dash elements. """ user_id = current_user.username # Make sure all variables have a value before returning choices if pipeline_choice is None: return [html.H4("Select a pipeline first.")] pipeline = dill.loads(redis_conn.get(pipeline_choice)) # Reminder: pipelines are named after their graphs following # these conventions: # Pipeline: userid_pipeline_userProvidedName_lastNodeID # Graph: userid_graph_userProvidedName # Get the graph for the model name = pipeline_choice.split("_")[2] model = dill.loads(redis_conn.get(f"{user_id}_graph_{name}")) # For each input node columns = [] for input_node in model.input_nodes: dataset = input_node.params["dataset"] # Append the input_node.id to the keys in case of columns # with the same name. cols = list( f"{key}_{input_node.id}" for key in get_data_schema(dataset, redis_conn)["types"].keys()) columns.extend(cols) var_options = [{"label": col, "value": col} for col in columns] # e.g.: linr_001 output_node_id = "_".join(pipeline_choice.split("_")[-2:]) output_node = model.graph.node_collection[output_node_id] # Depending on the problem type, dis/allow for a Y variable if any( isinstance(output_node.model_class(), base) for base in [ClassifierMixin, RegressorMixin]): # Supervised disabled_y = False else: # Unsupervised disabled_y = True return html.Div([ html.Div( create_dropdown("Choose variable(s) X", options=var_options, multi=True, id="xvars_pipeline")), html.Div( create_dropdown("Choose target variable Y", options=var_options, multi=False, id="yvars_pipeline", disabled=disabled_y)), html.Div([ html.H6("Export trained model..."), html.Button("Export!", id="export_model_button"), ]) ])
def Network_Options(options): """ Generate the layout of the dashboard. Args: options (list(dict)): Available datasets as options for `dcc.Dropdown`. Returns: A Dash element or list of elements. """ return html.Div( children=[ html.Div( [ # Choose a dataset html.Div(create_dropdown("Available datasets", options, multi=False, id="dataset_choice_network"), className="vertical_dropdowns"), # Available buttons and choices for plotting html.Div(create_dropdown( "In-node", options=[], multi=False, id="in_node"), className="vertical_dropdowns"), html.Div(create_dropdown( "Out-node", options=[], multi=False, id="out_node"), className="vertical_dropdowns"), html.Div(create_dropdown( "Layout", id='dropdown-callbacks-1', value='grid', multi=False, clearable=False, options=[ { 'label': name, 'value': name } for name in ['grid', 'random', 'circle', 'concentric', 'cose'] ]), className="vertical_dropdowns") ], className="col-sm-3"), # The graph itself html.Div([ cyto.Cytoscape(id='cytoscape_network_graph', layout={'name': 'preset'}, style={ 'width': '100%', 'height': '700px' }, elements=[{ 'data': { 'id': 'one', 'label': 'Example Node 1' }, 'position': { 'x': 75, 'y': 75 } }, { 'data': { 'id': 'two', 'label': 'Example Node 2' }, 'position': { 'x': 200, 'y': 200 } }, { 'data': { 'source': 'one', 'target': 'two' } }]), ], className="col-sm-9"), ], className="row")
def Map_Options(options): """ Generate the layout of the dashboard. Args: options (list(dict)): Available datasets as options for `dcc.Dropdown`. Returns: A Dash element or list of elements. """ return html.Div(children=[ html.Div([ # Choose a dataset html.Div(create_dropdown("Available datasets", options, multi=False, id="dataset_choice_maps"), className="vertical_dropdowns"), # Choose a map type html.Div(create_dropdown("Map type", [ {"label": "Choropleth", "value": "agg_choropleth"}, {"label": "Simple geoscatter", "value": "geoscatter"}, {"label": "Lines on map", "value": "maplines"}, ], multi=False, id="map_type_choice"), className="vertical_dropdowns"), # Available buttons and choices for plotting html.Div(create_dropdown("Colorscale", options=[ {"label": v, "value": v} for v in colorscale_list ], multi=False, id="colorscale", value="Jet"), className="vertical_dropdowns"), html.Div(create_dropdown("Latitude", options=[], multi=False, id="lat_var"), className="vertical_dropdowns"), html.Div(create_dropdown("Longitude", options=[], multi=False, id="lon_var"), className="vertical_dropdowns"), html.Div(create_dropdown("Country", options=[], multi=False, id="country"), className="vertical_dropdowns"), html.Div(create_dropdown("Z variable", options=[], multi=False, id="z_var"), className="vertical_dropdowns"), html.Div(create_dropdown("Choose aggregation type", options=[ {"label": "Sum", "value": "sum"}, {"label": "Average", "value": "mean"}, {"label": "Count", "value": "count"}, {"label": "Max", "value": "max"}, {"label": "Min", "value": "min"}, ], multi=False, id="aggregator_field", value="count"), className="vertical_dropdowns"), html.Div(create_dropdown("Destination latitude", options=[], multi=False, id="dest_lat"), className="vertical_dropdowns"), html.Div(create_dropdown("Destination longitude", options=[], multi=False, id="dest_long"), className="vertical_dropdowns"), html.Div(create_dropdown("Map projection style", options=[ {"label": "Equirectangular", "value": "equirectangular"}, {"label": "Azimuthal equal area", "value": "azimuthal equal area"}, {"label": "Orthographic", "value": "orthographic"}, ], multi=False, id="projection_type"), className="vertical_dropdowns"), ], className="col-sm-3"), # The graph itself html.Div([ dcc.Graph(id="map_graph", style={"minHeight": "650px"}) ], className="col-sm-9"), ], className="row")
def Pipeline_Options(options): """ Generate the layout of the dashboard. Args: options (list(dict)): Available datasets as options for `dcc.Dropdown`. Returns: A Dash element or list of elements. """ user_id = current_user.username available_pipelines = { k.decode(): redis_conn.get(k) for k in redis_conn.keys(f'{user_id}_pipeline_*') } return [ # The right side with the results html.Div( [ # Choose type of metric to display dcc.Tabs(id="results_tabs_pipeline", value='metrics', children=[ dcc.Tab(label='Metrics', value='metrics'), dcc.Tab(label='Visualizations', value='visualizations'), ]), # Hidden divs for the intermediate results html.Div(id="hidden_results_metrics_pipeline", style={"display": "none"}), html.Div(id="hidden_results_visualizations_pipeline", style={"display": "none"}), # A modal for exporting the model dbc.Modal([ dbc.ModalHeader("Trained model export report."), dbc.ModalBody(id="modal_body") ], id=f"export_model_modal", is_open=False), # The fitting results (target of the tab menu) html.Div(id="fitting_report_pipeline") ], id="training_results_div"), # The tab menu html.Div( [ # Choose a dataset html.Div( create_dropdown("Available pipelines", options=[{ 'label': f'Pipeline --> {pipe_name}', 'value': pipe_name } for pipe_name in available_pipelines], multi=False, id="pipeline_choice")), html.Div(id="variable_choices_pipeline"), ], id="pipelines_menu"), ]
dbc.ModalBody( children=[ # Stuff inside the modal html.Div( id='sidebar_collapsible_button_modify_node', children=[ html.Div( id="inspector", children=[ html.Div( [ *create_dropdown( "Options", [{ "label": "No node selected", "value": "none" }], id="modify_option_dropdown" ), dcc.RadioItems( options=[{ "label": "No node selected", "value": "none" }], id="modify_node_params", labelStyle={ 'display': 'inline-block', 'margin': '5px' })
def Map_Options(options): """ Generate the layout of the dashboard. Args: options (list(dict)): Available datasets as options for `dcc.Dropdown`. Returns: A Dash element or list of elements. """ return [ # The main content html.Div(dcc.Graph(id="map_graph"), className="main-content-graph"), html.Div([ # Choose a dataset html.Div(create_dropdown("Available datasets", options, multi=False, id="dataset_choice_maps")), # The tab menu html.Div(create_dropdown("Map type", [ {"label": "Choropleth", "value": "agg_choropleth"}, {"label": "Simple geoscatter", "value": "geoscatter"}, {"label": "Lines on map", "value": "maplines"}, ], multi=False, id="map_type_choice")), # Available buttons and choices for plotting html.Div(create_dropdown("Colorscale", options=[ {"label": v, "value": v} for v in colorscale_list ], multi=False, id="colorscale", value="Jet")), html.Div(create_dropdown("Latitude", options=[], multi=False, id="lat_var")), html.Div(create_dropdown("Longitude", options=[], multi=False, id="lon_var")), html.Div(create_dropdown("Country", options=[], multi=False, id="country")), html.Div(create_dropdown("Z variable", options=[], multi=False, id="z_var")), # Relevant for `agg_choropleth` html.Div(create_dropdown("Choose aggregation type", options=[ {"label": "Sum", "value": "sum"}, {"label": "Average", "value": "mean"}, {"label": "Count", "value": "count"}, {"label": "Max", "value": "max"}, {"label": "Min", "value": "min"}, ], multi=False, id="aggregator_field", value="count")), # Relevant for `maplines` html.Div(create_dropdown("Destination latitude", options=[], multi=False, id="dest_lat")), html.Div(create_dropdown("Destination longitude", options=[], multi=False, id="dest_long")), # How to draw the map and represent distances html.Div(create_dropdown("Map projection style", options=[ {"label": "Equirectangular", "value": "equirectangular"}, {"label": "Azimuthal equal area", "value": "azimuthal equal area"}, {"label": "Orthographic", "value": "orthographic"}, ], multi=False, id="projection_type")), ], id="map_menu"), ]
def render_variable_choices_pipeline(algo_choice_pipeline, user_id): """ Create a menu of dcc components to select pipeline and variables. Args: algo_choice_pipeline (str): Choice among (pre)defined pipelines. user_id (str): Session/user id. Returns: list: Dash elements. """ # Make sure all variables have a value before returning choices if algo_choice_pipeline is None: return [html.H4("Select a pipeline first.")] model = dill.loads(r.get(algo_choice_pipeline)) input_node = pipeline_creator.find_pipeline_node( pipeline_classes.BaseInput)(model) terminal_node = pipeline_creator.find_pipeline_node( pipeline_classes.TerminalNode)(model) # defaults layout = [] options = [] if isinstance(input_node, pipeline_classes.GenericInput): try: dataset_choice = input_node.dataset except AttributeError: return [html.H4("Something went wrong with the input")] if isinstance(input_node, pipeline_classes.TwitterAPI): layout += [ html.Button("Fit model", id="fit_model", n_clicks=0), # Debugger html.Div( dcc.Dropdown(options=[], multi=True, id="xvars_pipeline", style={"display": "none"})), ] else: df = get_data(dataset_choice, user_id) # Truncate labels so they don't fill the whole dropdown options = [{'label': col[:35], 'value': col} for col in df.columns] layout += [ html.Div(create_dropdown("X variable(s)", options, multi=True, id="xvars_pipeline"), className="horizontal_dropdowns"), # to debug the next callback html.Button("Fit model", id="fit_model", n_clicks=0, style={"display": "none"}) ] else: layout += [ # Debuggers html.Button("Fit model", id="fit_model", n_clicks=0, style={"display": "none"}), html.Div( dcc.Dropdown(options=[], multi=True, id="xvars_pipeline", style={"display": "none"})), ] if not isinstance(terminal_node, pipeline_classes.UnsupervisedLearner): layout += [ html.Div(dcc.Dropdown(options=options, multi=False, id="yvars_pipeline"), className="horizontal_dropdowns") ] else: # Only existing for debugging the next callback, no yvars needed layout += [ dcc.Dropdown(options=[], id="yvars_pipeline", style={"display": "none"}) ] return layout