示例#1
0
def check_session_id_signature(session_id, secret_key=settings.secret_key_bytes(),
                               signed=settings.sign_sessions()):
    """Check the signature of a session ID, returning True if it's valid.

    The server uses this function to check whether a session ID
    was generated with the correct secret key. If signed sessions are disabled,
    this function always returns True.

    Args:
        session_id (str) : The session ID to check
        secret_key (str, optional) : Secret key (default: value of 'BOKEH_SECRET_KEY' env var)
        signed (bool, optional) : Whether to check anything (default: value of
                                  'BOKEH_SIGN_SESSIONS' env var)

    """
    secret_key = _ensure_bytes(secret_key)
    if signed:
        pieces = session_id.split('-', 1)
        if len(pieces) != 2:
            return False
        base_id = pieces[0]
        provided_signature = pieces[1]
        expected_signature = _signature(base_id, secret_key)
        # hmac.compare_digest() uses a string compare algorithm that doesn't
        # short-circuit so we don't allow timing analysis
        # encode_utf8 is used to ensure that strings have same encoding
        return hmac.compare_digest(encode_utf8(expected_signature), encode_utf8(provided_signature))
    else:
        return True
示例#2
0
文件: IoKwb.py 项目: nelabdiel/IoK
def P():
    if request.method == 'GET': 
        html = render_template(
            'projections.html',
            total_disp=1, NS_disp=1,
        )
        return encode_utf8(html)
    else:
        app.vars['agep'] = request.form['agep']
        app.vars['bwp'] = request.form['bwp']
        app.vars['totalp'] = request.form['totalp']
        
        if app.vars['agep'] == 'Ruben Olmedo':
            html = render_template(
                'projections.html',
                total_disp='A new WR of 305.5', NS_disp='OVER 9000!!!!',
            )
            return encode_utf8(html)   
        
        else:
            if app.vars['agep']== '' or app.vars['bwp'] == '' or app.vars['totalp']== '':
                html = render_template(
                    'projections.html',
                    total_disp=1, NS_disp=1,
                )
                return encode_utf8(html)
                
                
            else:    
            
                agep = float(app.vars['agep'])
                bwp = float(app.vars['bwp'])
                totalp = float(app.vars['totalp'])
        
        
        
                #NSp = round(-approx(bwp)+totalp, 2)
                #for index, row in recent_data.iterrows():
                    #if abs(row['Age']-agep)<=2 and abs(row['NSC']-NSp)<=2:
                        #comparison = (row['LC'],row['CC'],row['Birth'],row['Year'],row['Year']+1)
                comparison = (5933, 15, 2016-agep, agep,2016)        
                NSp2 = nei_model_pred.predict(comparison)   
                NSp = round(-approx(bwp)+totalp, 2)
                NSp3 = round(NSp2[0],2)
               
                total_disp = NSp-NSp3+totalp
            
                
                html = render_template(
                    'projections.html',
                    total_disp=total_disp, NS_disp=NSp3,
                )
                return encode_utf8(html)    
def plot_titles():
    session_id = request.args.get("session_id")
    df_file = get_sess(session_id)['df_file']
    df = load_csv(session_id)

    ind = indeed_scrape.Indeed("kw")
    df['jobtitle'] = df['jobtitle'].apply(lambda x: x.lower())
    df['jobtitle'] = df['jobtitle'].apply(lambda x:' '.join(ind._split_on_spaces(x)))
    df['jobtitle'] = df['jobtitle'].apply(lambda x: re.sub('[^a-z\d\s]', '', x))
    num = df.shape[0]
    title_de_duped = ind.summary_similarity(df, 'jobtitle', 80)

    grp = title_de_duped.groupby("jobtitle").count().sort("url", ascending=False)
    cities = grp.index.tolist()
    counts = grp['city'] # any key will do here
    dff = pd.DataFrame({'kw':cities,
                        'count':counts
                        })

    kws = get_sess(session_id)['keyword'][0]
    p = plot_fig(dff, num, kws)
    script, div = components(p)

    session_string = "?session_id=%s" % session_id
    page = render_template('titles.html', div=div, script=script, session_id=session_string)
    return encode_utf8(page)
示例#4
0
def graph():
    # request was a POST
    StockTicker = request.form['stock']
    Type = request.form['type']
        
    api_url = 'https://www.quandl.com/api/v1/datasets/WIKI/%s.json' % StockTicker
    session = requests.Session()
    session.mount('http://', requests.adapters.HTTPAdapter(max_retries=3))
    raw_data = session.get(api_url)
    json_dat = raw_data.json()
    data = json_dat["data"]
    df = pd.DataFrame(data, columns= json_dat["column_names"])
    df['Date'] = pd.to_datetime(df['Date'])
    df = df[df["Date"] >= start]
    p1 = figure(x_axis_type = "datetime")
    p1.title = "Stock Closing Prices"
    p1.grid.grid_line_alpha=0.3
    p1.xaxis.axis_label = 'Date'
    p1.yaxis.axis_label = 'Price'    
    p1.line(df["Date"], df[Type], color='#A6CEE3', legend=StockTicker)
        
    
    # For more details see:
    #   http://bokeh.pydata.org/en/latest/docs/user_guide/embedding.html#components      
    script, div = components(p1, INLINE)
        
    return encode_utf8(render_template('graph.html', script=script, div=div))
示例#5
0
文件: app.py 项目: shchen/flask-demo
def graph():
    df = app.vars['data']

    # Create a line plot from our data.
    p = figure(width=700, height=500, x_axis_type="datetime",
                title="Data from Quandle WIKI set")
    for category in app.vars['features']:
        p.line(pd.to_datetime(df['Date']), df[category],
                color=app.vars['color'][category], line_width=1,
                legend=app.vars['ticker'] + ": " + category)

    p.legend.orientation = "top_right"

    # Configure resources to include BokehJS inline in the document.
    plot_resources = RESOURCES.render(
        js_raw=INLINE.js_raw,
        css_raw=INLINE.css_raw,
        js_files=INLINE.js_files,
        css_files=INLINE.css_files,
    )

    script, div = components(p, INLINE)
    html = render_template(
        'graph.html',
        ticker=app.vars['ticker'],
        plot_script=script, plot_div=div, plot_resources=plot_resources
    )
    return encode_utf8(html)
示例#6
0
def plot_data():
    # get data
    x = []
    y = []
    colors = []
    i = 0
    with open("time_dep.csv", "r") as f:
        while True:
            line = f.readline()
            if len(line) == 0:
                break
            items = line.split(',')
            x.append(float(items[0]))
            y.append(float(items[1]))
            
    fig = figure(title="Taxi trips versus Day", plot_width=600, plot_height=400, x_axis_type="datetime", toolbar_location="below")
    fig.line(x, y)
    fig.xaxis[0].formatter = DatetimeTickFormatter(formats=dict(days=["%a"]))
    fig.yaxis.axis_label = 'Number of Trips'

    script, div = components(fig, INLINE)
    html = flask.render_template(
        'layout.html', #'layout.html',
        plot_script=script,
        plot_div=div,
        js_resources=js_resources,
        css_resources=css_resources,
    )
    return encode_utf8(html)
示例#7
0
def graph():
    app.symbol = request.form['symbol']
    try:       
      graph_html = build_graph(str(app.symbol))
      return encode_utf8(graph_html)   
    except KeyError:
      return render_template('error.html')
示例#8
0
def get_data():

    if request.method == "POST":
        session_id = mk_random_string()
        logging.info("session id: %s" % session_id)

        type_ = request.form['type_']
        kws = request.form['kw'].lower()
        kws = indeed_scrape.Indeed._split_on_spaces(kws)
        kws = " ".join(kws) #enter into DB normalized

        # key used for sql to recover other info
        to_sql({'session_id':session_id,
                'type_':type_,
                'keyword':kws,
                'ind':0,
                'end':0,
                'count_thres':50
                })

        logging.info("running get_data:%s" % time.strftime("%d-%m-%Y:%H:%M:%S"))
        logging.info("type:%s" %  type_)
        logging.info("key words:%s" % kws)

        session_string = "?session_id=%s" % session_id
        html = render_template('output.html', session_id=session_string)
        return encode_utf8(html)
def plot_cities():
    session_id = request.args.get("session_id")
    logging.info("session id:%s" % session_id)
    df = load_csv(session_id)

    count = df.groupby("city").count()['url']
    cities = count.index.tolist()
    num_posts = df.shape[0]

    df_city = pd.DataFrame({'kw':cities, 'count':count})
    df_city.sort('count', ascending=False, inplace=True)
    df_city.reset_index(inplace=True)

    # hack
    df_city[df_city['count'] == 0] = None
    df_city.dropna(inplace=True)

    n = df_city.shape[0]
    if n > 20:
        end = 20
    else:
        end = n

    kws = get_sess(session_id)['keyword'][0]
    slice = df_city.loc[0:end, :].copy()
    p = plot_fig(slice, num_posts, kws)
    script, div = components(p)

    session_string = "?session_id=%s" % session_id
    page = render_template('cities.html', div=div, script=script, session_id=session_string)
    return encode_utf8(page)
