def parse(app, markdown_path, extra_env_vars=None):
extra_env_vars = extra_env_vars or {}
raw = (HERE / markdown_path).read_text()
# we use the markdown package to extract metadata
md = markdown.Markdown(extensions=["meta"])
md.convert(raw)
meta = md.Meta
content = [
html.H1(meta["title"][0]),
html.Div(dcc.Markdown(meta["lead"][0]), className="lead"),
]
raw = HEADER_PATTERN.sub("", raw).strip()
markdown_blocks = SPLIT_PATTERN.split(raw)
markdown_blocks = [
dcc.Markdown(block.strip()) for block in markdown_blocks
]
examples_docs = EXAMPLE_DOC_PATTERN.findall(raw)
examples_docs = [
_parse_block(block, app, extra_env_vars) for block in examples_docs
]
content.extend(_interleave(markdown_blocks, examples_docs))
return html.Div(content, key=str(markdown_path))
def component_reference(component_name):
component = getattr(dbc, component_name)
component_doc = component.__doc__
return_div = [
dcc.Markdown("### Keyword arguments for {}".format(component_name))
]
docs = component_doc.split("Keyword arguments:")[-1]
docs = re.sub(VERBATIM_PATTERN, r"`[\3]`", docs)
# format links
docs = re.sub(LINK_PATTERN, r"[\1](\2)", docs)
# formats the prop defaults
docs = re.sub(PROP_OPTIONAL_DEFAULT_PATTERN, r"default `\1`)", docs)
# formats the prop type
docs = re.sub(PROP_TYPE_PATTERN, r"\1*\2*;", docs)
# formats the prop name on first level only
docs = re.sub(PROP_NAME_PATTERN, r"\1**`\2`** (", docs)
# formats keys of nested dicts
docs = re.sub(NESTED_PROP_NAME_PATTERN, r"\1**`\2`** (", docs)
# removes a level of nesting
docs = docs.replace("\n-", "\n")
return_div.append(dcc.Markdown(docs))
return html.Div(return_div, className="reference")
def test_mkdw001_img(dash_dcc):
app = Dash(__name__, eager_loading=True, assets_folder="../../assets")
app.layout = html.Div([
html.Div("Markdown img"),
dcc.Markdown(['<img src="assets/image.png" />'],
dangerously_allow_html=True),
html.Div("Markdown img - requires dangerously_allow_html"),
dcc.Markdown(['<img src="assets/image.png" />']),
])
dash_dcc.start_server(app)
dash_dcc.percy_snapshot("mkdw001 - image display")
assert dash_dcc.get_logs() == []
def div_base():
return html.Div(
children=[
dcc.Markdown(''' ### **Sousa, Paraíba - 2020**'''),
dcc.Markdown(
'''#### Site: [Cidade Sousa](https://www.sousa.pb.gov.br/)''')
],
style={
'textAlign': 'center',
'font-weight': 'bold',
'border': '2px solid lightgreen',
'box-shadow':
'0 4px 8px 0 rgba(0, 0, 0, 0.2), 0 6px 20px 0 rgba(0, 0, 0, 0.19)',
'background-color': '#8FBC8F',
})
def main_layout(self) -> html.Div:
return html.Div(children=[
html.Div(
style={
"height": "40vh",
"overflow-y": "auto"
},
children=[
wcc.FlexBox(children=[
wcc.FlexColumn(
[
self.overview_report_volume_changes,
],
flex=7,
style={"margin-right": "20px"},
),
wcc.FlexColumn(self.dataset_info, flex=3),
], ),
],
),
html.Div(
style={"margin-top": "20px"},
children=[
wcc.Header("QC_FLAG descriptions",
style=LayoutStyle.HEADER),
dcc.Markdown(qc_flag_description()),
],
),
])
def main_layout(self, dframe: pd.DataFrame, selectors: list,
map_figure: go.Figure) -> html.Div:
return html.Div(children=[
wcc.Header("Maximum capillary pressure scaling",
style=LayoutStyle.HEADER),
wcc.FlexBox(
style={
"margin-top": "10px",
"height": "40vh"
},
children=[
wcc.FlexColumn(
dcc.Markdown(pc_columns_description()),
flex=7,
style={"margin-right": "40px"},
),
wcc.FlexColumn(
FullScreen(
wcc.Graph(
style={
"height": "100%",
"min-height": "35vh"
},
figure=map_figure,
)),
flex=3,
),
],
),
self.create_max_pc_table(dframe, text_columns=selectors),
])
def update_graph(figure):
if figure is None:
raise PreventUpdate
elif figure == "error":
search_error = (MessageContainer(
[
MessageBody(
dcc.Markdown(
"Plotting is only available for phase diagrams containing 2-4 components."
))
],
kind="warning",
), )
return search_error
else:
plot = [
dcc.Graph(
figure=figure,
config={
"displayModeBar": False,
"displaylogo": False
},
)
]
return plot
def test_internal(mocker):
assert "dash" in ComponentRegistry.registry
mocker.patch("dash.development.base_component.ComponentRegistry.registry")
ComponentRegistry.registry = {"dash", "dash.dcc", "dash.html"}
mocker.patch("dash.dcc._js_dist")
mocker.patch("dash.dcc.__version__")
mocker.patch("dash.html._js_dist")
dcc._js_dist = _monkey_patched_js_dist # noqa: W0212,
dcc.__version__ = "1.0.0"
app = dash.Dash(__name__,
assets_folder="tests/assets",
assets_ignore="load_after.+.js")
app.layout = dcc.Markdown()
assert app.scripts.config.serve_locally and app.css.config.serve_locally
with mock.patch("dash.dash.os.stat", return_value=StatMock()):
with mock.patch("dash.dash.importlib.import_module", return_value=dcc):
resource = app._collect_and_register_resources(
app.scripts.get_all_scripts())
assert resource == [
"/_dash-component-suites/"
"dash/external_javascript.v1_0_0m1.js",
"/_dash-component-suites/dash/external_css.v1_0_0m1.css",
"/_dash-component-suites/dash/fake_dcc.v1_0_0m1.js",
]
assert ("fake_dcc.min.js.map" in app.registered_paths["dash"]
), "Dynamic resource not available in registered path {}".format(
app.registered_paths["dash"])
def test_external(mocker):
assert "dash" in ComponentRegistry.registry
mocker.patch("dash.development.base_component.ComponentRegistry.registry")
ComponentRegistry.registry = {"dash", "dash.dcc", "dash.html"}
mocker.patch("dash.dcc._js_dist")
mocker.patch("dash.dcc.__version__")
mocker.patch("dash.html._js_dist")
dcc._js_dist = _monkey_patched_js_dist # noqa: W0212
dcc.__version__ = "1.0.0"
app = dash.Dash(__name__,
assets_folder="tests/assets",
assets_ignore="load_after.+.js")
app.layout = dcc.Markdown()
app.scripts.config.serve_locally = False
resource = app._collect_and_register_resources(
app.scripts.get_all_scripts())
assert resource == [
"https://external_javascript.js",
"https://external_css.css",
"https://component_library.bundle.js",
]
def render(self, dashboard):
return html.Div(children=[
html.H2(self.title),
html.H3(self.meta["timestamp"]),
dcc.Markdown(self.description),
html.Pre(self.meta["env"]["uname"]),
self._render(dashboard)
],
className="dashboard-object")
def test_mkdw009_target_blank_links(dash_dcc):
app = Dash(__name__)
app.layout = dcc.Markdown("[link](https://duckduckgo.com)", link_target="_blank")
dash_dcc.start_server(app)
dash_dcc.find_element("a").click()
until(lambda: len(dash_dcc.driver.window_handles) == 2, timeout=1)
def update_header(n_clicks):
if n_clicks is None:
n_sim = 1
else:
n_sim = n_clicks + 1
return dcc.Markdown(
d("""
**Simulation #{}:**
""".format(n_sim)))
def test_msmh001_no_window_variable(dash_dcc):
app = Dash(__name__)
app.layout = html.Div(dcc.Markdown(md_text))
dash_dcc.start_server(app)
dash_dcc.wait_for_element("code")
window_hljs = dash_dcc.driver.execute_script("return window.hljs")
assert window_hljs is None
assert dash_dcc.get_logs() == []
def test_mkdw004_inline_mathjax(dash_dcc, is_eager):
app = Dash(__name__, eager_loading=is_eager, assets_folder="../../assets")
app.layout = html.Div(
[
dcc.Markdown("# h1 tag with inline MathJax: $E=mc^2$", mathjax=True),
]
)
dash_dcc.start_server(app)
dash_dcc.wait_for_element("h1 svg")
assert dash_dcc.get_logs() == []
def get_layout(**kwargs):
return html.Div([
dcc.Markdown(
dedent("""
# Research Analysis
""")),
dcc.Dropdown(id="app-option",
options=[{
'label': i,
'value': i
} for i in get_app_options()],
value=get_app_options()[0]),
dcc.Dropdown(id="balance-option",
options=[{
'label': i,
'value': i
} for i in get_balancing_options()],
value="Combined"),
dcc.Loading(id="loading-icon",
type="circle",
children=[
html.Div(
children=[dcc.Graph(id="latency_vs_price")],
style={'margin': 'auto'},
),
]),
dcc.Loading(id="loading-icon",
type="circle",
children=[
html.Div(dcc.Graph(id="price_cdf_koss_weights")),
]),
dcc.Loading(id="loading-icon",
type="circle",
children=[
html.Div(dcc.Graph(id="price_cdf_algo_comparison")),
]),
dcc.Loading(id="loading-icon",
type="circle",
children=[
html.Div(dcc.Graph(id="latency_cdf_koss_weights")),
]),
dcc.Loading(id="loading-icon",
type="circle",
children=[
html.Div(dcc.Graph(id="latency_cdf_algo_comparison")),
]),
# dcc.Loading(
# id = "loading-icon",
# type="circle",
# children=[html.Div(dcc.Graph(id="latecy-to-price-graph"))]
# ),
])
def get_app_layout():
return dbc.Container([
dcc.Store(id='selected-data-left'),
dcc.Store(id='selected-data-right'),
dcc.Store(id='session-id', data=str(uuid.uuid4())),
dcc.Store(id='filter-trigger', data=0),
dcc.Store(id='left-hide-trigger', data=0),
dcc.Store(id='file-loaded-trigger', data=0),
dcc.Store(id='dummy-export-scatter2d-left'),
dcc.Store(id='dummy-export-scatter2d-right'),
dcc.Store(id='dummy-export-histogram'),
dcc.Store(id='dummy-export-violin'),
dcc.Store(id='dummy-export-parallel'),
dcc.Store(id='dummy-export-heatmap'),
dcc.Store(id='dummy-export-data'),
html.Div(
[
html.Div(html.Img(
src=app.get_asset_url('sensorview_logo.svg'),
id='sensorview-image',
style={
'height': '100px',
'width': 'auto',
},
), className="text-center"),
html.H1(app.title, className="text-center"),
html.Hr(className="my-2"),
html.P(
'Sensor Data Visualization', className="text-center"
),
],
className="bg-light rounded-3 my-2 p-3",
),
dbc.Row([
dbc.Col(
dbc.CardGroup([
testcase_card,
datafile_card
])
)], className='mb-3'),
tabs,
dcc.Markdown(
'Designed and developed by **Zhengyu Peng** \
| Powered by [Dash](https://plotly.com/dash/),\
[Redis](https://redis.io/),\
[Celery](https://docs.celeryproject.org/en/stable/),\
[Docker](https://www.docker.com/)'),
], fluid=True, className="dbc_light")
def format_pulsar_paramters(self):
pp = self._record["pulsar_parameters"]
return html.Div(children=[
html.H3("Pulsar Parameters"),
html.Br(),
html.P(["Period: {} ms".format(pp["period"])]),
html.P(
dcc.Markdown("Dispersion measure: {} pc cm<sup>-3</sup>".
format(pp["dm"]),
dangerously_allow_html=True)),
html.P("Binary: {}".format(pp["binary"])),
html.Br()
])
def learn_more(n_clicks):
# If clicked odd times, the instructions will show; else (even times), only the header will show
if n_clicks is None:
n_clicks = 0
if (n_clicks % 2) == 1:
n_clicks += 1
return (
html.Div(
style={"padding-right": "15%"},
children=[dcc.Markdown(demo_description_md)],
),
"Close",
)
else:
n_clicks += 1
return (
html.Div(
style={"padding-right": "15%"},
children=[dcc.Markdown(demo_intro_md)],
),
"Learn More",
)
def test_mkdw003_without_mathjax(dash_dcc, is_eager):
app = Dash(__name__, eager_loading=is_eager)
app.layout = html.Div(
[
dcc.Markdown("# No MathJax: Apple: $2, Orange: $3"),
]
)
dash_dcc.start_server(app)
dash_dcc.wait_for_text_to_equal("h1", "No MathJax: Apple: $2, Orange: $3")
assert not dash_dcc.driver.execute_script("return !!window.MathJax")
assert dash_dcc.get_logs() == []
def HighlightedSource(py_source, r_source, jl_source, className="px-3"):
return dbc.Tabs(
[
dbc.Tab(
dcc.Markdown(f"```{lang}\n{source}\n```", className="m-3"),
label=lang.capitalize(),
className="example-source",
) for lang, source in [
("python", py_source),
("r", r_source),
("julia", jl_source),
] if source is not None
],
className=className,
)
def populateBowlingStats(table_data,
player,
season,
match_type,
discipline,
inter_tav_type):
if discipline != "Bowling": return None
if not player: return None
df_bowling = pd.DataFrame(table_data)#getBattingDataframe()
player_name = df_bowling.iloc[player[0]]["name"]#df_batting[df_batting['name'] == player]
df_bowling = getBowlingDataframe()
df_player = getBowlingPlayer(df_bowling,
player_name,
inter_tav_type,
season,
match_type)
if df_player.empty: return None
overs = df_player['overs'].sum()
if not overs: return None
runs = df_player['runs'].sum()
wickets = df_player['wickets'].sum()
if overs:
economy = float(runs)/float(overs)
else:
economy = 0.0
if wickets:
average = float(runs)/float(wickets)
strike_rate = 6.0*float(overs)/float(wickets)
else:
average = 0.0
strike_rate = 0.0
return html.Div([
html.Div(
[ html.H2(player_name + ' Bowling', className='tavs-stat-title'),
html.Div([
dcc.Markdown("Overs: " + "{:.1f}".format(overs)),
dcc.Markdown("Wickets: " + "{:,}".format(int(wickets))),
dcc.Markdown("Runs: " + "{:,}".format(int(runs))),
dcc.Markdown("Average: " + "{:.2f}".format(average)),
dcc.Markdown("Economy Rate: " + "{:.2f}".format(economy)),
dcc.Markdown("Strike Rate: " + "{:.2f}".format(strike_rate)),
], className='tavs-unit__extra-content'),
],
className='tavs-unit',
),
], className='tavs-grid__unit tavs-grid__unit--half')
def test_mkdw006_toggle_mathjax(dash_dcc, is_eager):
app = Dash(__name__, eager_loading=is_eager)
gravity = "$F=\\frac{Gm_1m_2}{r^2}$"
app.layout = html.Div(
[
html.Button("Toggle MathJax", id="btn"),
dcc.Markdown(
f"""
# Test MathJax Toggling {gravity}
""",
id="md",
),
]
)
@app.callback(
Output("md", "mathjax"), Input("btn", "n_clicks"), prevent_initial_call=True
)
def toggle(n):
return (n or 0) % 2 != 0
dash_dcc.start_server(app)
# Initial state: no MathJax loaded or rendered, unformatted text is shown
dash_dcc.wait_for_contains_text("#md", gravity)
dash_dcc.wait_for_no_elements("#md svg")
assert not dash_dcc.driver.execute_script("return !!window.MathJax")
btn = dash_dcc.find_element("#btn")
btn.click()
# One click: MathJax is rendered, unformatted text is gone
dash_dcc.wait_for_element("#md svg")
assert gravity not in dash_dcc._get_element("#md").text
assert dash_dcc.driver.execute_script("return !!window.MathJax")
btn.click()
# Second click: Back to initial state except that MathJax library is still loaded
dash_dcc.wait_for_contains_text("#md", gravity)
dash_dcc.wait_for_no_elements("#md svg")
assert dash_dcc.driver.execute_script("return !!window.MathJax")
def apply_transformation(transformation_data, struct):
transformation = self.from_data(transformation_data)
error = None
try:
struct = transformation.apply_transformation(struct)
except Exception as exc:
error_title = (
f'Failed to apply "{transformation.__class__.__name__}" '
f"transformation: {exc}")
traceback_info = Reveal(
title=html.B("Traceback"),
children=[dcc.Markdown(traceback.format_exc())],
)
error = [error_title, traceback_info]
return struct, error
def get_layout(**kwargs):
print("pivot table")
return html.Div([
dcc.Markdown(
dedent("""
# Analysis Pivot Table
""")),
dcc.Dropdown(id="app-option",
options=[{
'label': i,
'value': i
} for i in get_app_options()],
value=get_app_options()[0]),
dcc.Loading(id="loading-icon",
type="circle",
children=[
html.Div(id="pivot-table"),
]),
])
def warming():
return html.Div([
dbc.Row([
dbc.Col([
dcc.Markdown(global_md),
html.A("View details",
href='https://datahub.io/core/global-temp#readme',
className="btn btn-secondary"),
],
md=3),
dbc.Col(
[
# https://dash.plot.ly/dash-core-components/graph
dcc.Graph(
figure={
"data": [{
"y": data['Mean'].tolist(),
"x": data['Year'].tolist()
}],
'layout': {
'title': 'Global Temperature Change (°C)',
'xaxis': {
'title': 'Year'
}
}
},
config={'displayModeBar': False},
),
],
md=9),
]),
dbc.Row([
dbc.Col([
dcc.Link("State Solar",
href=spa.url_for('solar'),
className="btn btn-primary float-end")
],
md=12)
])
])
def test_mkdw007_load_mathjax(dash_dcc, is_eager):
app = Dash(__name__, eager_loading=is_eager)
gravity = "$F=\\frac{Gm_1m_2}{r^2}$"
app.layout = html.Div(
[
html.Button("Add Second MathJax", id="btn"),
dcc.Markdown(
f"""
# No Math Rendering Here! {gravity}
""",
id="md",
mathjax=False,
),
html.Div("initial", id="out"),
]
)
@app.callback(
Output("out", "children"), Input("btn", "n_clicks"), prevent_initial_call=True
)
def add_math(n):
return dcc.Markdown(f"# Math!\n{gravity}", id="md2", mathjax=True)
dash_dcc.start_server(app)
# Initial state: no MathJax loaded or rendered, unformatted text is shown
dash_dcc.wait_for_contains_text("#md", gravity)
dash_dcc.wait_for_no_elements("#md svg")
assert not dash_dcc.driver.execute_script("return !!window.MathJax")
btn = dash_dcc.find_element("#btn")
btn.click()
# One click: MathJax is loaded and rendered on the second, unformatted text is gone
dash_dcc.wait_for_element("#md2 svg")
assert gravity not in dash_dcc._get_element("#md2").text
assert dash_dcc.driver.execute_script("return !!window.MathJax")
def update_graph(plotdata):
if not plotdata:
raise PreventUpdate
if plotdata == "error":
search_error = (MessageContainer(
[
MessageBody(
dcc.Markdown(
"XANES pattern not available for this selection."
))
],
kind="warning",
), )
return search_error
else:
return [
dcc.Graph(
figure=go.Figure(data=plotdata,
layout=self.default_xas_layout),
config={"displayModeBar": False},
)
]
def information_dialog(self) -> html.Div:
title = "Plugin and 'check_swatinit' information"
return html.Div(
style={"margin-bottom": "30px"},
children=[
html.Button(
title,
style={
"width": "100%",
"background-color": "white"
},
id=self.get_uuid("info-button"),
),
wcc.Dialog(
title=title,
id=self.get_uuid("info-dialog"),
max_width="md",
open=False,
children=dcc.Markdown(check_swatinit_description()),
),
],
)
def test_mkdw010_mathjax_with_html(dash_dcc):
app = Dash(__name__)
CONTENT = [
"""
<details>
<summary>Topic</summary>
Some details
</details>
$E = mc^2$
""",
"""
<p>Some paragraph</p>
$E = mc^2$
""",
"""
<p>Some paragraph</p>
$E = mc^2$
""",
"""
<p>Some paragraph</p> $E = mc^2$
""",
"""
<p>Some paragraph with $E = mc^2$ inline math</p>
""",
]
app.layout = html.Div(
[dcc.Markdown(c, dangerously_allow_html=True, mathjax=True) for c in CONTENT]
)
dash_dcc.start_server(app)
dash_dcc.wait_for_element(".MathJax")
assert len(dash_dcc.find_elements((".MathJax"))) == len(CONTENT)
def blueprints():
return dcc.Markdown("""
**Dash/SPA** supports Flask style Blueprints and route decorators:
```
from dash import html
from dash_spa import Blueprint
greetings = Blueprint('greetings')
@greetings.route('/hello')
def hello():
return html.H2('Dash/SPA say's HELLO!')
@greetings.route('/goodby')
def goodby():
return html.H2('Dash/SPA say's GOODBY!')
...
app.register_blueprint(greetings, url_prefix='/test/greetings')
```
""")
