def plot_data(selected_year, selected_district):
# filter data based on user selection
dff = df[df.Year == selected_year]
dff = dff[dff.District == selected_district]
# build scatter plot
fig, ax = plt.subplots()
ax.scatter(x=dff.Damage, y=dff.Graffiti, s=dff.Drugs)
ax.set_xlabel("Damage")
ax.set_ylabel("Graffiti")
ax.grid(color='lightgray', alpha=0.7)
html_scatter = mpld3.fig_to_html(fig)
# build bar plot
fig, ax = plt.subplots()
ax.bar(x=dff.Location, height=dff.Robbery)
ax.set_xlabel(selected_district)
ax.set_ylabel("Robbery")
ax.grid(color='lightgray', alpha=0.7)
html_bar = mpld3.fig_to_html(fig)
# build DataTable
mytable = dash_table.DataTable(
id='table',
columns=[{
"name": i,
"id": i
} for i in dff.columns],
data=dff.to_dict('records'),
)
return html_scatter, html_bar, mytable
def test_cbsc003_callback_with_unloaded_async_component(dash_duo):
app = Dash()
app.layout = html.Div(children=[
dcc.Tabs(children=[
dcc.Tab(children=[
html.Button(id="btn", children="Update Input"),
html.Div(id="output", children=["Hello"]),
]),
dcc.Tab(children=dash_table.DataTable(id="other-table")),
])
])
@app.callback(Output("output", "children"), [Input("btn", "n_clicks")])
def update_out(n_clicks):
if n_clicks is None:
raise PreventUpdate
return "Bye"
dash_duo.start_server(app)
dash_duo.wait_for_text_to_equal("#output", "Hello")
dash_duo.find_element("#btn").click()
dash_duo.wait_for_text_to_equal("#output", "Bye")
assert dash_duo.get_logs() == []
def get_standard_data_table(df, id):
"""Returns a dash data table with standard configuration.
"""
if type(df) == pd.Series:
df = df.to_frame().reset_index()
df = df.fillna("")
def get_datatypes(dtype):
if 'float' in dtype or 'double' in dtype or 'int' in dtype:
return 'numeric'
elif 'datetime' in dtype:
return 'datetime'
return 'text'
dataset_table = dash_table.DataTable(
id=id,
columns=[{
"name": i,
"id": i,
'presentation': 'markdown',
"type": get_datatypes(str(df[i].dtype))
} for i in df.columns],
data=df.to_dict("records"),
is_focused=True,
style_table={
'height': 500,
'overflowY': 'scroll',
},
style_header={
'backgroundColor': 'white',
'fontWeight': 'bold',
"border": "1px solid white",
},
style_cell={
'whiteSpace': 'normal',
'height': 'auto',
'textAlign': 'left'
},
sort_action="native",
sort_mode="multi",
filter_action='native',
filter_options={'case': 'insensitive'},
style_data={
"backgroundColor": '#E3F2FD',
"border-bottom": "1px solid #90CAF9",
"border-top": "1px solid #90CAF9",
"border-left": "1px solid #E3F2FD",
"border-right": "1px solid #E3F2FD"
},
style_data_conditional=[{
"if": {
"state": "selected"
},
"backgroundColor": '#E3F2FD',
"border-bottom": "1px solid #90CAF9",
"border-top": "1px solid #90CAF9",
"border-left": "1px solid #E3F2FD",
"border-right": "1px solid #E3F2FD",
}])
return dataset_table
def display_plot_data_tb(display_check, jsonized_df_export, test_passed):
if display_check == ['display']:
if test_passed is True:
dataset = json.loads(jsonized_df_export[0])
df_to_export = pd.read_json(dataset, orient='split')
df_tb_div_list = [
html.Hr(),
dt.DataTable(
id=app_id_dict['df_export_tb'],
data=df_to_export.to_dict('records'),
columns=[{
'name': each_col,
'id': each_col
} for each_col in df_to_export.columns],
export_format='csv',
style_data_conditional=[striped_rows],
fixed_rows={
'headers': True,
'data': 0
},
style_table={
'maxHeight': '300',
'overflowY': 'scroll',
},
)
]
return [df_tb_div_list]
else:
return [None]
else:
return [None]
def make_component_table(ckey, data):
ckey = None if not ckey in data.keys() else ckey
if ckey is not None:
cdict = data[ckey]
if ckey == 'system':
cdict = copy(data[ckey])
cdict.pop('dates', None)
else:
cdict = copy(data[ckey]['settings'])
cdict.pop('styling', None)
df = pd.DataFrame({
"Component property": [key for key in cdict.keys()],
"Property value" : [value for value in cdict.values()],
}
)
table = html.Div([
dash_table.DataTable(
columns=[
{"name": df.columns[0], "id": df.columns[0], "editable": False},
{"name": df.columns[1], "id": df.columns[1], "editable": True},
],
data= df.to_dict('records')
)], style = {'visibility': 'visible'}
)
else:
table = html.Div([
], style = {'visibility': 'hidden'}
)
return table
def make_datatable(df, dataset):
global table_index
table_index += 1
return dash_table.DataTable(
id={'type': 'datatable_table', 'dataset': dataset, 'index': table_index},
columns=[
(dict(name=i, id=i, hideable=False, type='numeric',
format=Format(precision=4, scheme=Scheme.fixed, trim=Trim.yes))
if i != 'Species' else
dict(name=i, id=i))
# {"name": i, "id": i, "hideable": True}
for i in df.columns
if i not in ['numIndex', 'id']
],
data=df.to_dict('records'), # the contents of the table
filter_action="native", # allow filtering of data by user ('native') or not ('none')
sort_action="native", # enables data to be sorted per-column by user or not ('none')
sort_mode="single", # sort across 'multi' or 'single' columns
# column_selectable="multi", # allow users to select 'multi' or 'single' columns
row_selectable="multi", # allow users to select 'multi' or 'single' rows
# row_deletable=True, # choose if user can delete a row (True) or not (False)
page_size=8, # number of rows visible per page
style_cell={ # ensure adequate header width when text is shorter than cell's text
# 'minWidth': 95, 'maxWidth': 95, 'width': 95,
'fontSize': 12, 'font-family': 'sans-serif'
},
style_data={ # overflow cells' content into multiple lines
'whiteSpace': 'normal',
'height': 'auto'}
)
def get_datatable(data, color_scheme=cfg.COLOR_SCHEME, editable=False):
# type: (List[Dict], Dict[str, str], bool) -> dash_table.DataTable
'''
Gets a Dash DataTable element using given data.
Assumes dict element has all columns of table as keys.
Args:
data (list[dict]): List of dicts.
color_scheme (dict, optional): Color scheme dictionary.
Default: COLOR_SCHEME.
editable (bool, optional): Whether table is editable. Default: False.
Returns:
DataTable: Table of data.
'''
cs = copy(cfg.COLOR_SCHEME)
cs.update(color_scheme)
cols = [] # type: Any
if len(data) > 0:
cols = data[0].keys()
cols = [{'name': x, 'id': x} for x in cols]
return dash_table.DataTable(
data=data,
columns=cols,
id='datatable',
fixed_rows=dict(headers=True),
sort_action='native',
sort_mode='multi',
cell_selectable=editable,
editable=editable,
)
def show_file(complete_filename, filename):
try:
print(f'Importing event log: {complete_filename}')
framework.import_log(complete_filename, filename)
except Exception as e:
print(e)
return html.Div([f'Error when processing file: {complete_filename}.'])
div_file_info = html.Div([
html.H5(
f'First {framework.MAX_TRACES} traces of the file: {filename}'),
html.
H5(f'Total of cases: {framework.current_log.total_of_cases} and Median case duration: '
f'{round(framework.current_log.median_case_duration_in_hours, 2)} hrs'
),
dash_table.DataTable(
data=framework.current_log.first_traces.to_dict('records'),
columns=[{
'name': i,
'id': i
} for i in framework.current_log.first_traces.columns],
style_cell={'textAlign': 'left'},
style_as_list_view=True,
sort_action="native",
sort_mode='multi',
page_action="native",
page_current=0,
page_size=20,
),
])
return div_file_info
def create_params_table(table_name="", data={}, columns=None, **kwargs):
style_table = {"overflowX": "scroll"}
style_cell = {
"minWidth": "0px",
"maxWidth": "180px",
"whiteSpace": "normal",
"font_size": "14px",
}
css = [{
"selector":
".dash-cell div.dash-cell-value",
"rule":
"display: inline; white-space: inherit; overflow: inherit; text-overflow: inherit;",
}]
# if data is null, return early
if len(data) == 0:
output_info_table = dash_table.DataTable(
id=table_name,
style_table=style_table,
style_cell=style_cell,
css=css,
)
return output_info_table
# convert dict into pandas
elif type(data) == dict and len(data) > 0:
data_pd = pd.DataFrame.from_dict(data)
data = data_pd.reset_index().astype(str)
if columns is None:
columns = [{"name": i, "id": i} for i in data.columns]
else:
columns = [{"name": i, "id": i} for i in columns]
data = data.to_dict("records")
output_info_table = dash_table.DataTable(
id=table_name,
columns=columns,
data=data,
style_table=style_table,
style_cell=style_cell,
css=css,
**kwargs,
)
return output_info_table
def layout(self) -> html.Div:
return html.Div(
style={"marginLeft": "10px", "height": "90vh"},
children=[
html.Div(
children=[
html.Label(
"Tornado Plot",
style={
"textAlign": "center",
"font-weight": "bold",
},
),
wcc.RadioItems(
vertical=False,
id=self.ids("plot-or-table"),
options=[
{"label": "Show bars", "value": "bars"},
{
"label": "Show table",
"value": "table",
},
],
value="bars",
),
],
),
html.Div(
style={"overflowY": "auto", "height": "60vh"},
children=[
html.Div(
id=self.ids("graph-wrapper"),
style={},
children=wcc.Graph(
id=self.ids("tornado-graph"),
config={"displayModeBar": False},
),
),
html.Div(
id=self.ids("table-wrapper"),
style={"display": "none"},
children=dash_table.DataTable(
id=self.ids("tornado-table"),
style_cell={
"whiteSpace": "normal",
"height": "auto",
},
),
),
],
),
html.Hr(style={"marginTop": "10px"}),
self.settings_layout,
dcc.Store(id=self.ids("storage"), storage_type="session"),
dcc.Store(id=self.ids("click-store"), storage_type="session"),
dcc.Store(id=self.ids("high-low-storage"), storage_type="session"),
dcc.Store(id=self.ids("client-height-pixels"), storage_type="session"),
],
)
def layout(self) -> dash_table.DataTable:
return dash_table.DataTable(
columns=[{"name": i, "id": i} for i in self.df.columns],
data=self.df.to_dict("records"),
sort_action="native" if self.sorting else "none",
filter_action="native" if self.filtering else "none",
page_action="native" if self.pagination else "none",
)
def update_output(season, home, away):
if season == 'All':
data = df.query('((HomeTeam==@home & AwayTeam==@away) | (HomeTeam==@away & AwayTeam==@home))')
else:
data = df.query('Season==@season & ((HomeTeam==@home & AwayTeam==@away) | (HomeTeam==@away & AwayTeam==@home))')
data_1 = data.to_dict('rows')
columns = [{"name": i, "id": i,} for i in (df.columns)]
return dt.DataTable(data=data_1, columns=columns)
def main(unused_argv):
# TODO: Make this a more efficient query.
sessions = queries.GetSessions()
points_columns = queries.GetPointsColumns() + [
'front_brake_pressure_percentage', 'rear_brake_pressure_percentage',
'racing_line', 'gsum', 'time_delta'
]
tracks = queries.GetTracks()
app.layout = html.Div(
style={'display': 'grid'},
children=[
dcc.Location(id='url', refresh=False),
dcc.Link('Home', href='/'),
dcc.Link('Clear', href='/track=None&points=None'),
dcc.Dropdown(
id='track-dropdown',
options=[{
'label': i,
'value': i
} for i in tracks],
searchable=False,
clearable=False,
style={'width': '50%'},
),
dcc.Dropdown(
id='points-dropdown',
options=[{
'label': i,
'value': i
} for i in points_columns],
clearable=False,
multi=True,
),
dash_table.DataTable(
id='sessions-table',
columns=[{
'name': i,
'id': i
} for i in sessions.columns],
filter_action='native',
sort_action='native',
sort_mode='single',
sort_by=[{
'column_id': 'lap_time',
'direction': 'asc'
}, {
'column_id': 'session_time',
'direction': 'desc'
}],
row_selectable='multi',
page_action='native',
page_current=0,
page_size=10,
),
html.Div(id='graphs'),
],
)
app.run_server(host='0.0.0.0', debug=FLAGS.debug)
def get_project_data(df: pd.DataFrame, project_name) -> dt.DataTable:
project_df = df[df.project_name == project_name]
project_df = project_df.sort_values(by="timestamp")
project_data = project_df.to_dict("rows")
columns = [{
"name": column,
"id": column
} for column in project_df.columns]
return dt.DataTable(data=project_data, columns=columns)
def simple_table(names=("a", "b"), **props_override):
props = dict(
id="table",
columns=table_columns(names),
data=[{"c0": 0, "c1": 1}, {"c0": 2, "c1": 3}],
persistence=True,
)
props.update(props_override)
return dt.DataTable(**props)
def layout(self) -> html.Div:
"""Returns a table with dataframe columns and clickable color column
Add this to the layout of the plugin"""
return html.Div(
style={
"fontSize": "0.8em",
"height": "600px",
"fontColor": "black",
},
children=[
dcc.Store(
id=self.color_store_id,
data=list(self._dframe["COLOR"].values),
storage_type="session",
),
wcc.FlexBox(
style={"display": "flex"},
children=[
html.Div(
style={
"flex": 2,
"overflowY": "scroll",
"height": "550px"
},
children=dash_table.DataTable(
id={
"id": self._uuid,
"element": "table"
},
fixed_rows={"headers": True},
columns=self._columns,
style_header={
"opacity": 0.5,
},
data=self._dframe.to_dict("records"),
style_data_conditional=self.
data_style_in_table,
),
),
html.Div(
id={
"id": self._uuid,
"element": "pickerwrapper"
},
style={"flex": 1},
children=[
html.Label(
"Click on a table row to get a color picker",
style={"padding": "15px"},
)
],
),
],
),
],
)
def get_table(df: DataFrame):
grouped = df[["confirmed", "name"]].groupby("name")
df = grouped.sum()
df["increase"] = grouped.last()
df["increase"] = df["increase"].apply(get_increase_str)
df.sort_values("confirmed", ascending=False, inplace=True)
df.reset_index(inplace=True)
table = dash_table.DataTable(
id="cases-table",
data=df.to_dict("records"),
columns=[
{"name": "Регион", "id": "name"},
{"name": "Случаев", "id": "confirmed"},
{"name": "За сегодня", "id": "increase"},
],
merge_duplicate_headers=True,
style_header={
"fontWeight": "700",
"whiteSpace": "normal",
"height": "auto",
},
style_data={
"whiteSpace": "normal",
"height": "auto",
},
style_cell={
"backgroundColor": "#22252b",
"color": "#bdbdbd",
"border": "2px solid #1a1c23",
"textAlign": "right",
"fontFamily": "'Roboto Slab', sans-serif",
"padding": "5px",
},
style_cell_conditional=[
{
"if": {"column_id": "name"},
"textAlign": "left",
},
],
style_data_conditional=[
{
"if": {"column_id": "increase"},
"color": "rgb(250,170,0,0.7)",
},
],
editable=False,
row_selectable=False,
column_selectable=False,
)
return table
def get_key_value_table(
data, id_='key-value', header='', editable=False, key_order=None
):
# type (dict, Optional(str), str, bool, Optional(List[str])) -> DataTable
'''
Gets a Dash DataTable element representing given dictionary.
Args:
data (dict): Dictionary.
id_ (str, optional): CSS id. Default: 'key-value'.
header (str, optional): Table header title. Default: ''.
editable (bool, optional): Whether table is editable. Default: False.
key_order (list[str], optional): Order in which keys will be displayed.
Default: None.
Returns:
DataTable: Tablular representation of given dictionary.
'''
data = rpb.BlobETL(data).to_flat_dict()
# determine keys
keys = sorted(list(data.keys()))
if key_order is not None:
diff = set(key_order).difference(keys)
if len(diff) > 0:
diff = list(sorted(diff))
msg = f'Invalid key order. Keys not found in data: {diff}.'
raise KeyError(msg)
keys = set(keys).difference(key_order)
keys = sorted(list(keys))
keys = key_order + keys
# transform data
data = [dict(key=k, value=data[k]) for k in keys]
cols = [] # type: Any
if len(data) > 0:
cols = data[0].keys()
cols = [{'name': x, 'id': x} for x in cols]
table = dash_table.DataTable(
data=data,
data_previous=data,
columns=cols,
id=f'{id_}-table',
sort_action='native',
sort_mode='multi',
page_action='none',
cell_selectable=True,
editable=editable,
)
head = html.Div(className='key-value-table-header', children=header)
return html.Div(
id=id_, className='key-value-table-container', children=[head, table]
)
def create_graph1(data):
dff = pd.DataFrame(data)
# 2. convert string like JSON to pandas dataframe
# dff = pd.read_json(data, orient='split')
my_table = dash_table.DataTable(columns=[{
"name": i,
"id": i
} for i in dff.columns],
data=dff.to_dict('records'))
return my_table
def populate_checklist(data, day):
if day is None:
return html.H1("Please choose a day on bargraph page!")
dff = pd.DataFrame(data)
dff = dff[dff["day"] == day]
my_table = dash_table.DataTable(
id='table',
columns=[{"name": i, "id": i} for i in dff.columns],
data=dff.to_dict('records'),
)
return my_table
def test_cbsc007_parallel_updates(refresh, dash_duo):
# This is a funny case, that seems to mostly happen with dcc.Location
# but in principle could happen in other cases too:
# A callback chain (in this case the initial hydration) is set to update a
# value, but after that callback is queued and before it returns, that value
# is also set explicitly from the front end (in this case Location.pathname,
# which gets set in its componentDidMount during the render process, and
# callbacks are delayed until after rendering is finished because of the
# async table)
# At one point in the wildcard PR #1103, changing from requestQueue to
# pendingCallbacks, calling PreventUpdate in the callback would also skip
# any callbacks that depend on pathname, despite the new front-end-provided
# value.
app = Dash()
app.layout = html.Div([
dcc.Location(id="loc", refresh=refresh),
html.Button("Update path", id="btn"),
dash_table.DataTable(id="t", columns=[{
"name": "a",
"id": "a"
}]),
html.Div(id="out"),
])
@app.callback(Output("t", "data"), [Input("loc", "pathname")])
def set_data(path):
return [{"a": (path or repr(path)) + ":a"}]
@app.callback(Output("out", "children"),
[Input("loc", "pathname"),
Input("t", "data")])
def set_out(path, data):
return json.dumps(data) + " - " + (path or repr(path))
@app.callback(Output("loc", "pathname"), [Input("btn", "n_clicks")])
def set_path(n):
if not n:
raise PreventUpdate
return "/{0}".format(n)
dash_duo.start_server(app)
dash_duo.wait_for_text_to_equal("#out", '[{"a": "/:a"}] - /')
dash_duo.find_element("#btn").click()
# the refresh=True case here is testing that we really do get the right
# pathname, not the prevented default value from the layout.
dash_duo.wait_for_text_to_equal("#out", '[{"a": "/1:a"}] - /1')
if not refresh:
dash_duo.find_element("#btn").click()
dash_duo.wait_for_text_to_equal("#out", '[{"a": "/2:a"}] - /2')
def target_points_tab_layout(self) -> dash_table.DataTable:
df = self.df_well_target_points.get_targetpoints_df()
return dash_table.DataTable(
id=self.ids("target-point-table"),
columns=[{
"name": i,
"id": i
} for i in df.columns],
data=df.to_dict("records"),
sort_action="native",
filter_action="native",
)
def create_datatable(df):
return [
dash_table.DataTable(
id='datatable',
columns=[{
'name': n,
'id': i
} for n, i in zip([
'Term', 'Subj', 'Nmbr', 'CRN', 'Sec', 'S', 'Cam', 'Title',
'Credit', 'Enrl', 'Days', 'Time', 'Loc', 'Instructor'
], [*df.columns])],
style_header={
'backgroundColor': 'rgb(230, 230, 230)',
'fontWeight': 'bold',
},
style_cell={
'font-family': 'sans-serif',
'font-size': '1rem'
},
style_cell_conditional=[{
'if': {
'column_id': i
},
'textAlign': 'left',
'minWidth': w,
'width': w,
'maxWidth': w,
'whiteSpace': 'normal'
} for i, w in zip([*df.columns], [
'9%', '5%', '5.5%', '5.5%', '4.5%', '3.5%', '4.5%', '19.5%',
'5.5%', '4.5%', '5.5%', '9%', '7.5%', '11%'
])],
fixed_rows={
'headers': True,
'data': 0
},
page_size=5000,
virtualization=True,
data=df.to_dict('records'),
# editable=True,
filter_action='native',
sort_action='native',
sort_mode='multi',
# row_selectable='multi',
# row_deletable=True,
selected_rows=[],
style_data={
'whiteSpace': 'normal',
'height': 'none',
},
)
]
def make_table(data):
table = dash_table.DataTable(
id="data",
columns=[{'id': 'activity', 'name': 'name'}],
data=json_to_list(data),
page_size=10,
page_current=0,
virtualization=True,
fixed_rows={'headers': True},
style_cell={'minWidth': 95, 'width': 95, 'maxWidth': 95},
style_table={'height': 300}, # default is 500,
)
return table
def test_cbmt003_chain_with_table(dash_duo):
# see https://github.com/plotly/dash/issues/1071
app = Dash(__name__)
app.layout = html.Div(
[
html.Div(id="a1"),
html.Div(id="a2"),
html.Div(id="b1"),
html.H1(id="b2"),
html.Button("Update", id="button"),
dash_table.DataTable(id="table"),
]
)
@app.callback(
# Changing the order of outputs here fixes the issue
[Output("a2", "children"), Output("a1", "children")],
[Input("button", "n_clicks")],
)
def a12(n):
return "a2: {!s}".format(n), "a1: {!s}".format(n)
@app.callback(Output("b1", "children"), [Input("a1", "children")])
def b1(a1):
return "b1: '{!s}'".format(a1)
@app.callback(
Output("b2", "children"),
[Input("a2", "children"), Input("table", "selected_cells")],
)
def b2(a2, selected_cells):
return "b2: '{!s}', {!s}".format(a2, selected_cells)
dash_duo.start_server(app)
dash_duo.wait_for_text_to_equal("#a1", "a1: None")
dash_duo.wait_for_text_to_equal("#a2", "a2: None")
dash_duo.wait_for_text_to_equal("#b1", "b1: 'a1: None'")
dash_duo.wait_for_text_to_equal("#b2", "b2: 'a2: None', None")
dash_duo.find_element("#button").click()
dash_duo.wait_for_text_to_equal("#a1", "a1: 1")
dash_duo.wait_for_text_to_equal("#a2", "a2: 1")
dash_duo.wait_for_text_to_equal("#b1", "b1: 'a1: 1'")
dash_duo.wait_for_text_to_equal("#b2", "b2: 'a2: 1', None")
dash_duo.find_element("#button").click()
dash_duo.wait_for_text_to_equal("#a1", "a1: 2")
dash_duo.wait_for_text_to_equal("#a2", "a2: 2")
dash_duo.wait_for_text_to_equal("#b1", "b1: 'a1: 2'")
dash_duo.wait_for_text_to_equal("#b2", "b2: 'a2: 2', None")
def notebookHome(self):
# TODO: better first call
example = UserFilesAccess.shortExample
example_data = pandas.read_excel(example)
notebook = dash_table.DataTable(
id=self.notebook,
columns=[
{
"name": column,
"id": column,
"editable": False,
"hideable": True,
"renamable": True,
}
if column == "ID"
else {
"name": column,
"id": column,
"type": "numeric",
"hideable": True,
"renamable": True,
}
if (column == "Amount" or column == "Reimbursement")
else {
"name": column,
"id": column,
"type": "datetime",
"hideable": True,
"renamable": True,
}
if column == "Date"
else {
"name": column,
"id": column,
"hideable": True,
"renamable": True,
}
for column in example_data.columns
],
editable=True,
row_deletable=True,
export_columns="all",
export_format="xlsx",
export_headers="display",
)
notebook_div = html.Div(
id=self.notebook_div, children=notebook, style={"display": "none"},
)
return notebook_div
def makeTable(id, df, height=300, row_selectable='single', defaultRow=0):
"""
defaultRow: row index selected on __init__
"""
if df is None:
statDict = {'tmp': 'empty'}
df = pd.DataFrame(columns=['Idx', 'Error'])
#df['idx'] = [i for i in range(len(statDict.keys()))]
#df['error'] = [x for x in statDict.keys()]
#
columns = [{"name": i, "id": i} for i in df.columns]
data = df.to_dict('records')
ret = dash_table.DataTable(
id=id,
persistence=True,
columns=columns,
data=data,
row_selectable=row_selectable,
fixed_rows={'headers': True}, # on scroll, keep headers at top
selected_rows=[defaultRow], # default selected row
style_header={
'backgroundColor': 'rgb(30, 30, 50)',
'fontWeight': 'bold',
},
style_cell={
'textAlign': 'left',
'fontSize': 11,
'font-family': 'sans-serif',
'color': 'white', # dark theme
'backgroundColor': 'rgb(30, 30, 30)', # dark theme
},
style_data_conditional=[{
'if': {
'row_index': 'odd'
},
#'backgroundColor': 'rgb(50, 50, 50)' # dark theme
'backgroundColor': 'rgb(50, 50, 50)' # light theme
}],
# CSS styles to be applied to the outer table container
style_table={
'height': height, # hard coding height
'overflowX': 'auto',
'overflowY': 'auto',
#'width': width
})
return ret
def display_output(n_clicks, column_list):
"""Renders wellpoints table from csv file"""
wellpoints_df = self.df_well_target_points.update_wellpoints_df(
column_list)
return html.Div([
dash_table.DataTable(
id=self.ids("well-points-table"),
columns=[{
"name": i,
"id": i
} for i in wellpoints_df.columns],
data=wellpoints_df.to_dict("records"),
sort_action="native",
filter_action="native",
),
])
def get_dict_input(
self,
kwarg_label: str,
default: Optional[Any] = None,
state: Optional[dict] = None,
label: Optional[str] = None,
help_str: str = None,
key_name: str = "key",
value_name: str = "value",
):
"""
:param kwarg_label:
:param default:
:param state:
:param label:
:param help_str:
:param key_name:
:param value_name:
:return:
"""
state = state or {}
default = default or state.get(kwarg_label) or {}
dict_input = dt.DataTable(
id=self.id(kwarg_label, is_kwarg=True, hint="dict"),
columns=[
{
"id": "key",
"name": key_name
},
{
"id": "value",
"name": value_name
},
],
data=[{
"key": k,
"value": v
} for k, v in default.items()],
editable=True,
persistence=False,
)
return add_label_help(dict_input, label, help_str)
def make_rate_table(self):
probe_group = [dict(name="Measured From %s" % each["value"],
id=each["value"].replace("-", ""))
for each in self.dao_dnsprobe.make_probe_group()]
columns = [dict(name="Address Family", id="af"),
dict(name="Nameserver", id="dst_name"),
dict(name="Transport", id="proto")] + probe_group
soa_table = dash_table.DataTable(
id="main-content-table",
filter_action="native",
columns=columns,
style_data_conditional=[],
data=[])
return soa_table