示例#10
0
def polynomial():
    """ Very simple embeding of a polynomial chart """
    # Grab input arguments from the URL
    # This is automated by the button
    args = flask.request.args

    # Get all the form arguments in their url with defaults
    color = colors[getitem(args,'color','Black')]

    fig = figure(width=800, height=350,x_axis_type='datetime', title='%s closing prices for last 30 days' % st)
    fig.line(dates, closing_prices, line_width=2, color=color, alpha=0.2, legend='close')
    fig.xaxis.axis_label = 'Date'
    fig.yaxis.axis_label = 'Price'

    # Configure resources to include BokehJS inline in the document.
    plot_resources = RESOURCES.render(
        js_raw = INLINE.js_raw,
        css_raw = INLINE.css_raw,
        js_files = INLINE.js_files,
        css_files = INLINE.css_files
    )

    script, div = components(fig, INLINE)

    html = flask.render_template(
        'embed.html',
        plot_script = script, plot_div=div, plot_resources=plot_resources,
        color=color
    )
    return encode_utf8(html)
 def set(self, key, val):
     _data = self.shelve_module.open('bokeh.server')
     try:
         key = encode_utf8(key)
         _data[key] = json.dumps(val)
     finally:
         _data.close()
示例#12
0
def plot_cities():
    session_id = request.args.get("session_id")
    logging.info("session id:%s" % session_id)
    df = load_csv(session_id)

    count = df.groupby("city").count()['url']
    cities = count.index.tolist()
    num_posts = df.shape[0]

    df_city = pd.DataFrame({'kw':cities, 'count':count})
    df_city.sort('count', ascending=False, inplace=True)
    df_city.reset_index(inplace=True)

    n = df_city.shape[0]
    if n > 20:
        end = 20
    else:
        end = n

    p = plot_fig(df_city.loc[0:end,:], num_posts, 'Posts Per City in the Analysis:Top 20')
    script, div = components(p)

    session_string = "?session_id=%s" % session_id
    page = render_template('cities.html', div=div, script=script, session_id=session_string)
    return encode_utf8(page)
示例#13
0
def plot_data():
    """Obtains post data and produces two graphs: 
    volume of posts mentioning 'dengue' versus time; and
    volume of posts versus neighborhood
    """
    (df, df_volume, df_by_location) = get_data()
    script1, div1 = volumeGraph(df_volume)
    script2, div2 = locationGraph(df_by_location)

    plot_resources = RESOURCES.render(
        js_raw=INLINE.js_raw,
        css_raw=INLINE.css_raw,
        js_files=INLINE.js_files,
        css_files=INLINE.css_files,
    )

    html = flask.render_template(
        'embed.html',
        plot_script1=script1, 
        plot_div1=div1, 
        plot_script2=script2, 
        plot_div2=div2, 
        plot_resources=plot_resources
    )
    return encode_utf8(html)
示例#14
0
def plot_titles():
    session_id = request.args.get("session_id")
    df_file = get_sess(session_id)['df_file']
    df = load_csv(session_id)

    ind = indeed_scrape.Indeed("kw")
    df['jobtitle'] = df['jobtitle'].apply(lambda x: x.lower())
    df['jobtitle'] = df['jobtitle'].apply(lambda x:' '.join(ind._split_on_spaces(x)))
    df['jobtitle'] = df['jobtitle'].apply(lambda x: re.sub('[^a-z\d\s]', '', x))
    title_de_duped = ind.summary_similarity(df, 'jobtitle', 80)

    grp = title_de_duped.groupby("jobtitle").count().sort("url", ascending=False)
    cities = grp.index.tolist()
    counts = grp['city'] # any key will do here

    row = u'<tr><td>%s</td><td>%s</td></tr>'
    rows = u''

    for cty, cnt in zip(cities, counts):
        try:
            cty = cty.encode("utf-8", "ignore")
            rows += row % (cty, cnt)
        except:
           continue

    session_string = "?session_id=%s" % session_id
    page = render_template('titles.html', rows=rows, session_id=session_string)
    return encode_utf8(page)
示例#15
0
    def get(self, *args, **kwargs):
        session = yield self.get_session()

        element_id = self.get_argument("bokeh-autoload-element", default=None)
        if not element_id:
            self.send_error(status_code=400, reason='No bokeh-autoload-element query parameter')
            return

        resources = self.application.resources(self.request)
        websocket_url = self.application.websocket_url_for_request(self.request, self.bokeh_websocket_path)

        # TODO: yes, this should resuse code from bokeh.embed more directly
        render_items = [dict(sessionid=session.id, elementid=element_id, use_for_title=True)]
        script = _script_for_render_items(None, render_items, websocket_url=websocket_url, wrap_script=False)

        js = AUTOLOAD_JS.render(
            js_urls = resources.js_files,
            css_urls = resources.css_files,
            js_raw = resources.js_raw + [script],
            css_raw = resources.css_raw_str,
            elementid = element_id,
        )

        self.set_header("Content-Type", 'application/javascript')
        self.write(encode_utf8(js))
示例#16
0
def plot_data():
    # get data
    x = []
    y = []
    colors = []
    i = 0
    with open("data.csv", "r") as f:
        while True:
            line = f.readline()
            if len(line) == 0:
                break
            if i == 6:
                break
            items = line.split(',')
            x.append(float(items[0]))
            y.append(float(items[1]))
            #z = int(items[2][:-1])
            colors.append("#%02x%02x%02x" % (255, 0, 0))
            i += 1
    fig = figure(title="Data", plot_width=600, plot_height=400, toolbar_location="below")
    fig.scatter(x, y, radius=0.1, fill_color=colors, fill_alpha=0.6, line_color=None)

    script, div = components(fig, INLINE)
    html = flask.render_template(
        'figure.html', #'layout.html',
        plot_script=script,
        plot_div=div,
        js_resources=js_resources,
        css_resources=css_resources,
    )
    return encode_utf8(html)
示例#17
0
def extract_zip(zip_name, exclude_term=None):
    """Extracts a zip file to its containing directory."""

    zip_dir = os.path.dirname(os.path.abspath(zip_name))

    try:
        with zipfile.ZipFile(zip_name) as z:

            # write each zipped file out if it isn't a directory
            files = [zip_file for zip_file in z.namelist() if not zip_file.endswith('/')]

            print('Extracting %i files from %r.' % (len(files), zip_name))
            for zip_file in files:

                # remove any provided extra directory term from zip file
                if exclude_term:
                    dest_file = zip_file.replace(exclude_term, '')
                else:
                    dest_file = zip_file

                dest_file = os.path.normpath(os.path.join(zip_dir, dest_file))
                dest_dir = os.path.dirname(dest_file)

                # make directory if it does not exist
                if not os.path.isdir(dest_dir):
                    os.makedirs(dest_dir)

                # read file from zip, then write to new directory
                data = z.read(zip_file)
                with open(dest_file, 'wb') as f:
                    f.write(encode_utf8(data))

    except zipfile.error as e:
        print("Bad zipfile (%r): %s" % (zip_name, e))
        raise e
示例#18
0
def polynomial():
    """ Very simple embedding of a polynomial chart"""
    # Grab the inputs arguments from the URL
    # This is automated by the button
    args = flask.request.args

    # Get all the form arguments in the url with defaults
    color = colors[getitem(args, 'color', 'Black')]
    _from = int(getitem(args, '_from', 0))
    to = int(getitem(args, 'to', 10))

    # Create a polynomial line graph
    x = list(range(_from, to + 1))
    fig = figure(title="Polynomial")
    fig.line(x, [i ** 2 for i in x], color=color, line_width=2)

    # Configure resources to include BokehJS inline in the document.
    # For more details see:
    #   http://bokeh.pydata.org/en/latest/docs/reference/resources_embedding.html#module-bokeh.resources
    plot_resources = RESOURCES.render(
        js_raw=INLINE.js_raw,
        css_raw=INLINE.css_raw,
        js_files=INLINE.js_files,
        css_files=INLINE.css_files,
    )

    # For more details see:
    #   http://bokeh.pydata.org/en/latest/docs/user_guide/embedding.html#components
    script, div = components(fig, INLINE)
    html = flask.render_template(
        'embed.html',
        plot_script=script, plot_div=div, plot_resources=plot_resources,
        color=color, _from=_from, to=to
    )
    return encode_utf8(html)
示例#19
0
文件: app.py 项目: hhsieh/Herokuapp
def second_stock():	
	n = app_stock.vars['name']
	ss = "WIKI/" + n + ".4"
	mydata = quandl.get(ss, encoding='latin1', parse_dates=['Date'], dayfirst=True, index_col='Date', trim_start="2016-05-05", trim_end="2016-06-05", returns = "numpy", authtoken="ZemsPswo-xM16GFxuKP2")
	mydata = pd.DataFrame(mydata)
	#mydata['Date'] = mydata['Date'].astype('datetime64[ns]')
	x = mydata['Date']
	y = mydata['Close']
	p = figure(title="Stock close price", x_axis_label='Date', y_axis_label='close price', plot_height = 300, plot_width = 550)
	p.line(x, y, legend="Price in USD", line_width=3, color = "#2222aa")
	
	
	# Configure resources to include BokehJS inline in the document.
    # For more details see:
    #   http://bokeh.pydata.org/en/latest/docs/reference/resources_embedding.html#bokeh-embed
	js_resources = INLINE.render_js()
	css_resources = INLINE.render_css()

    # For more details see:
    #   http://bokeh.pydata.org/en/latest/docs/user_guide/embedding.html#components
	script, div = components(p, INLINE)
    
	html = flask.render_template(
		'stockgraph.html',
		ticker = app_stock.vars['name'],
		plot_script=script,
		plot_div=div,
		js_resources=js_resources,
		css_resources=css_resources,
	)
	return encode_utf8(html)
示例#20
0
def polynomial():
    """ Very simple embedding of a polynomial chart

    """

    # Grab the inputs arguments from the URL
    args = flask.request.args

    # Get all the form arguments in the url with defaults
    color = getitem(args, 'color', 'Black')
    _from = int(getitem(args, '_from', 0))
    to = int(getitem(args, 'to', 10))

    # Create a polynomial line graph with those arguments
    x = list(range(_from, to + 1))
    fig = figure(title="Polynomial")
    fig.line(x, [i ** 2 for i in x], color=colors[color], line_width=2)

    js_resources = INLINE.render_js()
    css_resources = INLINE.render_css()

    script, div = components(fig)
    html = flask.render_template(
        'embed.html',
        plot_script=script,
        plot_div=div,
        js_resources=js_resources,
        css_resources=css_resources,
        color=color,
        _from=_from,
        to=to
    )
    return encode_utf8(html)
