def gen_report_with_files(datadir: Path,
single_file: bool = False) -> dp.Report:
# Asset tests
lis = [1, 2, 3]
df = gen_df(10000)
md_block = dp.Markdown(
text="# Test markdown block <hello/> \n Test **content**")
list_asset = dp.File(data=lis, name="List Asset", is_json=True)
img_asset = dp.File(file=datadir / "datapane-logo.png")
plot_asset = dp.Plot(data=alt.Chart(gen_df()).mark_line().encode(x="x",
y="y"),
caption="Plot Asset")
df_asset = dp.Table(df=df, caption="Test Dataframe Table")
pivot_asset = dp.Table(df=df,
caption="Test Dataframe PivotTable",
can_pivot=True)
if single_file:
return dp.Report(dp.Blocks([md_block, plot_asset]))
else:
return dp.Report(list_asset, img_asset, df_asset, md_block, plot_asset,
pivot_asset)
def gen_report_complex_with_files(datadir: Path,
single_file: bool = False,
local_report: bool = False) -> dp.Report:
# Asset tests
lis = [1, 2, 3]
small_df = gen_df()
big_df = gen_df(10000)
# text
# md_block
html_block = dp.HTML(html="<h1>Hello World</h1>")
html_block_1 = dp.HTML(html=h2("Hello World"))
code_block = dp.Code(code="print('hello')", language="python")
formula_block = dp.Formula(formula=r"\frac{1}{\sqrt{x^2 + 1}}")
big_number = dp.BigNumber(heading="Tests written", value=1234)
big_number_1 = dp.BigNumber(heading="Real Tests written :)",
value=11,
change=2,
is_upward_change=True)
embed_block = dp.Embed(url="https://www.youtube.com/watch?v=JDe14ulcfLA")
# assets
plot_asset = dp.Plot(data=gen_plot(), caption="Plot Asset")
list_asset = dp.File(data=lis, filename="List Asset", is_json=True)
img_asset = dp.File(file=datadir / "datapane-logo.png")
# tables
table_asset = dp.Table(data=small_df, caption="Test Basic Table")
# local reports don't support DataTable
dt_asset = table_asset if local_report else dp.DataTable(
df=big_df, caption="Test DataTable")
if single_file:
return dp.Report(dp.Group(blocks=[md_block, dt_asset]))
else:
return dp.Report(
dp.Page(
dp.Select(md_block,
html_block,
html_block_1,
code_block,
formula_block,
embed_block,
type=dp.SelectType.TABS),
dp.Group(big_number, big_number_1, columns=2),
),
dp.Page(
plot_asset,
list_asset,
img_asset,
table_asset,
dt_asset,
),
)
def __test_gen_report_id_check():
"""Test case unused atm"""
# all fresh
report = dp.Report(md_block, md_block, md_block)
assert_report(report) # expected_id_count=5)
# 2 fresh
report = dp.Report(md_block, md_block_id, md_block)
assert_report(report) # expected_id_count=4)
# 0 fresh
report = dp.Report(md_block_id, dp.Text("test", name="test-2"))
assert_report(report) # expected_id_count=2)
def test_gen_report_primitives(datadir: Path):
# check we don't allow arbitary python primitives - must be pickled directly via dp.File
with pytest.raises(DPError):
_ = dp.Report([1, 2, 3])
report = dp.Report(
"Simple string Markdown #2", # Markdown
gen_df(), # Table
gen_plot(), # Plot
datadir / "datapane-logo.png", # File
)
assert_report(report, 3)
assert glom(report, ("pages.0.blocks.0.blocks", ["_tag"])) == [
"Text", "Table", "Plot", "File"
]
def test_complex_df_report():
"""Test our dataframe importing with types of DFs user's upload"""
tz_df = convert_csv_pd("""
date,datetime,datetime_tz
2017-01-10,2017-01-21T23:10:24,2020-03-23T00:00:00.000Z
2017-01-11,2017-01-23T23:01:24,2020-04-23T00:00:00.000Z
""")
raw_data = {
"first_name": ["Jason", "Molly", "Tina", "Jake", "Amy"],
"last_name": ["Miller", "Jacobson", "Ali", "Milner", "Cooze"],
"age": [42, 52, 36, 24, 73],
"preTestScore": [4, 24, 31, 2, 3],
"postTestScore": [25, 94, 57, 62, 70],
}
index_df = pd.DataFrame(raw_data,
columns=[
"first_name", "last_name", "age",
"preTestScore", "postTestScore"
])
df_desc = index_df.describe()
df_desc_2 = df_desc.reset_index()
tz_t = dp.Table(tz_df)
index_t = dp.Table(index_df)
df_desc_t = dp.Table(df_desc)
df_desc_2_t = dp.Table(df_desc_2)
with deletable(dp.Report(tz_t, index_t, df_desc_t,
df_desc_2_t)) as dp_report:
dp_report.publish(name=gen_name())
def discrim_html_output_datapane(self, ProcDiscrim, fileName):
"""Création d'un reporting en format HTML pour la méthode PROC DISCRIM
grâce à la librairie datapane.
Paramètres
----------
ProcDiscrim : objet LinearDiscriminantAnalysis
objet suite à appel de la fonction fit() de la classe
LinearDiscriminantAnalysis
fileName : string
nom du fichier de sortie (avec ou sans .html)
"""
if fileName[-5:] != ".html":
fileName += ".html"
ProcDiscrim._stats_dataset()
ProcDiscrim._stats_classes()
ProcDiscrim._stats_pooled_cov_matrix()
ProcDiscrim._stats_wilks()
report = dp.Report(
dp.Text("# Linear Discriminant Analysis"),
dp.Text("## General information about the data"),
dp.Table(ProcDiscrim.infoDataset),
dp.Table(ProcDiscrim.infoClasses),
dp.Text("## Informations on the covariance matrix"),
dp.Table(ProcDiscrim.W),
dp.Table(ProcDiscrim.infoCovMatrix),
dp.Text("## Function of lda and its' intercept "
"and coefficients"),
dp.Table(ProcDiscrim.infoFuncClassement),
dp.Text("## Statistics. Wilks' Lambda"),
dp.Table(ProcDiscrim.infoWilksStats))
report.save(path=fileName)
def gen_report_complex_no_files() -> dp.Report:
"""Generate a complex layout report with simple elements"""
select = dp.Select(blocks=[md_block, md_block], type=dp.SelectType.TABS)
group = dp.Group(md_block, md_block, columns=2)
return dp.Report(
dp.Page(
blocks=[
dp.Group(md_block, md_block, columns=2),
dp.Select(blocks=[md_block, group],
type=dp.SelectType.DROPDOWN),
],
title="Page Uno",
),
dp.Page(
blocks=[
dp.Group(select, select, columns=2),
dp.Select(blocks=[md_block, md_block, md_block],
type=dp.SelectType.TABS),
],
title="Page Duo",
),
dp.Page(
blocks=[
dp.Group(group, group, columns=2),
dp.Select(blocks=[select, select], type=dp.SelectType.TABS),
],
title="Page Tres",
),
)
def test_gen_report_nested_blocks():
s = "# Test markdown block <hello/> \n Test **content**"
report = dp.Report(blocks=[
dp.Group(dp.Text(s, name="test-id-1"),
"Simple string Markdown",
label="test-group-label"),
dp.Select(
blocks=[
dp.Text(s, name="test-id-2", label="test-block-label"),
"Simple string Markdown",
],
label="test-select-label",
),
])
# No additional wrapper block
assert len(report.pages[0].blocks) == 2
assert isinstance(report.pages[0].blocks[0], dp.Group)
assert isinstance(report.pages[0].blocks[1], dp.Select)
assert isinstance(report.pages[0].blocks[1].blocks[1], dp.Text)
assert glom(report, ("pages.0.blocks", ["_attributes.label"])) == [
"test-group-label", "test-select-label"
]
assert glom(report, "pages.0.blocks.0.blocks.0.name") == "test-id-1"
assert glom(
report,
"pages.0.blocks.1.blocks.0._attributes.label") == "test-block-label"
assert_report(report, 0)
def test_full_report(tmp_path: Path):
df = gen_df()
name = gen_name()
description = gen_description()
source_url = "https://github.com/datapane/datapane"
# create a basic report
m = dp.Text("hello world!!")
# Asset tests
lis = [1, 2, 3]
json_list: str = json.dumps(lis)
plot = gen_plot()
# create the DP
fn = tmp_path / "json_list.json"
fn.write_text(data=json_list)
file_asset = dp.File(file=fn)
json_asset = dp.File(data=json_list, is_json=True)
plot_asset = dp.Plot(data=plot)
list_asset = dp.File(data=lis, is_json=True)
df_asset = dp.DataTable(df=df, caption="Our Dataframe")
dp_report = dp.Report(m, file_asset, df_asset, json_asset, plot_asset, list_asset)
dp_report.upload(name=name, description=description, source_url=source_url)
with deletable(dp_report):
# are the fields ok
check_name(dp_report, name)
assert dp_report.description == description
assert dp_report.source_url == source_url
assert len(dp_report.pages[0].blocks[0].blocks) == 6
def test_complex_df_report():
"""Test our dataframe importing with types of DFs user's upload"""
tz_df = pd.DataFrame(
dict(
duration_col=[timedelta(seconds=x) for x in range(30)],
date_col=[date.today() for _ in range(30)],
datetime_col=[datetime.utcnow() for _ in range(30)],
datetimez_col=[datetime.now(timezone.utc) for _ in range(30)],
)
)
raw_data = {
"first_name": ["Jason", "Molly", "Tina", "Jake", "Amy"],
"last_name": ["Miller", "Jacobson", "Ali", "Milner", "Cooze"],
"age": [42, 52, 36, 24, 73],
"preTestScore": [4, 24, 31, 2, 3],
"postTestScore": [25, 94, 57, 62, 70],
}
index_df = pd.DataFrame(raw_data, columns=["first_name", "last_name", "age", "preTestScore", "postTestScore"])
df_desc = index_df.describe()
df_desc_2 = df_desc.reset_index()
tz_t = dp.DataTable(tz_df)
index_t = dp.DataTable(index_df)
df_desc_t = dp.DataTable(df_desc)
df_desc_2_t = dp.DataTable(df_desc_2)
with deletable(dp.Report(tz_t, index_t, df_desc_t, df_desc_2_t)) as dp_report:
dp_report.upload(name=gen_name())
def LoadReport(title, X, Y, prediccion, anios):
""" Función de utilidad para generar el reporte en Datapane. Crea una tabla
que contiene los valores de las predicciones, así como las métricas con las
que se evalúan los modelos. También contiene una gráfica de puntos con los
valores de la predicción.
Args:
title (str): titulo del reporte de datapane.
X (:obj: `numpy.array`): datos reales de prueba.
Y (:obj: `numpy.array`): datos reales de predicción.
prediccion (:obj: `numpy.array`): datos predichos.
anios (int): número de años que se predijeron.
Returns:
(:obj: `datapane.Report`): reporte de datapane listo para publicar o guardar.
"""
anios_ = [1998 + i for i in range(len(X))]
n1 = len(anios_)
anios_ += [1997 + len(X) + i for i in range(len(Y) + 1)]
n2 = len(anios_) - n1
anios_ += [1997 + len(X) + i for i in range(len(Y) + 1)]
n3 = len(anios_) - n2 - n1
series = ['Datos de entrenamiento'] * n1
series += ['Datos de prueba'] * n2
series += ['Datos predichos'] * n3
alumnos = list(X)
alumnos += (list(X) + list(Y))[-(anios + 1):]
alumnos += (list(X) + list(prediccion))[-(anios + 1):]
df = pd.DataFrame(data={
'Serie': series,
'Año': anios_,
'Alumnos': alumnos
})
columns = ['Año %d' % (i) for i in range(1, anios + 1)]
columns += ['MAPE', 'MAE', 'RMSE']
metricas = np.zeros(3)
# MAPE
metricas[0] = np.abs((prediccion - Y) / Y).mean()
# MAE
metricas[1] = np.abs(prediccion - Y).mean()
# RMSE
metricas[2] = np.sqrt(np.square(prediccion - Y).mean())
metricas = pd.DataFrame(np.array([list(prediccion) + list(metricas)]),
columns=columns)
# Crear grafica
chart = alt.Chart(df).mark_line().encode(
x='Año', y='Alumnos', color='Serie').mark_line(
point=True).interactive().properties(title=title)
# Crear reporte
reporte = dp.Report(dp.Table(metricas), dp.Plot(chart))
return reporte
def gen_report_with_files(datadir: Path,
single_file: bool = False) -> dp.Report:
# Asset tests
lis = [1, 2, 3]
small_df = gen_df()
big_df = gen_df(10000)
# text
md_block = dp.Markdown(
text="# Test markdown block </hello> \n Test **content**")
html_block = dp.HTML(html="Hello World</hello>")
big_number = dp.BigNumber(heading="Tests written", value=1234)
big_number_1 = dp.BigNumber(heading="Real Tests written :)",
value=11,
change=2,
is_upward_change=True)
# assets
plot_asset = dp.Plot(data=alt.Chart(gen_df()).mark_line().encode(x="x",
y="y"),
caption="Plot Asset")
list_asset = dp.File(data=lis, name="List Asset", is_json=True)
img_asset = dp.File(file=datadir / "datapane-logo.png")
# tables
table_asset = dp.Table(data=small_df, caption="Test Basic Table")
dt_asset = dp.DataTable(df=big_df, caption="Test DataTable")
dt_pivot_asset = dp.DataTable(df=big_df,
caption="Test DataTable with Pivot",
can_pivot=True)
if single_file:
return dp.Report(dp.Blocks(blocks=[md_block, plot_asset]))
else:
return dp.Report(
md_block,
html_block,
big_number,
big_number_1,
plot_asset,
list_asset,
img_asset,
table_asset,
dt_asset,
dt_pivot_asset,
)
def publish(
self,
name="Folium Map",
description="",
source_url="",
visibility="DEFAULT",
open=True,
tags=None,
**kwargs,
):
"""Publish the map to datapane.com
Args:
name (str, optional): The document name - can include spaces, caps, symbols, etc., e.g. "Profit & Loss 2020". Defaults to "Folium Map".
description (str, optional): A high-level description for the document, this is displayed in searches and thumbnails. Defaults to ''.
source_url (str, optional): A URL pointing to the source code for the document, e.g. a GitHub repo or a Colab notebook. Defaults to ''.
visibility (str, optional): Visibility of the map. It can be one of the following: PORTFOLIO, PRIVATE, DEFAULT. Defaults to 'DEFAULT'.
open (bool, optional): Whether to open the map. Defaults to True.
tags (bool, optional): A list of tags (as strings) used to categorise your document. Defaults to None.
"""
import webbrowser
try:
import datapane as dp
except Exception:
webbrowser.open_new_tab(
"https://docs.datapane.com/tut-getting-started")
raise ImportError(
"The datapane Python package is not installed. You need to install and authenticate datapane first."
)
try:
visibility = visibility.upper()
if visibility not in ["DEFAULT", "PRIVATE", "PORTFOLIO"]:
raise ValueError(
"The visibility argument must be either DEFAULT or PRIVATE or PORTFOLIO."
)
if visibility == "PRIVATE":
visibility = dp.Visibility.PRIVATE
elif visibility == "PORTFOLIO":
visibility = dp.Visibility.PORTFOLIO
else:
visibility = dp.Visibility.DEFAULT
dp.Report(dp.Plot(self)).upload(
name=name,
description=description,
source_url=source_url,
visibility=visibility,
open=open,
tags=tags,
)
except Exception as e:
raise Exception(e)
def test_gen_failing_reports():
# local reports with unsupported elements
with pytest.raises(DPError):
r = dp.Report(dp.DataTable(gen_df()))
r._gen_report(embedded=True, title="TITLE", description="DESCRIPTION")
# nested pages
with pytest.raises((DocumentInvalid, DPError)):
r = dp.Report(dp.Page(dp.Page(md_block)))
r._gen_report(embedded=False, title="TITLE", description="DESCRIPTION")
with pytest.raises((DocumentInvalid, DPError)):
r = dp.Report(dp.Group(dp.Page(md_block)))
r._gen_report(embedded=False, title="TITLE", description="DESCRIPTION")
# group with 0 object
with pytest.raises((DocumentInvalid, DPError)):
r = dp.Report(dp.Page(dp.Group(blocks=[])))
r._gen_report(embedded=False, title="TITLE", description="DESCRIPTION")
# select with 1 object
with pytest.raises((DocumentInvalid, DPError)):
r = dp.Report(dp.Page(dp.Select(blocks=[md_block])))
r._gen_report(embedded=False, title="TITLE", description="DESCRIPTION")
# empty text block
with pytest.raises((AssertionError, DocumentInvalid, DPError)):
r = dp.Report(dp.Text(" "))
r._gen_report(embedded=False, title="TITLE", description="DESCRIPTION")
# empty df
with pytest.raises((AssertionError, DocumentInvalid, DPError)):
r = dp.Report(dp.DataTable(pd.DataFrame()))
r._gen_report(embedded=False, title="TITLE", description="DESCRIPTION")
def gen_report_nested_mixed() -> dp.Report:
return dp.Report(
dp.Blocks(
dp.Markdown(
text="# Test markdown block <hello/> \n Test **content**",
id="test-id-1"),
"Simple string Markdown",
),
"Simple string Markdown #2",
)
def publish_report(df: pandas.DataFrame):
dp_token: str = db["DP_TOKEN"]
dp.login(token=dp_token)
plot = alt.Chart(df).mark_area(opacity=0.4, stroke='black').encode(
x='date:T',
y=alt.Y('new_cases_smoothed_per_million:Q', stack=None),
color=alt.Color('continent:N', scale=alt.Scale(scheme='set1')),
tooltip='continent:N').interactive().properties(width='container')
dp.Report(dp.Plot(plot), dp.DataTable(df)).save(path='report.html',open=True)
def test_add_footer():
text = "FOOTER"
r = dp.Report(blocks=[dp.Page(md_block, md_block) for _ in range(3)])
r1 = dp.templates.add_footer(r, footer=text, all_pages=True)
assert_report(r1, 0, 18)
assert glom(r1, ("pages", ["blocks.0.blocks.-1.content"])) == [text, text, text]
r1 = dp.templates.add_footer(r, footer=text, all_pages=False)
assert_report(r1, 0, 14)
assert glom(r1, ("pages", ["blocks.0.blocks.-1.content"])) == [text, md_block.content, md_block.content]
def plot_planning(planning, need, timeline):
# Plot graph - Requirement
source = need.copy()
source = source.rename(columns={0: "Hours"})
source["Date"] = source.index
bars_need = (alt.Chart(source).mark_bar().encode(
y="Hours:Q",
column=alt.Column("Date:N"),
tooltip=["Date", "Hours"],
).interactive().properties(
width=550 / len(timeline) - 22,
height=75,
title='Requirement',
))
# Plot graph - Optimized planning
source = planning.filter(like="Total hours", axis=0).copy()
source["Date"] = list(source.index.values)
source = source.rename(columns={"Solution": "Hours"}).reset_index()
source[["Date", "Line"]] = source["Date"].str.split(",", expand=True)
source["Date"] = source["Date"].str.split("[").str[1]
source["Line"] = source["Line"].str.split("]").str[0]
source["Min capacity"] = 7
source["Max capacity"] = 12
source = source.round({"Hours": 1})
source["Load%"] = pd.Series(
["{0:.0f}%".format(val / 8 * 100) for val in source["Hours"]],
index=source.index,
)
bars = (alt.Chart(source).mark_bar().encode(
x="Line:N",
y="Hours:Q",
column=alt.Column("Date:N"),
color="Line:N",
tooltip=["Date", "Line", "Hours", "Load%"],
).interactive().properties(
width=550 / len(timeline) - 22,
height=150,
title="Optimized Production Schedule",
))
chart = alt.vconcat(bars, bars_need)
chart.save("planning_time_model2.html")
dp.Report(dp.Plot(
chart, caption="Production schedule model 2 - Time")).publish(
name="Optimized production schedule model 2 - Time",
description="Optimized production schedule model 2 - Time",
open=True,
visibily="PUBLIC",
)
def publish(
self,
name=None,
headline="Untitled",
visibility="PUBLIC",
overwrite=True,
open=True,
):
"""Publish the map to datapane.com
Args:
name (str, optional): The URL of the map. Defaults to None.
headline (str, optional): Title of the map. Defaults to 'Untitled'.
visibility (str, optional): Visibility of the map. It can be one of the following: PUBLIC, PRIVATE, ORG. Defaults to 'PUBLIC'.
overwrite (bool, optional): Whether to overwrite the existing map with the same name. Defaults to True.
open (bool, optional): Whether to open the map. Defaults to True.
"""
import webbrowser
try:
import datapane as dp
except Exception:
webbrowser.open_new_tab(
"https://docs.datapane.com/tutorials/tut-getting-started")
raise ImportError(
"The datapane Python package is not installed. You need to install and authenticate datapane first."
)
# import datapane as dp
# import logging
# logging.getLogger('googleapiclient.discovery_cache').setLevel(logging.ERROR)
try:
if name is None:
name = "folium_" + random_string(6)
visibility = visibility.upper()
if visibility not in ["PUBLIC", "PRIVATE", "ORG"]:
visibility = "PRIVATE"
if overwrite:
delete_dp_report(name)
report = dp.Report(dp.Plot(self))
report.publish(name=name,
headline=headline,
visibility=visibility,
open=open)
except Exception as e:
print(e)
def test_gen_report_nested_mixed():
report = dp.Report(
dp.Group(
md_block_id,
str_md_block,
),
"Simple string Markdown #2",
)
assert_report(report, 0)
assert len(glom(report, "pages.0.blocks")) == 1
assert isinstance(glom(report, "pages.0.blocks.0"), dp.Group)
assert isinstance(report.pages[0].blocks[0].blocks[0], dp.Group)
assert isinstance(report.pages[0].blocks[0].blocks[1], dp.Text)
assert report.pages[0].blocks[0].blocks[0].blocks[0].name == "test-id-1"
def publish(
self,
name="Folium Map",
description="",
source_url="",
tags=None,
source_file=None,
open=True,
formatting=None,
**kwargs,
):
"""Publish the map to datapane.com
Args:
name (str, optional): The document name - can include spaces, caps, symbols, etc., e.g. "Profit & Loss 2020". Defaults to "Folium Map".
description (str, optional): A high-level description for the document, this is displayed in searches and thumbnails. Defaults to ''.
source_url (str, optional): A URL pointing to the source code for the document, e.g. a GitHub repo or a Colab notebook. Defaults to ''.
tags (bool, optional): A list of tags (as strings) used to categorise your document. Defaults to None.
source_file (str, optional): Path of jupyter notebook file to upload. Defaults to None.
open (bool, optional): Whether to open the map. Defaults to True.
formatting (ReportFormatting, optional): Set the basic styling for your report.
"""
import webbrowser
try:
import datapane as dp
except Exception:
webbrowser.open_new_tab("https://docs.datapane.com/tut-getting-started")
raise ImportError(
"The datapane Python package is not installed. You need to install and authenticate datapane first."
)
try:
dp.Report(dp.Plot(self)).upload(
name=name,
description=description,
source_url=source_url,
tags=tags,
source_file=source_file,
open=open,
formatting=formatting,
)
except Exception as e:
raise Exception(e)
def run(db_url):
engine = Engine(db_url)
graph_posts_per_day = process_posts_per_day(engine)
post_per_day_caption = (
f"Number of posts updated per day (updated {get_current_time_in_vietname()})"
)
df_posts_per_domain = process_posts_per_domain(engine)
df_domain_sim, graph_domain_sim_score = process_sim_score_table(engine)
report = dp.Report(
dp.Plot(graph_posts_per_day, caption=post_per_day_caption),
dp.DataTable(df_posts_per_domain,
caption="Number of posts per domain"),
dp.DataTable(df_domain_sim, caption="Simplified similar_docs table"),
dp.Plot(graph_domain_sim_score,
caption="Similarity score histogram (>= 0.5)"),
)
report.publish(name="TopDup monitoring table", open=False)
print("View report at "
"https://datapane.com/u/tiepvupsu/reports/topdup-monitoring-table/")
r = dp.Report(
dp.Page(
label='Introduction',
blocks=[
dp.HTML(html),
"The data has been compiled over 3 semesters, for the introductory computer science class CSE 1223.",
dp.Group(dp.BigNumber(heading="Number of Students",
value=num_students),
dp.BigNumber(heading="Class Average",
value=str(class_average) + "%",
change="2%",
is_upward_change=True),
columns=2),
dp.BigNumber(heading="Pass Rate", value=str(pass_rate) + "%"),
]),
dp.Page(label='Deliverables',
blocks=[
f'### Labs',
dp.Plot(lab_bar), f'### Homeworks',
dp.Plot(hw_bar), f'### Projects',
dp.Plot(project_bar)
]),
dp.Page(label='Exam Grades',
blocks=[f'### Kernel Density Plot ',
dp.Plot(exams_kdp)]),
dp.Page(label='Final Grades',
blocks=[
f'### Comparing Final Grade Data ',
dp.Plot(fg_hist),
dp.Plot(letter_pie)
]),
dp.Page(
dp.Select(blocks=[
dp.Plot(sex_bar, label='Sex-Bar Chart'),
dp.Plot(urm_bar, label='URM-Bar Chart'),
dp.Plot(race_bar, label='Race-Bar Chart'),
dp.Plot(sex_kdp, label='Sex-KDP')
],
type=dp.SelectType.DROPDOWN),
label='Demographics',
#blocks=[f'### Comparing Final Grade Data among Various Demographics']
))
def gen_report_simple() -> dp.Report:
return dp.Report(blocks=[
dp.Markdown(text="# Test markdown block <hello/> \n Test **content**",
id="test-id-1"),
"Simple string Markdown",
])
import os
import pandas as pd
import datapane as dp
# basic report creation, with params
df = pd.DataFrame.from_dict({"x": [4, 3, 2, 1], "y": [10.5, 20.5, 30.5, 40.5]})
blocks = [dp.Text(f"Dummy Markdown block - {dp.Params['p1']}"), dp.DataTable(df), dp.Text(f"Text block with env var: {os.environ['ENV_VAR']}")]
# test running as main or by datapane runner
if dp.ON_DATAPANE:
print("on datapane")
if __name__ == "__datapane__": # same as dp.by_datapane
print("by datapane")
report = dp.Report(blocks=blocks)
report.upload(name="dp_report", description="Description")
yevents1 = EventCollection(ydata1, color='tab:blue', linelength=0.05,
orientation='vertical')
yevents2 = EventCollection(ydata2, color='tab:orange', linelength=0.05,
orientation='vertical')
ax.add_collection(xevents1)
ax.add_collection(xevents2)
ax.add_collection(yevents1)
ax.add_collection(yevents2)
ax.set_xlim([0, 1])
ax.set_ylim([0, 1])
ax.set_title('line plot with data points')
mpl_asset = dp.Plot(mpl_fig)
# Report
report = dp.Report(
list_asset,
df_asset,
md_block,
vega_asset,
pv_asset,
img_asset,
file_asset,
bokeh_asset,
plotly_asset,
folium_asset,
mpl_asset
)
report.save(path="local_xml_report.html")
report.publish(name="xml_report")
"""{{ name }} report"""
import altair as alt
import pandas as pd
import datapane as dp
# get the data
dataset = pd.read_csv(
"https://covid.ourworldindata.org/data/owid-covid-data.csv")
df = dataset.groupby(
["continent",
"date"])["new_cases_smoothed_per_million"].mean().reset_index()
# build an altair plot
plot = alt.Chart(df).mark_area(opacity=0.4, stroke='black').encode(
x='date:T',
y=alt.Y('new_cases_smoothed_per_million:Q', stack=None),
color=alt.Color('continent:N', scale=alt.Scale(scheme='set1')),
tooltip='continent:N').interactive().properties(width='container')
# embed data and plot into a Datapane report and publish
report = dp.Report("## Covid data per continent", dp.Plot(plot), dp.Table(df))
report.publish(
name="Covid Demo {{ name }}",
description=
"Plot of Covid infections per continent, using data from ourworldindata",
open=True,
)
ax.plot(xdata2, ydata2, color='tab:orange')
xevents1 = EventCollection(xdata1, color='tab:blue', linelength=0.05)
xevents2 = EventCollection(xdata2, color='tab:orange', linelength=0.05)
yevents1 = EventCollection(ydata1,
color='tab:blue',
linelength=0.05,
orientation='vertical')
yevents2 = EventCollection(ydata2,
color='tab:orange',
linelength=0.05,
orientation='vertical')
ax.add_collection(xevents1)
ax.add_collection(xevents2)
ax.add_collection(yevents1)
ax.add_collection(yevents2)
ax.set_xlim([0, 1])
ax.set_ylim([0, 1])
ax.set_title('line plot with data points')
mpl_asset = dp.Plot(mpl_fig)
# Report
blocks = [
list_asset, df_table_asset, md_block, vega_asset, img_asset, file_asset,
bokeh_asset, plotly_asset, folium_asset, mpl_asset
]
dp.Report(blocks=blocks).save(path="local_xml_report.html")
# add datatable
blocks.append(df_datatable_asset)
dp.Report(blocks=blocks).upload(name="xml_report")
name='PDF',
line=dict(color='#ffc93c', width=2.5)),
row=1,
col=1)
fig.add_trace(go.Scatter(x=values,
y=cdfproba,
name='CDF',
line=dict(color='#ffc93c', width=2.5)),
row=1,
col=2)
fig.update_layout(plot_bgcolor='#0f4c75')
fig.update_xaxes(showgrid=False)
fig.update_yaxes(showgrid=False)
report = dp.Report(dp.Plot(fig)) #Create a report
report.publish(name='my_plot', open=True,
visibility='PUBLIC') #Publish the report
# In[2]:
import numpy as np
from plotly.subplots import make_subplots
import plotly.graph_objects as go
from scipy.stats import norm
import warnings
warnings.filterwarnings('ignore')
warnings.simplefilter('ignore')
values = np.linspace(-3, 3, num=101)
def gen_report_simple() -> dp.Report:
return dp.Report(blocks=[
md_block_id,
str_md_block,
])
