def users(): users = pd.read_csv("users.xlsx") hover = HoverTool(tooltips=[('Pct', '@pct')], mode='vline') users[''] donut_from_df = bc.Donut(users['City'], level_spacing=[0.0, 0.01]) ''' donut_from_df = Donut(df_users, label = "city",xlabel="city",ylabel="users", values="count", title="Users Per city", title_text_font_size=str(32)+"pt", level_spacing=[0.0, 0.01])''' #show(donut_from_df) script, div = components(donut_from_df) return """ <!doctype html> <head> <title>Popular places</title> {bokeh_css} </head> <body> <h1>Most Popular Places visited by people! {div} {bokeh_js} {script} </body> """.format(script=script, div=div, bokeh_css=CDN.render_css(), bokeh_js=CDN.render_js())
def visualisation(): # Build the dataframe df = pd.DataFrame({ 'x': 2 * np.pi * i / 100, 'sin': np.sin(2 * np.pi * i / 100), 'cos': np.cos(2 * np.pi * i / 100), } for i in range(0, 101)) # Create the plot plot = bc.Line(title='Triganometric fun!', data=df, x='x', ylabel='y') # Generate the script and HTML for the plot script, div = components(plot) # Return the webpage return """ <!doctype html> <head> <title>My wonderful trigonometric webpage</title> {bokeh_css} </head> <body> <h1>Everyone loves trig! {div} {bokeh_js} {script} </body> """.format(script=script, div=div, bokeh_css=CDN.render_css(), bokeh_js=CDN.render_js())
def visualisation(): current_city_name = request.args.get("city_name") if current_city_name == None: current_city_name = "Mumbai" subset = df_iplace[df_iplace['city'] == dropdown.value] #plot = create_figure(current_city_name) plot = bc.Bar(subset, "placename", values="placename", agg="count", plot_width=1000, plot_height=1000, title="Popular places") # Generate the script and HTML for the plot script, div = components(plot) # Return the webpage return """ <!doctype html> <head> <title>Popular places</title> {bokeh_css} </head> <body> <h1>Most Popular Places visited by people! {div} {bokeh_js} {script} </body> """.format(script=script, div=div, bokeh_css=CDN.render_css(), bokeh_js=CDN.render_js())
def next_step(): world = load_world() orders = dict() for sid, station in world.charging_stations.items(): if "order_%s" % sid not in request.form: raise Exception("Missing order_%s in request." % sid) orders[sid] = int(request.form.get("order_%s" % sid)) move_summary = world.next_step(orders) save_world(world) num_turns = len(world.solar_park.generation) available_tokens = [world.available_tokens(i) for i in range(num_turns)] max_tokens = int(max(available_tokens)) turn_hours = [str(h).rjust(2, "0") for h in range(9, 9 + num_turns)] if world.current_step < num_turns: safe_js = make_custom_js(world.charging_stations, max_tokens, world.current_step) else: safe_js = "" data_plots_html, data_plots_js = build_game_data_plots(world) return render_template("board.html", **dict(world=world), num_turns=num_turns, available_tokens=available_tokens, max_tokens=max_tokens, completed_a_move=True, move_summary=move_summary, turn_hours=turn_hours, safe_js=safe_js, bokeh_css_resources=CDN.render_css(), bokeh_js_resources=CDN.render_js(), data_plots_html=data_plots_html, data_plots_js=data_plots_js)
def init(is_reset=False): if not os.path.exists("worlds"): raise Exception( "Admin, please create the 'worlds' directory to save worlds!") world = load_world() num_turns = len(world.solar_park.generation) available_tokens = [world.available_tokens(i) for i in range(num_turns)] max_tokens = int(max(available_tokens)) turn_hours = [str(h).rjust(2, "0") for h in range(9, 9 + num_turns)] safe_js = make_custom_js(world.charging_stations, max_tokens, world.current_step) data_plots_html, data_plots_js = build_game_data_plots(world) return render_template("board.html", **dict(world=world), num_turns=num_turns, available_tokens=available_tokens, max_tokens=max_tokens, turn_hours=turn_hours, safe_js=safe_js, resetted_the_game=is_reset, bokeh_css_resources=CDN.render_css(), bokeh_js_resources=CDN.render_js(), data_plots_html=data_plots_html, data_plots_js=data_plots_js)
def visualisation(): # Build the dataframe df = pd.DataFrame({ 'x': 2*np.pi*i/100, 'sin': np.sin(2*np.pi*i/100), 'cos': np.cos(2*np.pi*i/100), } for i in range(0,101)) # Create the plot plot = bc.Line(title='Triganometric fun!', data=df, x='x', ylabel='y') # Generate the script and HTML for the plot script, div = components(plot) # Return the webpage return """ <!doctype html> <head> <title>My wonderful trigonometric webpage</title> {bokeh_css} </head> <body> <h1>Everyone loves trig! {div} {bokeh_js} {script} </body> """.format(script=script, div=div, bokeh_css=CDN.render_css(), bokeh_js=CDN.render_js())
def test_bokeh(): from bokeh.io import output_notebook, show from bokeh.plotting import figure import ipyvolume.bokeh x, y, z = np.random.random((3, 100)) p3.figure() scatter = p3.scatter(x, y, z) tools = "wheel_zoom,box_zoom,box_select,lasso_select,help,reset," p = figure(title="E Lz space", tools=tools, webgl=True, width=500, height=500) r = p.circle(x, y, color="navy", alpha=0.2) ipyvolume.bokeh.link_data_source_selection_to_widget( r.data_source, scatter, 'selected') from bokeh.resources import CDN from bokeh.embed import components script, div = components(p) ipyvolume.embed.embed_html( "tmp/bokeh.html", [p3.gcc(), ipyvolume.bokeh.wmh], all=True, extra_script_head=script + CDN.render_js() + CDN.render_css(), body_pre="<h2>Do selections in 2d (bokeh)<h2>" + div + "<h2>And see the selection in ipyvolume<h2>")
def output_pweave(): """ Call this once in a Pweave document to include correct headers for Bokeh. Analogous to Bokeh's output_notebook """ out = CDN.render_css() out += CDN.render_js() #display_markdown(out, raw=True) display_html(out, raw=True)
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 output_pweave(): """ Call this once in a Pweave document to include correct headers for Bokeh. Analogous to Bokeh's output_notebook """ out = CDN.render_css() out += CDN.render_js() # display_markdown(out, raw=True) display_html(out, raw=True)
def visuals(): plot = bc.Bar(data=top_ten_states_dataFrame, values='count', label='State') script, div = components(plot) error = None try: return ''' <!DOCTYPE html> <html> <head> <title>Train Wreck Header</title> <meta charset="utf-8"> <link rel="stylesheet" type="text/css" href="../static/css/bootstrap.min.css"> <script type="text/javascript" href="../static/js/bootstrap.min.js"></script> <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script> {bokeh_css} </head> <header style="background-color: #e6e6e6;"> <!-- <p> started working </p> --> <nav class="navbar navbar-inverse" style="background-color: #4d4d4d;"> <div class="container-fluid"> <div class="navbar-header"> <a class="navbar-brand" href="/" style="color: white;">Train Wreck Analysis</a> </div> <ul class="nav navbar-nav"> <li><a href="/">Home</a></li> <li><a href="/map/">Map</a></li> <li><a href="/visuals/">Bar Chart</a></li> </ul> </div> </nav> </header> <body> <div class="container-fluid" style="margin-left: 20px; float:left; border: solid; border-style: groove; border-width: 5px; height: 650px; width: 700px; padding-top: 20px;"> {div} {bokeh_js} {script} </div> </body> </html> '''.format(script=script, div=div, bokeh_css=CDN.render_css(), bokeh_js=CDN.render_js()) except Exception as e: flash(e) return render_template('visuals.html', error=error)
def make_plot_code(df): fraud_file = pd.read_csv('plots/graphfraud.csv') not_fraud_file = pd.read_csv('plots/graphnotfraud.csv') df = df.drop(['has_header'], axis=1) with open('plots/pca.pkl') as f: pca = pickle.load(f) with open('plots/scaler.pkl') as f: scaler = pickle.load(f) print df.values try: df_ = df.fillna(0.) x = pca.transform(scaler.transform(df_.values)) except: try: df_ = df.fillna(0) x = pca.transform(scaler.transform(df_.values)) except: df_ = df.fillna(str(0)) x = pca.transform(scaler.transform(df_.values)) p = figure(title="Fraud Visualization", plot_width=400, plot_height=400) p.background_fill_color = "#eeeeee" p.scatter(not_fraud_file.values[:, 0], not_fraud_file.values[:, 1], marker='triangle', color='orange', legend='Not Fraud') p.scatter(fraud_file.values[:, 0], fraud_file.values[:, 1], marker='circle', color='red', legend='Fraud') p.scatter(x[0, 0], x[0, 1], color='blue', legend='Most recent event', marker='square', size=10) script, div = components(p) div = ast.literal_eval(json.dumps(div)).replace('\n', "") script = ast.literal_eval(json.dumps(script)).replace('\n', "") css = CDN.render_css() css = ast.literal_eval(json.dumps(css)).replace('\n', "") js = CDN.render_js() js = ast.literal_eval(json.dumps(js)).replace('\n', "") return div, script, css, js
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 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 predict(): # loading data from current database connection data = cache.get('predictData') if data is None: data = db_to_pandas(g.cursor) cache.set('predictData', data, timeout=10600) # make predictions based on fetched data today_pred = cache.get('predictToday') if today_pred is None: today_pred = predict_today(data) cache.set('predictToday', today_pred, timeout=10600) # make plots from predictions script = cache.get('predictScript') divs = cache.get('predictDivs') if script is None: script, divs = graphics.create_all_buildings(today_pred.transpose()) cache.set('predictScript', script, timeout=10600) cache.set('predictDivs', divs, timeout=10600) ''' data = db_to_pandas(g.cursor) today_pred = predict_today(data) script, divs = graphics.create_all_buildings(today_pred.transpose()) ''' return render_template('predict.html', divs=divs, script=script, css_script=CDN.render_js())
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 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 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 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 bokehPlot(): company = app.vars['company'] script, div = components(plot_price(company)) return """ <!doctype html> <head> {bokeh_css} </head> <body> {div} {bokeh_js} {script} </body> """.format(script=script, div=div, bokeh_css=CDN.render_css(), bokeh_js=CDN.render_js())
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 stockprice(): if request.method == 'GET': return render_template('stocks.html') elif request.method == 'POST': theTicker = request.form['ticker'] theOption = request.form.getlist('features') theDate = request.form['daterange'] # call function to build graph plot = build_graph(theTicker, theOption, theDate) # get the plot components script, div = components(plot) # render plot on HTML page return render_template('stocks.html', script=script, div=div, bokeh_css=CDN.render_css(), bokeh_js=CDN.render_js())
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 main(): p = argparse.ArgumentParser() p.add_argument('infile', nargs='?', type=argparse.FileType('r'), default=sys.stdin) p.add_argument('outfile', nargs='?', default="site/index.html") p.add_argument('-t', '--template', default='template.jinja', help="""Jinja2 Tempate file[default: %(default)]""") p.add_argument('-v', '--view', default=False, help="""Launch browser to view output: %(default)]""") a = p.parse_args() df = pd.read_csv(a.infile) plots = mkplots(df) script, div = components(plots) js_resources = CDN.render_js() css_resources = CDN.render_css() env = Environment(loader=FileSystemLoader(THIS_DIR), trim_blocks=True) # Alias str.format to strformat in template env.filters['strformat'] = str.format template = env.get_template(a.template) html = template.render( date=datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"), command=" ".join(sys.argv), workdir=os.getcwd(), user=getpass.getuser(), title="Santa Performance Plots", js_resources=js_resources, css_resources=css_resources, script=script, div=div) with open(a.outfile, "w") as f: f.write(html.encode('utf-8')) # to deploy to gh-pages, use the function `gh=deploy` defined in ~.bash_profile # first copy index.html tp the `site/` directory # Cribbed from https://gist.github.com/cobyism/4730490 # git subtree push --prefix site origin gh-pages if a.view: view(a.outfile)
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 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)
def visualisation(session_type=None): global y_bottom global analyzer_log_dict global x global y # PARECERÍA QUE SE ENTRA UNA ÚNICA VEZ POR CLIENTE print("New Client Connected") plots = [] plots.append( ajax_getplot(x=x, y=y, y_bottom=y_bottom, ref_value=analyzer_log_dict["ref_level"])) #plots2 = [] #plots2.append(get_ajax_plot2()) return render_template("dashboard.html", bokeh_css=CDN.render_css(), bokeh_js=CDN.render_js(), plots=plots) #,plots2=plots2)
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 tickerTape_bokehPlot(): ticker_str = app_tickerTape.vars['tickerSymbol'] quandl.ApiConfig.api_key = 'rJS8aE3GNr2x5RBnFtr5' quandlData_df = getQuandlData(ticker_str) quandlPlot = plotQuandlData(ticker_str, quandlData_df) script, div = components(quandlPlot) return """ <!doctype html> <head> {bokeh_css} </head> <body> {div} {bokeh_js} {script} </body> """.format(script=script, div=div, bokeh_css=CDN.render_css(), bokeh_js=CDN.render_js())
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 popular_places(): try: db = mysql.connect() mycursor = db.cursor() mycursor.execute("select distinct(city) from placedetails") cities = [] for row in mycursor: cities.append(row[0]) form = AdminForm() form.city.choices = [(city, city) for city in cities] if request.method == 'POST' and form.validate_on_submit(): cname = request.form['city'] subset = df_iplace[df_iplace['city'] == cname] places = subset['placename'].value_counts().to_frame() plot = bc.Bar(places.iloc[0:5, ], label="index", values="placename", plot_width=1000, plot_height=700, legend="top_right", bar_width=0.3, min_border=30, xlabel="Places", ylabel="Count") script, div = components(plot) return render_template( "admin.html", form=form, script=script, title_text="Top 5 Places visited by people in ", div=div, bokeh_css=CDN.render_css(), bokeh_js=CDN.render_js(), city=cname) return render_template("admin.html", form=form) except: print("Exception occured in admin") finally: db.close()
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())