示例#21
0
def graphstocks(ssymbol):
    """ Very simple embedding of a polynomial chart"""
    # Grab the inputs arguments from the URL
    # This is automated by the button
    args = ["ADAM"] 
    args = request.args

    # Get all the form arguments in the url with defaults
    color = colors[getitem(args, 'color', 'Black')]
    _from = int(getitem(args, '_from', 0))
    to = int(getitem(args, 'to', 10))

    # Create a polynomial line graph
    #x = list(range(_from, to + 1))
    #fig = figure(title="Polynomial")
    #fig.line(x, [i ** 2 for i in x], color=color, line_width=2)
    AAPL= pd.read_csv("https://ichart.yahoo.com/table.csv?s="+ssymbol+"&a=0&b=1&c=2000&d=0&e=1&f=2010",parse_dates=['Date'])   
    data = dict(AAPL=AAPL['Adj Close'], Date=AAPL['Date'])
    tsline = TimeSeries(data,x='Date', y='AAPL', ylabel='Stock Prices', legend=True)
    #tsline=TimeSeries(data,x='Date', y=['AAPL'], color=['AAPL'], dash=['AAPL'],
   #                   title="Timeseries", ylabel = 'Stock Prices', legend=True)
#    tspoint=TimeSeries(data,x='Date',y=[ssymbol], dash=[ssymbol],title="Timeseries",ylabel='Stock Prices', legend=True)
    output_file("timeseries.html")
    fig=vplot(tsline)
    
    # Configure resources to include BokehJS inline in the document.
    # For more details see:
    #   http://bokeh.pydata.org/en/latest/docs/reference/resources_embedding.html#bokeh-embed
    js_resources = JS_RESOURCES.render(
        js_raw=INLINE.js_raw,
        js_files=INLINE.js_files
    )

    css_resources = CSS_RESOURCES.render(
        css_raw=INLINE.css_raw,
        css_files=INLINE.css_files
    )
#from: http://bokeh.pydata.org/en/0.11.1/docs/releases/0.11.0.html  
# Before:

#html = file_html(layout, None, title=title, template=template, js_resources=js_resources, css_resources=css_resources)
#v0.11:
#
#html = file_html(layout, resources=(js_resources, css_resources), title=title, template=template)
 
   # For more details see:
    #   http://bokeh.pydata.org/en/latest/docs/user_guide/embedding.html#components
    script, div = components(fig, INLINE)
    html = render_template(
        'embed.html',
        plot_script=script,
        plot_div=div,
        js_resources=js_resources,
        css_resources=css_resources,
        color=color,
        _from=_from,
        to=to
    )
    return encode_utf8(html)
示例#22
0
 def get(self, key):
     _data = shelve.open("bokeh.server")
     key = encode_utf8(key)
     data = _data.get(key, None)
     if data is None:
         return None
     attrs = json.loads(decode_utf8(data))
     _data.close()
     return attrs
示例#23
0
def model():
    pTOOLS = "crosshair,hover,pan,box_zoom,reset,save"
    p2 = figure(tools=pTOOLS,background_fill="#dbe0eb",
                x_range = (0,100),
                y_range =(80,100),
                x_axis_label='Decision Boundary (score)',
                y_axis_label='Precision',
                title='Recall and Precision',
                plot_height=600,
                plot_width=800)

    # Setting the second y axis range name and range
    p2.extra_y_ranges = {"foo": Range1d(start=-5, end=105)}

    # Adding the second axis to the plot.  
    p2.add_layout(LinearAxis(y_range_name="foo",axis_label="Recall", 
                             axis_label_text_color = "red",
                             major_label_text_color = "red"), 'right')

    source1 = ColumnDataSource(
        data=dict(precision = crit_r_c[1]*100, recall =  crit_r_c[2]*100.0/153546,
                 risk = 100 - crit_r_c[1]*100, miss = 100- crit_r_c[2]*100.0/153546))

    source2 = ColumnDataSource(
        data=dict(precision = crit_r_c[1]*100, recall =  crit_r_c[2]*100.0/153546,
                 risk = 100 - crit_r_c[1]*100, miss = 100- crit_r_c[2]*100.0/153546))


    p2.line(crit_r_c[0],crit_r_c[1]*100,line_color="blue", line_width=20, alpha=0.7,source=source1)
    p2.line(crit_r_c[0],crit_r_c[2]*100.0/153546,line_color="red", line_width=20, alpha=0.7,y_range_name="foo",source=source2)

    hover = p2.select(dict(type=HoverTool))
    hover.tooltips = OrderedDict([
        ('Decison Boundary (score)', '$x'),
        ("Precision            (%)","@precision"),
        ("Risk                 (%)", "@risk"),
        ("Recall               (%)", "@recall"),
        ("Missed Opportunity   (%)", "@miss"),

    ])

    js_resources2 = JS_RESOURCES.render(
        js_raw=INLINE.js_raw,
        js_files=INLINE.js_files)

    css_resources2 = CSS_RESOURCES.render(
        css_raw=INLINE.css_raw,
        css_files=INLINE.css_files)
    p2script, p2div = components(p2, INLINE)

    html = flask.render_template(
        'model.html',
        plot_script2=p2script, plot_div2=p2div, 
        js_resources=js_resources2,
        css_resources=css_resources2)
    return encode_utf8(html)
示例#24
0
def root():
    html = flask.render_template(
        'layout.html', 
        # plot_script=script,
        # plot_div=div,
        # plot_div2=div2,
        js_resources=js_resources,
        css_resources=css_resources,
    )
    return encode_utf8(html)
 def get(self, key):
     _data = self.shelve_module.open('bokeh.server')
     try:
         key = encode_utf8(key)
         data = _data.get(key, None)
         if data is None:
             return None
         attrs = json.loads(decode_utf8(data))
     finally:
         _data.close()
     return attrs
示例#26
0
def root():
    global plot_scripts
    html = flask.render_template(
        'layout.html', 
        plot_script=plot_scripts[0],
        plot_div=plot_scripts[1],
        plot_div2=plot_scripts[2],
        js_resources=js_resources,
        css_resources=css_resources,
    )
    return encode_utf8(html)
示例#27
0
文件: app.py 项目: jingfengli/tmp
def stock():
    """ Very simple plot of stock closing price for last month or so"""
    # Grab the inputs arguments from the URL
    # This is automated by the button
    args = flask.request.args
    return 'ALA'
    # Get all the form arguments in the url with defaults
    if 'company' in args.keys() and args['company']:
        company = args['company']
    else:
        company = 'GOOG'

    cl = requests.get("https://www.quandl.com/api/v3/datasets/WIKI/%s.json?order=asc&rows=31&start_date=2015-07-01&end_date=2015-09-03" % (company))
    if cl.status_code == 200:
    	c2=cl.content
    	stock=simplejson.loads(c2)
    	abb=stock['dataset']['dataset_code']
    	datanames=stock['dataset']['column_names']
    	data=stock['dataset']['data']
    	dataorg=pd.DataFrame(data,columns=datanames)
    	dataorg['Date']=pd.to_datetime(dataorg['Date'])
    else:
        ######## THIS IS NOT RECOMMENDED, because now it just returns an error message if not find the ticker.
        return 'Error! Ticker does not exist!'


    # Create a graph
    fig = figure(x_axis_type="datetime")
    fig.line(dataorg.Date,dataorg.Close)
    fig.title="Stock closing price (%s), from 07-01-2015    " % (company)
    # fig.xaxis_axis_label='Date'
    # fig.yaxis_axis_label='Price'

    # Configure resources to include BokehJS inline in the document.
    # For more details see:
    #   http://bokeh.pydata.org/en/latest/docs/reference/resources_embedding.html#module-bokeh.resources
    plot_resources = RESOURCES.render(
        js_raw=INLINE.js_raw,
        css_raw=INLINE.css_raw,
        js_files=INLINE.js_files,
        css_files=INLINE.css_files,
    )

    # For more details see:
    #   http://bokeh.pydata.org/en/latest/docs/user_guide/embedding.html#components
    script, div = components(fig, INLINE)
    html = flask.render_template(
        'embed.html',
        plot_script=script, plot_div=div, plot_resources=plot_resources,
        # color=color,
        company=company
    )
    return encode_utf8(html)
示例#28
0
def main(ipynb):
    print("running %s" % ipynb)
    with io.open(ipynb, encoding='utf8') as f:
        nb = read(f, NO_CONVERT)
    test_notebook(nb)
    base, ext = os.path.splitext(ipynb)

    exportHtml = HTMLExporter()
    (body, resources) = exportHtml.from_notebook_node(nb)

    outfile = ipynb + ".html"
    open(outfile, 'w').write(encode_utf8(body))
    print("wrote %s" % outfile)
示例#29
0
文件: app.py 项目: yinran/milestone1
def search():
    ticker = request.form['ticker']
    url = "https://www.quandl.com/api/v3/datasets/WIKI/" + ticker + "/data.json"
    payload = {'api_key':'9o4vcpiASzqaA6dczzzZ','start_date': '2015-11-01', 'end_date': '2015-11-30'}
    res = requests.get(url, params=payload)
    raw_data = json.loads(res.text)
    date_strings = [x[0] for x in raw_data["dataset_data"]["data"]]
    close_price = [x[4] for x in raw_data["dataset_data"]["data"]]
    date = pd.to_datetime(pd.Series(date_strings))
    p = figure(title="Stock Price for "+ticker+" (source: Quandl WIKI)", x_axis_label="Date",y_axis_label="Price", x_axis_type="datetime")
    p.line(date ,close_price, legend="Close Price", line_width=3)
    script, div = components(p, INLINE)
    html = render_template('results.html', plot_script=script, plot_div=div)
    return encode_utf8(html)
