def root():
print(
render_template('diagrams/root.html',
resources=CDN.render(),
prefix=uri_prefix))
return render_template('diagrams/root.html',
resources=CDN.render(),
prefix=uri_prefix)
def show_plot():
time_chooser = TimeForm.TimeForm(request.form)
# By default show the last 72 hours of data
interval = 72
if time_chooser.validate_on_submit():
#if time_chooser.the_time.data != 'all':
interval = time_chooser.the_time.data
current_app.logger.info('interval is %s', interval)
current_app.logger.info('interval is %s', interval)
# Get interval
now = datetime.datetime.now()
datetime_1 = (
now - datetime.timedelta(hours=interval)).strftime('%Y-%m-%d %H:%M:%S')
datetime_2 = now.strftime('%Y-%m-%d %H:%M:%S')
plot_script, plot_div = make_range_plot(datetime_1, datetime_2)
# CDN.render() has all of the information to get the javascript libraries
# for Bokeh to work, loaded from a cdn somewhere.
return render_template('temp_graph.html',
plot_div=plot_div,
plot_script=plot_script,
resources=CDN.render(),
form=time_chooser)
def root():
# get data
fixed_url = 'https://www.alphavantage.co/query?function=TIME_SERIES_DAILY&outputsize=compact&apikey=69N0R6WUDFW63EKD'
ticker = dict(symbol=app.user_input['ticker'])
try:
tdata = requests.get(url=fixed_url, params=ticker)
# format data
tdata_dict = tdata.json()
tdata_df = pd.DataFrame(tdata_dict['Time Series (Daily)'])
tdata_df = tdata_df.transpose()
tdata_df = tdata_df[['1. open', '4. close']]
tdata_df.columns = ['open', 'close']
tdata_df['open'] = tdata_df['open'].astype(float)
tdata_df['close'] = tdata_df['close'].astype(float)
# set data
app.tdata = tdata_df
app.user_input['req_fail'] == 'False'
return render_template('plot_page.html', resources=CDN.render())
except:
app.user_input['req_fail'] == 'True'
return redirect('/cantshow')
def savePlot(path, filename, country, r, cases, deaths, curve):
p = figure(plot_height=350, plot_width=500, title=country, x_axis_label='Days (since 100 cases)', y_axis_label='',
toolbar_location='right', tools = "hover",
y_range=Range1d(0, int(1.05*max(cases)), bounds="auto"), x_range=Range1d(0, int(1.05*max(r)), bounds="auto"))
hover = p.select(dict(type=HoverTool))
hover.tooltips = [
('People', '$y'),
('Days (since 100 cases)' , '$index')
]
p.vbar(r, top=cases, width=0.9, legend_label="Daily Cases", color = 'orange')
p.vbar(r, top=deaths, width=0.9, legend_label="Daily Deaths", color = 'red', )
p.line(r, curve, legend_label="Predicted Curve", line_width=2, line_color = 'red')
script_bokeh, div_bokeh = components(p)
resources_bokeh = CDN.render()
html = template.render(resources=resources_bokeh,
script=script_bokeh,
div=div_bokeh)
out_file_path = path + filename
with io.open(out_file_path, mode='w') as f:
f.write(html)
def submit_tick():
# Save the form responses to the appvars attribute.
appvars = {}
appvars['start_date'] = request.form.get('start_date')
appvars['end_date'] = request.form.get('end_date')
appvars['stock_code'] = request.form.get('stock_code')
try:
# Retrieve ticker data, create plot
tr = ticker_retrieval(appvars['stock_code'], appvars['start_date'],
appvars['end_date'], quandl_key)
tr.get_ticker_data()
p = tr.create_plot()
# Stuff for embedding bokeh plot in webpage.
script, div = components(p)
except:
# If data retrieval was unsuccessful, print an error in place of the plot!
script = ""
div = r"<div><p>Error! Stock code was entered incorrectly OR data is unavailable for the entered stock.</p></div>"
return render_template('index.html',
script=script,
div=div,
bokeh_resources=CDN.render(),
st_date=appvars['start_date'],
ed_date=appvars['end_date'],
scode=appvars['stock_code'])
def index(search=None, num_videos = 0, **kwargs):
print('/')
return render_template("index.html",
resources=CDN.render(),
num_videos = num_videos,
**kwargs
)
def srd(): response=make_response(page2.render(resources=CDN.render())) response.headers['Access-Control-Allow-Origin'] = '*' response.headers['Access-Control-Allow-Methods'] = 'OPTIONS,HEAD,GET,POST' response.headers['Access-Control-Allow-Headers'] = 'x-requested-with' return response
def data():
# Solution to url_for in template not recognized: https://stackoverflow.com/questions/20843085/url-for-is-not-defined-in-flask
main_url = url_for('main')
logout_url = url_for('logout')
if session['logged_in'] == True:
return page.render(main_url=main_url, logout_url=logout_url, resources=CDN.render())
else:
return redirect(url_for('shop_login'))
def crypto(request):
if request.user.is_authenticated:
user = request.user
else:
user = False
# do we have session data stored (avoiding too many api calls)
try:
print("Last data retrieved: ", request.session["timestamp"])
except KeyError:
request.session["timestamp"] = 0
# sorting commands received in url or default
try:
sort_by = request.GET["sort_by"]
except KeyError:
sort_by = None
coin_list, coin_data, market_data = retrieve_data_session_or_new_api(
request)
# sort data if needed (default order is by market_cap)
if sort_by:
print(f"Sorting data by {sort_by}...")
rev_order = True
if sort_by in ['symbol', 'name']:
rev_order = False
try:
coin_data.sort(key=lambda x: x[sort_by], reverse=rev_order)
except KeyError:
print("Error sorting data!")
resources = CDN.render()
time_options = timeList.keys()
currency_options = currencyList.keys()
return render(
request, "cryptoweb/crypto.html", {
'resources': CDN.render(),
'crypto_options': coin_list,
'user': user,
'time_options': time_options,
'currency_options': currency_options,
'coin_data': coin_data,
'market_data': market_data
})
def generate_sample_plot(h5file, dataset_path, dataset_index, dataset_name,
output_file, crt, cmz, plot_width, top_plot_height,
bottom_plot_height, use_global_max, global_max):
sp_set = dataset_path + '/sp'
if not (sp_set in h5file):
printlog('Error! sp not found in %s ! Skipping...' % (dataset_path))
return
sp = np.array(h5file[sp_set])
#sp_int = np.sum(sp, axis = 1);
crt = np.array(crt)
crt = crt / 60.0
top_plot = _make_top_rt_plot(
crt, sp, '%s. RT Integral profile, linear scale' % dataset_name,
plot_width, top_plot_height, use_global_max, global_max)
bottom_plot = _make_bottom_rt_plot(
crt, cmz, sp, '%s. Full profile, log scale' % dataset_name, plot_width,
bottom_plot_height, True, use_global_max, global_max)
#bottom_plot2 = _make_bottom_rt_plot(crt, cmz, sp, '%s. Full profile, linear scale'%dataset_name, plot_width, bottom_plot_height, False, use_global_max, global_max);
bottom_plot.x_range = top_plot.x_range
#bottom_plot2.x_range = top_plot.x_range;
#bottom_plot2.y_range = bottom_plot.y_range;
script, div = components(
gridplot([
[top_plot],
[bottom_plot],
#[bottom_plot2]
]))
with open(output_file, 'w') as fspec:
fspec.write('\n'.join([
'<!DOCTYPE html>',
'<html lang="en">',
' <head>',
' <meta charset="utf-8">',
' <title>RT Spectrum for all peaks</title>',
CDN.render(),
' <link href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">',
' </head>',
' <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>',
' <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js" integrity="sha384-Tc5IQib027qvyjSMfHjOMaLkfuWVxZxUPnCJA7l2mCWNIpG9mGCD8wGNIcPD7Txa" crossorigin="anonymous"></script>',
' <body>',
div,
' </body>',
script,
'<style>',
'</style>',
' </html>',
]))
def render_html_col() -> str:
"""Render any of the versions"""
# ip = request.ip.address
record_visit()
reload_tmpls()
x_tools = request.args.get("xt", "")
htmls = col.get_htmls()
return TMPLS['col'].render(resources=CDN.render(),
x_tools=x_tools,
**htmls)
def home(request):
temp = render_temperature_chart()
weather_data = get_weather_data()
pressao = render_pressao_chart()
context = {
'conditions': weather_data,
'temperature': temp,
'pressao': pressao,
'bokehcdn': CDN.render()
}
return render(request, 'home.html', context)
async def post(self, mode=None):
"""
Retrieve unique user login statistics. The optional ``mode`` operator
controls the output format. With mode ``raw`` the data is delivered
with the requested content type (html, csv, text or json).
Methods:
POST /usage/login - deliver results
Parameters:
start (str): inclusive lower bound
end (str): exclusive upper bound
aggregate (chr): daily (d), weekly (w), monthly (m), quarterly (q)
or yearly (y)
content_type (str): force json, html, text
Returns:
data element with list of aggregation time interval and count of
unique users who logged in
Raises:
401 Unauthorized:
Examples:
>>> GET http://devops:5001/usage/login?start=2017-01-01&aggregate=W
>>> GET http://devops:5001/usage/login/raw?content_type=json
"""
end = self.get_argument("end", as_type=datetime, default=now())
start = self.get_argument("start",
as_type=datetime,
default=end - timedelta(days=90))
aggregate = self.get_argument("aggregate", as_type=str, default="w")
if mode in ("plot", "raw"):
df = await self._query(start, end, aggregate)
if mode == "raw":
return self.reply(df)
x = df.timestamp
y = df.user
p = figure(title="unique users",
x_axis_label='week',
sizing_mode="stretch_both",
y_axis_label='logins',
x_axis_type="datetime")
p.line(x, y, line_width=4)
p.title.text = "core usage by users"
p.title.align = "left"
p.title.text_font_size = "25px"
return self.reply(json_item(p, "myplot"))
return self.render("templates/usage.html",
rsc=CDN.render(),
start=start.date(),
end=end.date(),
aggregate=aggregate)
def graph():
ticker = request.form.get('ticker')
print(ticker)
sdr = StockDataRetriever()
stock_df = sdr.get_stock_data_in_dataframe_daily(ticker)
boken_plotter = BokenPlotter(symbol=ticker, stock_df=stock_df)
stock_plot_js, stock_plot_div = boken_plotter.create_plot_components()
print(stock_plot_div)
return render_template('graph.html',
resources=CDN.render(),
stock_plot_script=stock_plot_js,
plot_div=stock_plot_div)
def root():
global holdFileName
global file
arr = os.listdir(app.config['UPLOADED_DATA_DEST'])
if request.method == 'POST':
holdFileName = request.form.get('set')
file = f'static/data/{holdFileName}'
return page.render(resources=CDN.render(),
selected=holdFileName,
arr=arr,
holdFileName=holdFileName,
file=file)
def acquisition_view(acquisition_id):
acquisition = db.session.query(AcquisitionModel).filter_by(
id=acquisition_id).first()
start = acquisition.frames[0]
end = acquisition.frames[-1]
return render_template('acquisition.html',
acq_start=start.id,
acq_end=end.id,
acq_count=len(acquisition.frames),
acquisition=acquisition,
resources=CDN.render())
def create_report(explanation, report_name, x_axis_label):
explanation_summary = visuals.summarize_explanation(explanation)
summary_waterfall = visuals.WaterfallChart(
baseline=explanation_summary['expected_value'],
shap_values=explanation_summary['shap_values'],
names=explanation_summary['feature_names'],
descriptions=explanation_summary['feature_descriptions'],
max_features=10,
x_axis_label=x_axis_label,
)
detailed_waterfall = visuals.WaterfallChart(
baseline=explanation['expected_value'],
shap_values=explanation['shap_values'],
names=explanation['feature_names'],
feature_values=explanation['feature_values'],
descriptions=explanation['feature_descriptions'],
max_features=10,
x_axis_label=x_axis_label)
script_summary, div_summary = components(summary_waterfall._figure)
script_detailed, div_detailed = components(detailed_waterfall._figure)
df = pd.DataFrame(explanation)
df = df[['feature_names', 'feature_values', 'shap_values']]
df = df.sort_values(by='shap_values')
table = df.to_html(
classes=['table', 'table-hover', 'table-sm', 'table-striped'],
index=False,
justify='left',
border=0)
with open(Path(reports_filepath, 'template', 'template.html')) as openfile:
template_html = openfile.read()
template = Template(template_html)
output_path = Path(reports_filepath, 'generated', report_name + '.html')
output_html = template.render(bokeh_js=CDN.render(),
script_summary=script_summary,
div_summary=div_summary,
script_detailed=script_detailed,
div_detailed=div_detailed,
table=table)
with open(output_path, "w") as openfile:
openfile.write(output_html)
return output_path
def generate_html():
env = Environment(loader=PackageLoader("dashboard", "templates"), )
template = env.get_template("index.html")
summary, regional, land_survey, scenarios = get_all_charts()
cdn = CDN.render()
html = template.render(
cdn=cdn,
summary=summary,
regional=regional,
land_survey=land_survey,
scenarios=scenarios,
)
return html
def predict():
input_val = [x for x in request.form.values()]
country = input_val[0]
# uncomment this line to deploy full APP
# model = input_val[1]
model = 'xgb'
prediction = test(country, model)
prediction = floor(prediction)
input_val = country.upper()
script, div = plot(input_val)
return render_template('prediction.html',
pred=f'{prediction}',
input_val=f'{input_val}',
script=script,
div=div,
resources=CDN.render())
def display_datasetAnalyzer():
printLogEntry("Running display_datasetAnalyzer()")
selectDatasetToAnalzerFormDetails = selectDatasetToAnalyzeForm()
selectDatasetToAnalzerFormDetails.datasetName.choices = getDatasetNames()
selectColumnToAnalyzeFormDetails = selectColumnToAnalyzeForm()
datasetDetails = {}
df = pd.DataFrame()
dfHtmlTableComponents = dataframeHtmlTableComponents(df)
df_preview_HtmlTableComponents = dataframeHtmlTableComponents(df)
datasets = DatasetManager.query.all()
if "submitDatasetToAnalyze" in request.form:
if selectDatasetToAnalzerFormDetails.validate_on_submit():
printLogEntry("Dataset to Analyze Form Submitted")
dataset_id = selectDatasetToAnalzerFormDetails.datasetName.data
datasetDetails = {}
datasetDetails = analyzeDataset(dataset_id, datasetDetails)
# print(datasetDetails)
# print(datasetDetails["describeDataset"])
df = datasetDetails["describeDataset"].round(6)
dfHtmlTableComponents = dataframeHtmlTableComponents(df)
if datasetDetails["columnChoices"]:
selectColumnToAnalyzeFormDetails.columnName.choices = datasetDetails[
"columnChoices"]
flash("Dataset Summary Statistics Completed", "success")
else:
flash("No columns found in dataset. Check dataset for errors.",
"error")
printFormErrors(selectDatasetToAnalzerFormDetails)
if "submitColumnToAnalyze" in request.form:
if selectColumnToAnalyzeFormDetails.validate_on_submit():
printLogEntry("Column to Analyze Form Submitted")
columnName = selectColumnToAnalyzeFormDetails.columnName.data
print(request.form)
printFormErrors(selectColumnToAnalyzeFormDetails)
flash("New plot created!", "success")
return render_template(
"datasetanalyzer.html",
title="Dataset Analyzer",
selectDatasetToAnalyzeForm=selectDatasetToAnalzerFormDetails,
selectColumnToAnalyzeForm=selectColumnToAnalyzeFormDetails,
resources=CDN.render(),
datasetDetails=datasetDetails,
dfHtmlTableComponents=dfHtmlTableComponents,
)
def result():
global model
global dictWord2Vec
ticker = request.form.get("var_1", type=str)
operation = request.form.get("operation")
ticker_storage.update_ticker(ticker)
# if(operation == 'Predict'):
# result = testFunc(var_1,var_2)
# result = setUpPredict(wordsForBow)
#p = produce_visual()
landing_page = get_template()
#return render_template('result.html', entry=entry, entry2 = entry2)
return landing_page.render(resources=CDN.render())
def post(post_id):
db = firestore.client()
doc_ref = db.collection(u'flagged_posts').document(str(post_id))
try:
doc = doc_ref.get()
except google.cloud.exceptions.NotFound:
return "Not Found"
post = doc.to_dict()
scores = post[u'scores']
p = make_plot(scores)
script1, div1 = components(p)
return render_template('post.html',
resources=CDN.render(),
script=script1,
div=div1,
uname=post[u'name'],
dom=post[u'domain'])
def submit():
if request.method == 'POST':
ticker = request.form['ticker'].upper()
price_type = request.form['price_type']
if ticker == '' or price_type == '':
message = 'Please enter required fields.'
return render_template('index.html', message=message)
else:
try:
p = make_plot(ticker, price_type)
with open('temp.txt', 'w') as f:
f.write(f"{ticker},{price_type}")
return page.render(resources=CDN.render())
except:
message = 'Please enter a valid ticker.'
return render_template('index.html', message=message)
def about():
type_mapping = {'Closing Price':'close', 'Adjusted Closing Price':'adj_close', \
'Open Price':'open', 'Adjusted Open Price':'adj_open'}
ticker = request.form.get("name")
ticker = ticker.split('-')[0] # get rid of the company full name.
type = request.form.get("type")
column = type_mapping[type] # get the name of the column needed.
range = request.form.get("range")
# Get the data for the ticker.
query = "https://www.quandl.com/api/v3/datatables/WIKI/PRICES.csv?ticker=" \
+ticker \
+"&qopts.columns=date," \
+column \
+"&api_key=ym9raNgKxyW-vx79qY5z"
time_series = pd.read_csv(query)
time_series['date'] = pd.to_datetime(time_series['date']) # Transfer the date column to timestamp to be safe.
latest = time_series['date'].max() # The latest date.
# Find the rows within the date range specified by the user.
starting = None
if range == '1 month':
starting = latest-relativedelta(months=1)
elif range == '6 months':
starting = latest-relativedelta(months=6)
elif range == 'YTD':
starting = datetime(latest.year,1,1)
elif range == '1 year':
starting = latest-relativedelta(years=1)
elif range == '5 years':
starting = latest-relativedelta(years=5)
time_series = time_series[time_series['date'] >= starting]
p = figure(plot_width=580, plot_height=520, x_axis_type='datetime')
p.xaxis.formatter=DatetimeTickFormatter(
days=["%b %d"],
months=["%b %Y"],
years=["%b %Y"],
)
# add a line renderer
p.line(x='date', y=column, source=time_series, line_width=2, legend=ticker+': '+type)
p.title.text = 'Quandl WIKI Stock Prices'
p.xaxis.axis_label = 'date'
p.legend.location = "top_left" # Set the position of the legend
p = json.dumps(json_item(p))
return render_template('plot.html', p=p, resources=CDN.render())
def dmarc_bokeh(request):
"""try a bokeh graph"""
# https://docs.djangoproject.com/en/dev/topics/db/aggregation/#interaction-with-default-ordering-or-order-by
# https://stackoverflow.com/questions/10154227/django-orm-group-by-day
# https://stackoverflow.com/questions/62105144/aggregate-number-of-likes-for-each-day-within-period
reports_count = Report.objects.extra(select={
'day': 'date( date_begin )'
}).values('day').order_by('date_begin').annotate(count=Count('date_begin'))
data = {
"day": [],
"count": [],
}
for r in reports_count:
data["day"].append(
datetime.datetime.combine(r["day"], datetime.datetime.min.time()))
data["count"].append(r["count"])
title = 'reports by day'
plot = figure(
title=title,
x_axis_label='Date',
x_axis_type="datetime",
y_axis_label='Reports',
plot_width=1000,
plot_height=400,
)
# plot.line(x="day", y="count", source=data, legend_label='reports', line_width=1)
plot.vbar(
x="day",
top="count",
source=data,
legend_label='reports',
width=1,
)
script, div = components(plot, CDN)
cdn = CDN.render()
context = {"div": div, "script": script, "bokeh_includes": cdn}
return render(request, 'dmarc/view_bokeh.html', context)
def plot(y):
if y not in PLOTS:
abort(404)
name = request.args.get("name")
file_name = request.args.get("file_name")
if name and file_name:
df = pd.read_csv(request.args.get("file_name"))
df["Date"] = pd.to_datetime(df["Date"])
child = current_user.children.filter_by(name=name).one()
print(df)
child.measurements.extend([
Measurement(m_type=y, date=t[1], value=t[2])
for t in df.itertuples()
])
db.session.commit()
return render_template('plot.html',
plot=y,
resources=CDN.render(),
children=current_user.children,
plots=PLOTS)
def index():
try:
# Retrieve ticker data, create plot
tr = ticker_retrieval('AAPL', '2019-01-01', '2019-01-31', quandl_key)
tr.get_ticker_data()
p = tr.create_plot()
# Stuff for embedding bokeh plot in webpage.
script, div = components(p)
except:
# If data retrieval was unsuccessful, print an error in place of the plot!
script = ""
div = r"<div><p>Error! Stock code was entered incorrectly OR data is unavailable for the entered stock.</p></div>"
return render_template('index.html',
script=script,
div=div,
bokeh_resources=CDN.render(),
st_date='2019-01-01',
ed_date='2019-01-31',
scode='AAPL')
def profile(uname):
db = firestore.client()
query = db.collection(u'flagged_posts').where(u'name', '==', 'uname')
ctr = 0
ctrd = {
u'FaceBook': 0,
u'Twitter': 0,
u'Reddit': 0,
u'Hackernews': 0,
u'Instagram': 0
}
avg_val = {
u'SexualContent': 0,
u'Hate': 0,
u'Insult': 0,
u'Obscene': 0,
u'SevereToxic': 0,
u'Toxic': 0,
u'Threat': 0,
u'Sarcasm': 0
}
for doc in query.stream():
ctr -= -1
post = doc.to_dict()
ctrd[post[u'domain']] -= -1
for k, v in post[u'scores']:
avg_val[k] += v
p1 = make_plot(avg_val)
p2 = make_plot(ctrd)
script1, div1 = components(p1)
script2, div2 = components(p2)
return render_template('userprofile.html',
resources=CDN.render(),
scriptA=script1,
divA=div1,
scriptB=script2,
divB=div2,
username=uname)
def create_report(
df: pd.DataFrame,
title: Optional[str] = "DataPrep Report",
mode: Optional[str] = "basic",
) -> None:
"""
This function is to generate and render element in a report object.
Parameters
----------
df
The DataFrame for which data are calculated.
title
The title of the report.
"""
context = {
"cdn": CDN.render(),
"title": title,
"components": format_report(df, mode),
}
template_base = ENV_LOADER.get_template("base.html")
with open(Path.cwd() / f"{title}.html", "w") as file:
file.write(template_base.render(context=context))
def render_html_cmp(scale: str) -> str:
"""Render any of the versions"""
# ip = request.ip.address
print(f'render_html_world - scale: {scale}')
record_visit()
reload_tmpls()
last_mtime = tstamp_to_dt(
cntries_data(date=None).mtime).isoformat(sep=' ')[:-10] + ' UTC'
x_tools = request.args.get("xt", "")
x_countries = request.args.get("xc", "")
if scale == "linear":
other_view = f'<a href="/corona_viz_log.html?xt={x_tools}&xc={x_countries}">' \
f'Vista en escala logarítmica</a>'
else:
other_view = f'<a href="/corona_viz_lin.html?xt={x_tools}&xc={x_countries}">' \
f'Vista en escala lineal</a>'
return TMPLS['cmp'].render(resources=CDN.render(),
scale=scale,
x_countries=x_countries,
x_tools=x_tools,
other_view=other_view,
last_mtime=last_mtime)
def root():
return page.render(resources=CDN.render())
def hello_world():
script = autoload_server(model=None,
url='http://localhost:5006/bkapp')
return render_template("embed1.html", script=script,
resources=CDN.render())