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())