示例#30
0
def check_for_low_count_using_title():
    session_id = request.args.get("session_id")
    logging.debug("session id:%s" % session_id)

    df = load_csv(session_id)
    logging.debug("title count:%i" % df.shape[0])

    string = "<br><p><i>Your search by job title returned a small number of job \
    postings. Click 'NEW SEARCH' and use the 'keyword' search.</i></p><br>"

    if df.shape[0] < 25:
        return encode_utf8(string)
    else:
        return ""
示例#31
0
    def get(self, *args, **kwargs):
        session = yield self.get_session()

        element_id = self.get_argument("bokeh-autoload-element", default=None)
        if not element_id:
            self.send_error(status_code=400, reason='No bokeh-autoload-element query parameter')
            return

        resources = self.application.resources(self.request)
        websocket_url = self.application.websocket_url_for_request(self.request, self.bokeh_websocket_path)

        js = AUTOLOAD_JS.render(
            docs_json = None,
            js_urls = resources.js_files,
            css_files = resources.css_files,
            elementid = element_id,
            sessionid = session.id,
            websocket_url = websocket_url
        )

        self.set_header("Content-Type", 'application/javascript')
        self.write(encode_utf8(js))
示例#32
0
def index():
    # Static resources
    js_resources = INLINE.render_js()
    css_resources = INLINE.render_css()
    plot_script = ""
    plot_div = ""
    articles = ""

    # Initialize the ticker registry (only once though)
    tickers_init()

    # Parse form data
    if request.method == 'POST':
        ticker = request.form.get('ticker').strip().upper()
        close = request.form.get('close')
        opening = request.form.get('open')
        high = request.form.get('high')
        low = request.form.get('low')

        # Go get stock info
        df = alpha_vantage(ticker)
        if df is not None:
            plot_script, plot_div = create_figure(df, ticker,
                                                  [opening, close, high, low])
            articles = get_news(ticker)
        else:
            flash('Stock ticker not found.')
            return redirect(url_for('index'))

    # Render our results (if any)
    html = render_template('index.html',
                           js_resources=js_resources,
                           css_resources=css_resources,
                           plot_script=plot_script,
                           plot_div=plot_div,
                           articles=articles,
                           entries=TICKERS)

    return encode_utf8(html)
示例#33
0
def graph():
    if request.method == 'POST':
        symbol = request.form['ticker']
    else:
        dat = "method not post"

    #get quandl data
    quandlTicker = "WIKI/%s" % symbol
    data = quandl.get(quandlTicker, start_date="2018-01-01")

    data.index.name = 'Date'
    data.reset_index(inplace=True)

    fig = figure(x_axis_type="datetime", title="Stock Closing Price")
    fig.grid.grid_line_alpha = 0.3
    fig.xaxis.axis_label = 'Date'
    fig.yaxis.axis_label = 'Price'

    fig.line(data['Date'], data['Close'], color='#A6CEE3', legend=symbol)

    js_resources = INLINE.render_js()
    css_resources = INLINE.render_css()

    #  window_size = 30
    #  window = np.ones(window_size)/float(window_size)
    #  avg = np.convolve(data['Close'], window, 'same')

    #  return(output_file("graph.html", title="Stock Closing Price"))

    script, div = components(fig)

    html = render_template('graph.html',
                           plot_script=script,
                           plot_div=div,
                           js_resources=js_resources,
                           css_resources=css_resources)

    return encode_utf8(html)
示例#34
0
def bokeh(filename):
    #print(filename)
    data = xr.open_dataarray(os.path.join(app.config['UPLOAD_FOLDER'], filename))
    #print(data)
    # init a basic bar chart:
    # http://bokeh.pydata.org/en/latest/docs/user_guide/plotting.html#bars
    pandas_data = data.sel(Meson_Number=15,Momentum_List='0 0 0').to_dataframe()
    x = list(pandas_data.index)
    y = pandas_data[pandas_data.columns[-1]].values
    y = np.log(y/np.roll(y,-1))

    print()
    print(x)
    print()
    print(y)
    print()

    fig = figure(plot_width=600, plot_height=600)
    fig.scatter(
        x,
        y,
        color='navy'
    )

    # grab the static resources
    js_resources = INLINE.render_js()
    css_resources = INLINE.render_css()

    # render template
    script, div = components(fig)
    html = render_template(
        'index.html',
        plot_script=script,
        plot_div=div,
        js_resources=js_resources,
        css_resources=css_resources,
    )
    return encode_utf8(html)
示例#35
0
def chart():
    brand = request.form['brand']
    response = get_data_from_api(brand=brand)
    # print(response)
    total = response['number_of_tweets']
    positive = response['positive']
    neutral = response['neutral']
    negative = response['negative']
    sentiments = ["Positive", "Neutral", "Negative"]
    distribution = [positive, neutral, negative]
    source = ColumnDataSource(data=dict(sentiments=sentiments, distribution=distribution))

    p = figure(x_range=sentiments, plot_height=550, plot_width= 1000, title="Sentiment distribution", x_axis_label = 'Sentiments')
    p.vbar(x='sentiments', top='distribution', width=0.9, source=source, legend_field="sentiments",
           line_color=None, fill_color=factor_cmap('sentiments', palette=['#39DA00', '#FDB229', '#FF0445'], factors=sentiments))

    p.xgrid.grid_line_color = None
    p.y_range.start = 0
    p.legend.orientation = "horizontal"
    p.legend.location = "top_right"
    p.background_fill_color = "#0B0022"

    script, div = components(p)

    pos = round((float(positive)/float(total))*100, 1)
    neu = round((float(neutral)/float(total))*100, 1)
    neg = round((float(negative) / float(total)) * 100, 1)
    print(pos)
    print(neu)
    print(neg)

    html = render_template("chart.html",
                           the_div=div,
                           the_script=script,
                           positive=pos,
                           neutral=neu,
                           negative=neg)
    return encode_utf8(html)
示例#36
0
def extract_zip(zip_name, exclude_term=None):
    """Extracts a zip file to its containing directory."""

    zip_dir = os.path.dirname(os.path.abspath(zip_name))

    try:
        with zipfile.ZipFile(zip_name) as z:

            # write each zipped file out if it isn't a directory
            files = [
                zip_file for zip_file in z.namelist()
                if not zip_file.endswith('/')
            ]

            print('Extracting %i files from %r.' % (len(files), zip_name))
            for zip_file in files:

                # remove any provided extra directory term from zip file
                if exclude_term:
                    dest_file = zip_file.replace(exclude_term, '')
                else:
                    dest_file = zip_file

                dest_file = os.path.normpath(os.path.join(zip_dir, dest_file))
                dest_dir = os.path.dirname(dest_file)

                # make directory if it does not exist
                if not os.path.isdir(dest_dir):
                    os.makedirs(dest_dir)

                # read file from zip, then write to new directory
                data = z.read(zip_file)
                with open(dest_file, 'wb') as f:
                    f.write(encode_utf8(data))

    except zipfile.error as e:
        print("Bad zipfile (%r): %s" % (zip_name, e))
        raise e
示例#37
0
def dashboard():

    CASSANDRA_HOST = ['192.168.0.101', '192.168.0.106']
    CASSANDRA_PORT = 9042
    CASSANDRA_DB = "cryptocoindb"

    cluster = Cluster(contact_points=CASSANDRA_HOST, port=CASSANDRA_PORT)
    session = cluster.connect(CASSANDRA_DB)

    session.row_factory = pandas_factory
    session.default_fetch_size = None

    ndays = request.args.get('ndays', default=7, type=int)
    print(ndays)
    tblGainLoss, tblDailyGainLoss, coinHistory, tblCoins = getAllData(
        ndays, session=session)
    # tblGainLoss, tblCoins, coinHistory = getSomeValueFromA_Database()
    # Grab the inputs arguments from the URL
    # args = flask.request.args
    l = layout(
        [[[[GainLossPlot(tblGainLoss)], [MarketPlot(tblCoins, coinHistory)]],
          WalletPlot(coinHistory)]],
        repsonsive=True)

    js_resources = INLINE.render_js()
    css_resources = INLINE.render_css()

    script, div = components(l)

    html = flask.render_template('old_dashboard.html',
                                 title="BitCoin Dashboard",
                                 plot_script=script,
                                 plot_div=div,
                                 js_resources=js_resources,
                                 css_resources=css_resources,
                                 active_page='projects',
                                 footer='false')
    return encode_utf8(html)
示例#38
0
def index():
    # Static resources:
    js_resources = INLINE.render_js()
    css_resources = INLINE.render_css()
    plot_script = ""
    plot_div = ""

    # Parse form data
    if request.method == 'POST':
        ticker = request.form.get('ticker').strip().upper()
        close = request.form.get('close')
        opening = request.form.get('open')
        high = request.form.get('high')
        low = request.form.get('low')

        # Get stock info from Alpha Vantage
        df = alpha_vantage(ticker)
        if df is not None:
            plot_script, plot_div = create_plot(df, ticker,
                                                [opening, close, high, low])

            # TODO: the function below isn't working, Need to figure out how to get input from multiple forms.
            #  Use the index.html file in /template_tinkering and reference:
            #  https://github.com/thedataincubator/sql_heroku/blob/master/app/templates/index.html#L54
            #plot_script, plot_div = create_candlesctick(df, ticker)
        else:
            flash('Stock ticker not found')
            return redirect(url_for('index'))

    # Render results is available
    html = render_template('index.html',
                           js_resources=js_resources,
                           css_resources=css_resources,
                           plot_script=plot_script,
                           plot_div=plot_div,
                           entries=['AAPL', 'GOOG', 'MSFT'])

    return encode_utf8(html)
示例#39
0
def plot_data():
    """Obtains post data and produces two graphs: 
    volume of posts mentioning 'dengue' versus time; and
    volume of posts versus neighborhood
    """
    (df, df_volume, df_by_location) = get_data()
    script1, div1 = volumeGraph(df_volume)
    script2, div2 = locationGraph(df_by_location)

    plot_resources = RESOURCES.render(
        js_raw=INLINE.js_raw,
        css_raw=INLINE.css_raw,
        js_files=INLINE.js_files,
        css_files=INLINE.css_files,
    )

    html = flask.render_template('embed.html',
                                 plot_script1=script1,
                                 plot_div1=div1,
                                 plot_script2=script2,
                                 plot_div2=div2,
                                 plot_resources=plot_resources)
    return encode_utf8(html)
def bokeh():

    #    but = Button(label="click me", width = 80, height = 10, button_type = 'primary')
    #
    #    def onclick():
    #        if par.text == "":
    #            par.text = "Hello! World"
    #        else:
    #            par.text = ""
    #
    #    but.on_click(onclick)
    #    par = Paragraph(text="", width = 80, height = 61, style = {'background-color':'#F2F3F4'})
    #    grid = column(but, Div(text = "", width = 10, height = 100), par)
    #
    #    js_resources = INLINE.render_js()
    #    css_resources = INLINE.render_css()

    # render template
    #    script, div = components(grid)
    script = server_document(url="http://localhost:5006/bokeh_code")
    html = render_template('index.html', plot_script=script)
    #                           div=div, js_resources=js_resources, css_resources=css_resources)
    return encode_utf8(html)
示例#41
0
def balances():
    if not current_user.is_authenticated:
        return redirect(url_for("user.login"))

    user_id = current_user.user_id

    # grab the static resources
    js_resources = INLINE.render_js()
    css_resources = INLINE.render_css()

    # render template
    script, div = components(plot_balance_report(user_id))
    html = render_template("report/balances.html",
                           plot_script=script,
                           plot_div=div,
                           js_resources=js_resources,
                           css_resources=css_resources,
                           title="Остатки на счетах",
                           current_month=get_current_month()["name"],
                           last_month=get_last_month()["name"],
                           accounts_list=sorted(
                               data_observer.get_all_account_names(user_id)))
    return encode_utf8(html)
示例#42
0
def example():
    ticker = (request.form['ticker'])#new
    start = dt.datetime(2019,1,1)
    end = dt.datetime(2019,1,31)

    #PULL DATA FROM WEB
    df = web.DataReader(ticker, 'yahoo', start, end) #TSLA = tesla
    ds = ColumnDataSource(df) #allows for calling the date as index below
    #output_file("lines.html") ##if using this, add "from bokeh.plotting import figure, **output_file**, show
    
    TOOLS="hover,crosshair,pan,wheel_zoom,box_zoom,reset,tap,save,box_select,poly_select,lasso_select"
    p = figure(title="Stock price (adjusted close) for ticker '" + ticker + "', 2019 Jan 1 - 2019 Jan 31", x_axis_type='datetime', x_axis_label='Date', y_axis_label='Adjusted Closing Price', tools=TOOLS)
    p.xaxis.formatter=DatetimeTickFormatter(
            hours=["%d %B %Y"],
            days=["%d %B %Y"],
            months=["%d %B %Y"],
            years=["%d %B %Y"],
        )
    p.xaxis.major_label_orientation = pi/4
    p.line(source=ds, x='Date', y='Adj Close')
    p.circle(source=ds, x='Date', y='Adj Close')


    # grab the static resources
    js_resources = INLINE.render_js()
    css_resources = INLINE.render_css()

    # render template
    script, div = components(p)
    html = render_template(
        'index.html',
        plot_script=script,
        plot_div=div,
        js_resources=js_resources,
        css_resources=css_resources,
    )
    return encode_utf8(html)
示例#43
0
def polynomial():
    """ Very simple embedding of a polynomial chart

    """

    # Grab the inputs arguments from the URL
    # This is automated by the button
    args = flask.request.args

    # Get all the form arguments in the url with defaults
    color = colors[getitem(args, 'color', 'Black')]
    _from = int(getitem(args, '_from', 0))
    to = int(getitem(args, 'to', 10))

    # Create a polynomial line graph
    x = list(range(_from, to + 1))
    fig = figure(title="Polynomial")
    fig.line(x, [i**2 for i in x], color=color, line_width=2)

    # Configure resources to include BokehJS inline in the document.
    # For more details see:
    #   http://bokeh.pydata.org/en/latest/docs/reference/resources_embedding.html#bokeh-embed
    js_resources = INLINE.render_js()
    css_resources = INLINE.render_css()

    # For more details see:
    #   http://bokeh.pydata.org/en/latest/docs/user_guide/embedding.html#components
    script, div = components(fig, INLINE)
    html = flask.render_template('embed.html',
                                 plot_script=script,
                                 plot_div=div,
                                 js_resources=js_resources,
                                 css_resources=css_resources,
                                 color=color,
                                 _from=_from,
                                 to=to)
    return encode_utf8(html)
示例#44
0
    def get(self, *args, **kwargs):
        session = yield self.get_session()

        element_id = self.get_argument("bokeh-autoload-element", default=None)
        if not element_id:
            self.send_error(status_code=400, reason='No bokeh-autoload-element query parameter')
            return

        resources = self.application.resources()

        # TODO: yes, this should resuse code from bokeh.embed more directly
        render_items = [dict(sessionid=session.id, elementid=element_id, use_for_title=False)]
        script = _script_for_render_items(None, render_items, wrap_script=False)

        js = AUTOLOAD_JS.render(
            js_urls = resources.js_files,
            css_urls = resources.css_files,
            js_raw = resources.js_raw + [script],
            css_raw = resources.css_raw_str,
            elementid = element_id,
        )

        self.set_header("Content-Type", 'application/javascript')
        self.write(encode_utf8(js))
示例#45
0
def index():
    # Create layout
    c_map = climate_map()
    ts = timeseries()
    l = legend()
    t = title()

    map_legend = hplot(c_map, l)
    layout = vplot(t, map_legend, ts)

    plot_resources = RESOURCES.render(
        js_raw=INLINE.js_raw,
        css_raw=INLINE.css_raw,
        js_files=INLINE.js_files,
        css_files=INLINE.css_files,
    )
    script, div = components(layout, INLINE)
    html = flask.render_template(
        'embed.html',
        plot_script=script,
        plot_div=div,
        plot_resources=plot_resources,
    )
    return encode_utf8(html)
示例#46
0
def html_for_render_items(comm_js,
                          docs_json,
                          render_items,
                          template=None,
                          template_variables={}):
    comm_js = wrap_in_script_tag(comm_js)

    json_id = make_id()
    json = escape(serialize_json(docs_json), quote=False)
    json = wrap_in_script_tag(json, "application/json", json_id)

    script = wrap_in_script_tag(script_for_render_items(json_id, render_items))

    context = template_variables.copy()

    context.update(
        dict(
            title='',
            bokeh_js=comm_js,
            plot_script=json + script,
            docs=render_items,
            base=NB_TEMPLATE_BASE,
            macros=MACROS,
        ))

    if len(render_items) == 1:
        context["doc"] = context["docs"][0]
        context["roots"] = context["doc"].roots

    if template is None:
        template = NB_TEMPLATE_BASE
    elif isinstance(template, string_types):
        template = _env.from_string("{% extends base %}\n" + template)

    html = template.render(context)
    return encode_utf8(html)
示例#47
0
def bokeh():
    global data_received
    import logging
    logging.warn("data %s" % data_received)
    div = handle_data_recieved(data_received)
    # grab the static resources
    js_resources = INLINE.render_js()
    css_resources = INLINE.render_css()
    titles = [
        "Biểu đồ thống kê số lượng vi phạm theo giờ trong ngày",
        "Biểu đồ thống kê số lượng vi phạm theo ngày trong tuần",
        "Biểu đồ thống kê số lượng vi phạm của từng loại phương tiện",
        "Biểu đồ thống kê 10 bộ số xuất hiện thường xuyên",
        "Biểu đồ thống kê 10 bộ số xuất hiện không thường xuyên"
    ]
    # render template
    html = render_template(
        'index.html',
        titles=titles,
        plot_div=div,
        js_resources=js_resources,
        css_resources=css_resources,
    )
    return encode_utf8(html)
示例#48
0
def graph():
    text = request.form.get('stock-ticker')
    ti = text.upper()

    mon = request.form.get('mon')
    yr = request.form.get('yr')
    day = '01'
    if mon == '01':
        mon2 = '12'
        yr2 = yrs[yrs.index(yr) - 1]
    else:
        mon2 = months[months.index(mon) -
                      1]  #making the selection the previous month
        yr2 = yr
    d1 = '%s-%s-%s' % (yr, mon, day)
    d2 = '%s-%s-%s' % (yr2, mon2, day)

    # grab the static resources
    js_resources = INLINE.render_js()
    css_resources = INLINE.render_css()

    plot = create_stock_plot(ti, d1, d2)
    script, div = components(plot)

    html = render_template('graph.html',
                           stock_ticker=ti,
                           plot_script=script,
                           plot_div=div,
                           js_resources=js_resources,
                           css_resources=css_resources)

    if ti:
        return encode_utf8(html)
        #return render_template('graph3.html', stock_ticker=ti, script=script, div=div)
    else:
        return 'Please enter a valid stock ticker', 400
示例#49
0
def root():
    """ Returns the spectrogram of audio data served from /data """

    spectrogram = make_spectrogram()

    resources = Resources("inline")
    plot_resources = RESOURCES.render(
        js_raw = resources.js_raw,
        css_raw = resources.css_raw,
        js_files = resources.js_files,
        css_files = resources.css_files,
    )

    plot_script, plot_div = components(
        spectrogram, resources
    )

    html = flask.render_template(
        "spectrogram.html",
        plot_resources = plot_resources,
        plot_script = plot_script,
        plot_div = plot_div,
    )
    return encode_utf8(html)
示例#50
0
def index():
    args = flask.request.args
    selected_team = flask.request.values.get("selected_team", "LAA")
    selected_year = int(flask.request.values.get("selected_year", "2012"))

    p = create_plot(selected_team, selected_year)
    plot_resources = RESOURCES.render(
        js_raw=INLINE.js_raw,
        css_raw=INLINE.css_raw,
        js_files=INLINE.js_files,
        css_files=INLINE.css_files,
    )
    script, div = components(p, INLINE)
    html = flask.render_template(
        'embed.html',
        plot_script=script,
        plot_div=div,
        plot_resources=plot_resources,
        selected_team=selected_team,
        selected_year=selected_year,
        years=distinct_years,
        teams=distinct_teams,
    )
    return encode_utf8(html)
示例#51
0
def plotDataset(ds,template='dataset.html',title='Dataset',color=None,*args, **kwargs):

    ds = ds.copy()
    ds.data.columns = ds.data.columns.astype(str)


    # ts = TimeSeries(ds.data)

    numlines=len(ds.data.columns)

    if color is None:
        color = ds.meta[ds.meta.columns[0]]
    label = color
    color = colorby(color)

    # print color

    # source = ColumnDataSource(data=ds.data)
    source = ColumnDataSource(dict(xs=[ds.data.index.values]*ds.data.shape[1],
                ys = [ds.data[name].values for name in ds.data], yslog = [np.log2(ds.data[name].values) for name in ds.data], color=color, label=label))

    labelsource = ColumnDataSource(ds.meta)
    colorsource = ColumnDataSource({k:colorby(ds.meta[k]) for k in ds.meta.columns.tolist()})


    # if color is None:
    #     # color = viridis(numlines)
    #     color = colorby(range(numlines))
    # else:
    #     # v = viridis(max(color)+1)
    #     # color = [v[c] for c in color]
    #     color = colorby(color)

    fig = figure(title=title,plot_width=97*8,)
    # plot = Plot()
    # fig.line(ds.data.index.values, ds.data, line_width=2)

    # fig.multi_line(xs=[ds.data.index.values]*ds.data.shape[1],
    #             ys = [ds.data[name].values for name in ds.data],
    #             line_color=color,
    #             line_width=5)
    fig.multi_line('xs', 'ys', color='color', legend='label', source=source)

    fig.legend.location = "top_left"

    # glyph = MultiLine(xs="xs", ys="ys", line_color="", line_width=2)
    # fig.add_glyph(source, glyph)
    # plot.add_glyph(source, glyph)

    callback = CustomJS(args=dict(source=source,colorsource=colorsource,labelsource=labelsource), code="""
        var data = source.get('data');
        var data2 = colorsource.get('data');
        var data3 = labelsource.get('data');
        var f = cb_obj.get('value')

        color = data['color']
        color2 = data2[f]

        label = data['label']
        label2 = data3[f]

        for (i = 0; i < color.length; i++) {
            color[i] = color2[i]
            label[i] = label2[i]
        }

        source.trigger('change');
    """)

    logcallback = CustomJS(args=dict(source=source), code="""
        var data = source.get('data');

        data['ys'] = data['yslog']

        source.trigger('change');
    """)


    menu = [(c,c) for c in ds.meta.columns]
    dropdown = Dropdown(label="Color by", button_type="warning", menu=menu, callback=callback)

    # layout = vform(dropdown, fig)
    layout = column(dropdown, fig)

    js_resources = INLINE.render_js()
    css_resources = INLINE.render_css()

    # script, div = components(ts)
    script, div = components(layout)
    # script, div = components(fig)

    html = render_template(
        template,
        plot_script=script,
        plot_div=div,
        js_resources=js_resources,
        css_resources=css_resources,
        *args, **kwargs
    )
    return encode_utf8(html)
def heatmap():
    selector_data = get_selector_data()  # generate/retrieve data for selector menu
    default_data = {'building': '6', 'point': '305', 'from': '2017-08-18', 'to': '2017-08-30'}
    html = render_template('heatmap.html', selector_data=selector_data, data=default_data)
    return encode_utf8(html)
示例#53
0
def graphs_input():
    if request.method == 'POST':
        topic = request.form['topic']
        sentence = request.form['sentence']

        if sentence != '':
            sentence = str(sentence)
            with open('../pickles/lda_model_' + identifier + '.pkl',
                      'rb') as f:
                lda_model = pickle.load(f)

            bow = lda_model.id2word.doc2bow(sentence.split(' '))
            topics = lda_model[bow]

            topic = 0
            prob = 0
            for topic_and_prob in topics:
                temp_topic = topic_and_prob[0]
                temp_prob = topic_and_prob[1]
                if temp_prob > prob:
                    topic = temp_topic
                    prob = temp_prob
            topic += 1
        else:
            topic = int(topic)

        script, div = get_components(topic=topic)

        with open('../pickles/topic_dict_' + identifier + '.pkl', 'rb') as f:
            topic_dict = pickle.load(f)

        dates = topic_dict[topic]['date_published']
        df = pd.DataFrame({'date_published': pd.Series(dates)})
        df = df[df['date_published'] > date(2017, 5, 18)]
        df = df['date_published'].dt.date.value_counts()
        max_date = df.index[np.argmax(df.values)]

        # script, div = make_bokeh_plot(topic_dict, topic)

        anger_tones = topic_dict[topic]['Anger']
        disgust_tones = topic_dict[topic]['Disgust']
        fear_tones = topic_dict[topic]['Fear']
        joy_tones = topic_dict[topic]['Joy']
        sadness_tones = topic_dict[topic]['Sadness']
        analytical_score = topic_dict[topic]['Analytical']

        tone_mean = []
        for i in range(5):
            tone_mean.append(np.mean(anger_tones))
            tone_mean.append(np.mean(disgust_tones))
            tone_mean.append(np.mean(fear_tones))
            tone_mean.append(np.mean(joy_tones))
            tone_mean.append(np.mean(sadness_tones))

        colors = ['red', 'green', 'purple', 'yellow', 'blue']
        tone = ['Anger', 'Disgust', 'Fear', 'Joy', 'Sadness']
        idx = np.argmax(tone_mean)

        js_resources = INLINE.render_js()
        css_resources = INLINE.render_css()

        html = render_template(
            'graphs_input.html',
            js_resources=js_resources,
            css_resources=css_resources,
            script=script,
            div=div,
            topic_num=topic,
            word_cloud='src="../static/img/wordclouds/wordcloud_topic' +
            str(topic) + '_' + identifier + '.png"',
            mood_plot='src="../static/img/mood_plots/mood_by_site_plot_by_topic'
            + str(topic) + '_' + identifier + '.png"',
            pos_neg_plot=
            'src="../static/img/pos_neg_plots/pos_neg_by_site_plot_by_topic' +
            str(topic) + '_' + identifier + '.png"',
            tone_mean="{0:.1f}".format(tone_mean[idx] * 100),
            tone=tone[idx],
            color='color="' + colors[idx] + '"',
            max_date=max_date,
            date_plot='src="../static/img/coverage_plots/coverage_plot_by_topic'
            + str(topic) + '_' + identifier + '.png"')
        return encode_utf8(html)
示例#54
0
def test_file_html_handles_css_only_resources():
    css_resources = CSSResources(mode="relative", components=["bokeh"])
    template = Template("<head>{{ bokeh_css }}</head><body></body>")
    output = embed.file_html(_embed_test_plot, (None, css_resources), "title", template=template)
    html = encode_utf8("<head>%s</head><body></body>" % css_resources.render_css())
    assert output == html
示例#55
0
def plot_page(df, columns, request, page):
    """Render the Bokeh plot.

    Inputs
    ------
    df : pd.DataFrame
      The DataFrame with the data
    columns : list
      Which columns to use for choices in the plot
    request : flask
      The request object from flask
    page : str ('plot', 'plot_exo')
      Which page to render (for combined ['plot_exo'] or just SWEET-Cat ['plot'])

    Output
    ------
    The rendered page with the plot
    """
    colorscheme = 'Plasma'
    if request.method == 'POST':  # Something is being submitted
        color = request.form['color']
        x = str(request.form['x'])
        y = str(request.form['y'])
        z = str(request.form['z'])
        z = None if z == 'None' else z

        if (x not in columns) or (y not in columns):
            return redirect(url_for(page))
        if (z is not None) and (z not in columns):
            return redirect(url_for(page))

        colorscheme = str(request.form.get('colorscheme', colorscheme))
        if colorscheme not in colorschemes.keys():
            return redirect(url_for(page))

        checkboxes = request.form.getlist("checkboxes")
        if not checkboxes:  # When [] is returned
            checkboxes = ['']
        if checkboxes[0] not in [[], '', 'h**o']:
            return redirect(url_for(page))

        df, x, y, z = extract(df, x, y, z, checkboxes)

        # Setting the limits
        x1, x2, y1, y2 = get_limits(request.form, x, y)

        if x.name != session.get('x', None):
            x1 = min(x)
            x2 = max(x)
            session['x'] = x.name
        if y.name != session.get('y', None):
            y1 = min(y)
            y2 = max(y)
            session['y'] = y.name

        xscale = str(request.form['xscale'])
        yscale = str(request.form['yscale'])
        if xscale not in ['linear', 'log']:
            return redirect(url_for(page))
        if yscale not in ['linear', 'log']:
            return redirect(url_for(page))

    else:
        if page == "plot_exo":
            x = 'discovered'
            y = 'plMass'
            z = None
            x1, x2 = 1985, 2020
            y1, y2 = 0.0001, 200
            session['x'] = 'discovered'
            session['y'] = 'plMass'
            session['z'] = 'None'
        else:
            x = 'teff'
            y = 'lum'
            z = 'logg'
            x1, x2 = 8000, 2500
            y1, y2 = 1e-3, 3000
            session['x'] = 'teff'
            session['y'] = 'lum'
            session['z'] = 'logg'
        yscale = 'log'
        color = 'Orange'
        xscale = 'linear'
        checkboxes = []
        df, x, y, z = extract(df, x, y, z, checkboxes)

    # Check scale
    xscale, yscale, error = check_scale(x, y, xscale, yscale)

    stars = df['Star']
    stars = list(stars.values)  # Turn series into list.
    hover = HoverTool(tooltips=[
        ("{}".format(x.name), "$x"),
        ("{}".format(y.name), "$y"),
        ("Star", "@star"),
    ])

    num_points = count(x, y, [x1, x2], [y1, y2])

    title = '{} vs. {}:\tNumber of objects in plot: {}'.format(
        x.name, y.name, num_points)

    tools = "crosshair,pan,wheel_zoom,box_zoom,reset,box_select,lasso_select,save".split(
        ',')
    fig = figure(title=title,
                 tools=tools + [hover],
                 plot_width=800,
                 plot_height=400,
                 toolbar_location='above',
                 x_range=[x1, x2],
                 y_range=[y1, y2],
                 x_axis_type=xscale,
                 y_axis_type=yscale)

    if z is not None:  # Add colours and a colorbar
        COLORS, pallete = colorschemes[colorscheme]
        groups = pd.qcut(z.values, len(COLORS), duplicates="drop")
        c = [COLORS[xx] for xx in groups.codes]
        source = ColumnDataSource(data=dict(x=x, y=y, c=c, star=stars))

        color_mapper = LinearColorMapper(palette=pallete,
                                         low=z.min(),
                                         high=z.max())
        color_bar = ColorBar(color_mapper=color_mapper,
                             label_standoff=12,
                             border_line_color=None,
                             location=(0, 0))
        fig.add_layout(color_bar, 'right')
        fig.circle('x',
                   'y',
                   source=source,
                   size=10,
                   color='c',
                   fill_alpha=0.2,
                   line_color=None)
        z = z.name
        fig.xaxis.axis_label = x.name
        fig.yaxis.axis_label = y.name
        color_bar.title = z
    else:  # Simple colorbar
        source = ColumnDataSource(data=dict(x=x, y=y, star=stars))
        fig.circle('x',
                   'y',
                   source=source,
                   size=10,
                   color=colors[color],
                   fill_alpha=0.2,
                   line_color=None)
        fig.xaxis.axis_label = x.name
        fig.yaxis.axis_label = y.name

    # Horizontal histogram
    hhist, hedges, hmax = scaled_histogram(x, num_points, xscale)

    ph = figure(toolbar_location=None,
                plot_width=fig.plot_width,
                plot_height=200,
                x_range=fig.x_range,
                y_range=(-hmax * 0.1, hmax),
                min_border=10,
                min_border_left=50,
                y_axis_location="right",
                x_axis_type=xscale)
    ph.xgrid.grid_line_color = None
    ph.yaxis.major_label_orientation = np.pi / 4
    ph.background_fill_color = "#fafafa"

    ph.quad(bottom=0,
            left=hedges[:-1],
            right=hedges[1:],
            top=hhist,
            color="white",
            line_color=colors[color])

    # Vertical histogram
    vhist, vedges, vmax = scaled_histogram(y, num_points, yscale)

    pv = figure(toolbar_location=None,
                plot_width=200,
                plot_height=fig.plot_height,
                x_range=(-vmax * 0.1, vmax),
                y_range=fig.y_range,
                min_border=10,
                y_axis_location="right",
                y_axis_type=yscale)
    pv.ygrid.grid_line_color = None
    pv.xaxis.major_label_orientation = np.pi / 4
    pv.background_fill_color = "#fafafa"

    pv.quad(left=0,
            bottom=vedges[:-1],
            top=vedges[1:],
            right=vhist,
            color="white",
            line_color=colors[color])

    layout = column(row(fig, pv), row(ph, Spacer(width=200, height=200)))

    js_resources = INLINE.render_js()
    css_resources = INLINE.render_css()

    script, div = components(layout)
    if error is not None:
        flash('Scale was changed from log to linear')
    html = render_template('plot.html',
                           plot_script=script,
                           plot_div=div,
                           js_resources=js_resources,
                           css_resources=css_resources,
                           color=color,
                           colors=colors,
                           x=x.name,
                           y=y.name,
                           z=z,
                           x1=x1,
                           x2=x2,
                           y1=y1,
                           y2=y2,
                           xscale=xscale,
                           yscale=yscale,
                           checkboxes=checkboxes,
                           columns=columns,
                           colorschemes=colorschemes,
                           colorscheme=colorscheme)
    return encode_utf8(html)
示例#56
0
def index():

    form = InputForm(request.form)
    if request.method == 'POST' and form.validate():
        veg, fylke, hpfra, hptil, mfra, mtil = form.veg.data, form.fylke.data, form.hpfra.data, form.hptil.data, form.mfra.data, form.mtil.data
        viseside = True
    else:
        viseside = False
        veg = 'fv241'
        fylke = '14'
        hpfra = 1
        hptil = 10
        mfra = 0
        mtil = 10000

    if hpfra == hptil:
        vegref = str(fylke) + '00' + veg + 'hp' + str(hpfra) + 'm' + str(
            mfra) + '-' + str(mtil)
    else:
        vegref = str(fylke) + '00' + veg + 'hp' + str(hpfra) + 'm' + str(
            mfra) + '-' + 'hp' + str(hptil) + 'm' + str(mtil)

    df = data.hentData(vegref)
    fig_skredtype = plot.plot_skredtype(df, vegref)
    fig_maaned = plot.plot_maaned(df, vegref)
    fig_losneområde = plot.plot_losneomrade(df, vegref)
    fig_steinmaaned = plot.plot_steinmaaned(df, vegref)
    fig_snomaaned = plot.plot_snomaaned(df, vegref)
    #fig_steinm = plot.plot_steinmaaned(df, vegref)
    fig_aar = plot.plot_aar(df, vegref)
    fig_volumomraade = plot.plot_volumomraade(df, vegref)
    fig_steinlosneomrade = plot.plot_steinlosneomrade(df, vegref)

    #grid_oversikt = gridplot([fig_skredtype, fig_maaned, fig_losneområde, fig_aar], ncols=1, plot_width=500)
    #grid_skredtype = gridplot([fig_steinmaaned, fig_snomaaned], ncols=1, plot_width=500)
    #gird_samlaplot = gridplot([], ncols=1, plot_width=500, plot_height=500)

    # grab the static resources
    js_resources = INLINE.render_js()
    css_resources = INLINE.render_css()

    # render template
    script_skredtype, div_skredtype = components(fig_skredtype)
    script_maaned, div_maaned = components(fig_maaned)
    script_aar, div_aar = components(fig_aar)
    script_steinmaaned, div_steinmaaned = components(fig_steinmaaned)
    script_snomaaned, div_snomaaned = components(fig_snomaaned)
    script_losneområde, div_losneområde = components(fig_losneområde)
    script_volumomraade, div_volumomraade = components(fig_volumomraade)
    script_steinlosneområde, div_steinlosneområde = components(
        fig_steinlosneomrade)

    html = render_template('index.html',
                           script_skredtype=script_skredtype,
                           div_skredtype=div_skredtype,
                           script_maaned=script_maaned,
                           div_maaned=div_maaned,
                           script_aar=script_aar,
                           div_aar=div_aar,
                           script_losneområde=script_losneområde,
                           div_losneområde=div_losneområde,
                           script_steinmaaned=script_steinmaaned,
                           div_steinmaaned=div_steinmaaned,
                           script_steinlosneområde=script_steinlosneområde,
                           div_steinlosneområde=div_steinlosneområde,
                           script_snomaaned=script_snomaaned,
                           div_snomaaned=div_snomaaned,
                           script_volumomraade=script_volumomraade,
                           div_volumomraade=div_volumomraade,
                           js_resources=js_resources,
                           css_resources=css_resources,
                           form=form,
                           vegref=vegref,
                           viseside=viseside)

    return encode_utf8(html)
示例#57
0
def map_ptsd():
    # Grab the inputs arguments from the URL
    args = flask.request.args

    # Get all the form arguments in the url with defaults
    metric = getitem(args, 'metric', 'PTSD Rate')
    year = getitem(args, 'year', '2014')

    # connect to database
    eng = create_engine("mysql://%s:%s@localhost/va_open" %
                        (os.getenv("MYSQL_USER"), os.getenv("MYSQL_PASS")))

    # execute query
    with open('ptsd_rate_by_state.sql', 'r') as fid:
        ptsd_table = pd.read_sql_query(fid.read(), eng)

    # separate years
    p14 = ptsd_table.query('year == 2014').reset_index(drop=True)
    p15 = ptsd_table.query('year == 2015').reset_index(drop=True)

    col_add = ['total_served', 'total_ptsd']
    if year == '2014':
        ptsd_table = p14
    elif year == '2015':
        ptsd_table = p15
    elif year == '2015+2014':
        ptsd_table = p15
        ptsd_table[col_add] += p14[col_add]

    # get the state boundaries
    state_table = pd.DataFrame(us_states.data).T

    # merge tables
    ptsd_table = pd.merge(state_table,
                          ptsd_table,
                          how='inner',
                          left_index=True,
                          right_on='state')
    ptsd_table['ptsd_rate'] = (100 * ptsd_table.total_ptsd /
                               ptsd_table.total_served)

    # create data source for map
    src = ColumnDataSource({
        'lons': ptsd_table['lons'].tolist(),
        'lats': ptsd_table['lats'].tolist(),
        'ptsd_rate': ptsd_table['ptsd_rate'],
        'total_served': ptsd_table['total_served'],
        'total_ptsd': ptsd_table['total_ptsd'],
        'name': ptsd_table['name']
    })

    # generate color map
    cmap = LinearColorMapper(palette=palette)

    # create figure
    us_map = figure(width=1200,
                    x_axis_location=None,
                    y_axis_location=None,
                    tools="hover",
                    title="Rates of Post Traumatic Stress (2015)")
    us_map.grid.grid_line_color = None
    us_map.patches('lons',
                   'lats',
                   source=src,
                   line_color='black',
                   fill_color={
                       'field': metric,
                       'transform': cmap
                   })
    us_map.x_range = Range1d(-130, -60)
    us_map.y_range = Range1d(20, 55)

    # program hover tool
    hover = us_map.select_one(HoverTool)
    hover.tooltips = [("State", "@name"),
                      ("Total Veterans Enrolled", "@total_served"),
                      ("Total PTSD", "@total_ptsd (@ptsd_rate{int}%)")]

    js_resources = INLINE.render_js()
    css_resources = INLINE.render_css()

    script, div = components(us_map)
    html = flask.render_template('embed.html',
                                 plot_script=script,
                                 plot_div=div,
                                 js_resources=js_resources,
                                 css_resources=css_resources,
                                 metric=metric,
                                 year=year)
    return encode_utf8(html)
示例#58
0
def Ope():

    if not request.method in ['POST']:
        return redirect(url_for('main.index'))

    files = request.files.getlist("ope[]")
    app.logger.debug('files={}'.format(files))

    opes = []
    del_files = []
    upload_dir = current_app.config['APP_UPLOAD']

    for f in files:
        filename = secure_filename(f.filename)

        ope = os.path.join(upload_dir, filename)
        f.save(ope)
        del_files.append(ope)
        if filename.lower().endswith(".ope"):
            opes.append(ope)

    app.logger.debug('opes={}'.format(opes))

    try:
        targets = helper.ope(opes, upload_dir, app.logger)
        #errors = helper.format_error(targets, app.logger)
    except Exception as e:
        app.logger.error('Error: invalid ope file. {}'.format(e))
        err_msg = "Plot Error: {}".format(e)
        #errors.append(err_msg)
        delete_files(del_files)
        return render_template('target_visibility.html', errors=[err_msg])

    #filepath = tempfile.NamedTemporaryFile().name
    #filepath = os.path.join(current_app.config['APP_UPLOAD'], filename)

    mysite = helper.site(request.form.get('site'))
    mydate = request.form.get('date')

    #app.logger.debug('targets={}'.format(targets))
    #app.logger.debug('filepath={}'.format(filepath))
    app.logger.debug('mydate={}'.format(mydate))

    delete_files(del_files)

    try:
        #fig = helper.populate_target2(targets, mysite, mydate, filepath, app.logger)
        fig = helper.populate_interactive_target(target_list=targets,
                                                 mysite=mysite,
                                                 mydate=mydate,
                                                 logger=app.logger)
    except Exception as e:
        app.logger.error('Error: failed to populate ope plot. {}'.format(e))
        err_msg = "Plot Error: {}".format(e)
        #errors.append(err_msg)
        return render_template('target_visibility.html', errors=[err_msg])
    else:

        # Grab the static resources
        js_resources = INLINE.render_js()
        css_resources = INLINE.render_css()

        # render template
        script, div = components(fig)
        html = render_template('target_visibility.html',
                               plot_script=script,
                               plot_div=div,
                               js_resources=js_resources,
                               css_resources=css_resources,
                               errors=None)

        return encode_utf8(html)
示例#59
0
def graph():
    ajax_input = dict(x_time=[],
                      x1_time=[],
                      y=[],
                      y_female=[],
                      y_male=[],
                      x_female_proj=[],
                      y_female_proj=[],
                      x_male_proj=[],
                      y_male_proj=[],
                      y_female_avg_viewing=[],
                      y_male_avg_viewing=[])

    source = AjaxDataSource(data=ajax_input,
                            data_url='http://127.0.0.1:5000/data',
                            polling_interval=ajax_refresh_inter *
                            1000)  #adapter=adapter)

    p = figure(plot_height=300,
               plot_width=800,
               x_axis_type="datetime",
               tools="wheel_zoom,reset",
               title="People Viewing Statistics")
    p.line(x='x_time',
           y='y',
           line_dash="4 4",
           line_width=3,
           color='gray',
           source=source)
    p.vbar(x='x_time',
           top='y_female',
           width=200,
           alpha=0.5,
           color='red',
           legend='female',
           source=source)  #female
    p.vbar(x='x1_time',
           top='y_male',
           width=200,
           alpha=0.5,
           color='blue',
           legend='male',
           source=source)  #male
    p.xaxis.formatter = DatetimeTickFormatter(milliseconds=["%X"],
                                              seconds=["%X"],
                                              minutes=["%X"],
                                              hours=["%X"])
    p.y_range = DataRange1d(start=0,
                            range_padding=5)  #padding leave margin on the top
    p.legend.orientation = "horizontal"  #legend horizontal
    p.xaxis.axis_label = 'Time'
    p.yaxis.axis_label = 'Number'
    # p.x_range.follow = "end"
    # p.x_range.follow_interval = timedelta(seconds=30)

    p2 = figure(plot_height=300,
                plot_width=800,
                tools="wheel_zoom,reset",
                title="Project Viewing Statistics")
    p2.vbar(x='x_female_proj',
            top='y_female_proj',
            width=f2_vbar_interval,
            alpha=0.5,
            color='red',
            legend='female',
            source=source)  #female
    p2.vbar(x='x_male_proj',
            top='y_male_proj',
            width=f2_vbar_interval,
            alpha=0.5,
            color='blue',
            legend='male',
            source=source)  #male
    p2.xaxis.ticker = [2, 6, 10, 14]
    p2.xaxis.major_label_overrides = {2: 'P1', 6: 'P2', 10: 'P3', 14: 'P4'}

    # avg_view_male = LabelSet(x='x_male_proj', y='y_male_proj', text='y_male_avg_viewing', level='glyph',
    #           x_offset=0, y_offset=5, source=source, render_mode='canvas')
    # avg_view_female = LabelSet(x='x_female_proj', y='y_female_proj', text='y_female_avg_viewing', level='glyph',
    #           x_offset=0, y_offset=5, source=source, render_mode='canvas')
    #
    # p2.add_layout(avg_view_male)
    # p2.add_layout(avg_view_female)

    p2.x_range = DataRange1d(start=0, end=16)  #padding leave margin on the top
    p2.y_range = DataRange1d(start=0,
                             range_padding=5)  #padding leave margin on the top
    p2.legend.orientation = "horizontal"
    p2.xaxis.axis_label = 'Project'
    p2.yaxis.axis_label = 'Number'

    js_resources = INLINE.render_js()
    css_resources = INLINE.render_css()

    script, div = components((p, p2))

    html = render_template(
        'embed.html',
        plot_script=script,
        plot_div=div[0],
        plot_div2=div[1],
        js_resources=js_resources,
        css_resources=css_resources,
    )

    return encode_utf8(html)
示例#60
0
def correlation():
    "the scatter plot"

    args = flask.request.args

    xattr = args.get("x", "atomic_number")
    yattr = args.get("y", "covalent_radius_pyykko")
    categ = args.get("categ", "name_series")

    data = get_data()
    properties = get_property_names(data)
    categories = get_category_names()

    fig = Figure(title="{} vs {}".format(properties[xattr], properties[yattr]),
                 plot_width=PLOT_WIDTH,
                 plot_height=PLOT_HEIGHT,
                 tools="box_zoom,pan,resize,save,reset",
                 toolbar_location="above",
                 toolbar_sticky=False,
                 )

    fig.xaxis.axis_label = properties[xattr]
    fig.yaxis.axis_label = properties[yattr]

    ccm = get_color_mapper(categ, data)

    if categ == "None":
        legend = None
        color_dict = "#1F77B4"
    else:
        legend = categ
        color_dict = {"field": categ, "transform": ccm}

    fig.circle(x=xattr, y=yattr, fill_alpha=0.7, size=10,
               source=ColumnDataSource(data=data),
               fill_color=color_dict,
               line_color=color_dict,
               legend=legend)

    if categ != "None":
        fig.legend.location = (0, 0)
        fig.legend.plot = None
        fig.add_layout(fig.legend[0], "right")

    hover = HoverTool(tooltips=HOVER_TOOLTIPS)

    fig.add_tools(hover)

    script, div = components(fig)

    js_resources = INLINE.render_js()
    css_resources = INLINE.render_css()

    html = render_template(
        "correlations.html",
        plot_script=script,
        plot_div=div,
        properties=properties,
        categories=categories,
        xselected=xattr,
        yselected=yattr,
        catselected=categ,
        js_resources=js_resources,
        css_resources=css_resources,
    )

    return encode_utf8(html)