def polinet():

	error = None
	if request.method == 'POST':
		try:
			app_polinet.vars['pol_name'] = get_pol_name(request.form['pol_name'])
		except:
			app_polinet.vars['pol_name'] = 'Not a valid name'

	else:
		app_polinet.vars['pol_name'] = 'Bernard Sanders'


	app.vars['pol_data'] = pd.DataFrame([[1,2,3,1,3,2,4,1]])
	fig = TimeSeries(app.vars['pol_data'])

	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)

	return render_template('polinet.html',
		                   name=app_polinet.vars['pol_name'],
		                   data=app_polinet.vars['pol_data'],
		                   plot_script=script,
		                   plot_div=div,
		                   plot_resources=plot_resources)
Beispiel #2
0
def index():
	error = None
	if request.method == 'POST':
		try:
			app.vars['stock_name'] = stock_to_caps(request.form['ticker'])
			app.vars['data_table'] = get_data(app.vars['stock_name'])
		except:
			app.vars['stock_name'] = 'GOOG'
			app.vars['data_table'] = get_data('GOOG')

	else:
		app.vars['stock_name'] = 'GOOG'
		app.vars['data_table'] = get_data('GOOG')
	fig = TimeSeries(app.vars['data_table'])

	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)

	return render_template('index.html',
		                   name=app.vars['stock_name'],
		                   data=app.vars['data_table'],
		                   plot_script=script,
		                   plot_div=div,
		                   plot_resources=plot_resources)
Beispiel #3
0
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)
Beispiel #4
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)
Beispiel #5
0
def index():
    error = None
    if request.method == 'POST':
        try:
            app.vars['stock_name'] = stock_to_caps(request.form['ticker'])
            app.vars['data_table'] = get_data(app.vars['stock_name'])
        except:
            app.vars['stock_name'] = 'GOOG'
            app.vars['data_table'] = get_data('GOOG')

    else:
        app.vars['stock_name'] = 'GOOG'
        app.vars['data_table'] = get_data('GOOG')
    fig = TimeSeries(app.vars['data_table'])

    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)

    return render_template('index.html',
                           name=app.vars['stock_name'],
                           data=app.vars['data_table'],
                           plot_script=script,
                           plot_div=div,
                           plot_resources=plot_resources)
Beispiel #6
0
def wordcloud():
    req_id = cache_request()
    req = REQUESTS[req_id]

    start_years = []
    end_years = []
    for i in range(req.num_intervals):
        start_years.append(i * req.interval_len + req.year1)
        end_years.append(min(req.year2, start_years[-1] + req.interval_len))
    plot_resources = RESOURCES.render(
        js_raw=INLINE.js_raw,
        css_raw=INLINE.css_raw,
        js_files=INLINE.js_files,
        css_files=INLINE.css_files,
    )

    plot_scripts, plot_divs = req.get_bokeh_word_frequencies()
    num_docs = req.get_num_docs()
    return render_template('wordcloud.html',
                           year1=req.year1,
                           year2=req.year2,
                           words=req.stop_words,
                           req_id=req_id,
                           percent1=req.percent1,
                           percent2=req.percent2,
                           num_intervals=req.num_intervals,
                           start_years=start_years,
                           end_years=end_years,
                           plot_resources=plot_resources,
                           plot_scripts=plot_scripts,
                           plot_divs=plot_divs,
                           num_docs=num_docs,
                           side_by_side=req.side_by_side)
Beispiel #7
0
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)
Beispiel #8
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)
Beispiel #9
0
def stock_plot():
	# compute start and end time
	end_time = time.strftime('%Y-%m-%d',time.localtime(time.time()))
	start_time = time.strftime('%Y-%m-%d',time.localtime(time.time()-60*60*24*30))
	# construct API request
	req = 'https://www.quandl.com/api/v3/datasets/WIKI/'+app.vars['stock_name']+'.json?start_date='+start_time+'&end_date='+end_time
	
	# read API results using pandas
	df = pandas.read_json(req)
	df = df['dataset']
	id = df["column_names"].index('Close')
	date_id = df["column_names"].index('Date')
	data = np.asarray(df['data'])
	plot_time = data[:,date_id]
	plot_data = data[:,id]
	plot_time = np.asarray(plot_time,dtype=np.datetime64)
	plot_data = np.asarray(plot_data)

	# construct response html
	# Get all the form arguments in the url with defaults
	fig = figure(title="Closing Price of "+app.vars['stock_name'],x_axis_type="datetime")
	fig.line(plot_time, plot_data)
	fig.xaxis.axis_label = 'Date'
	fig.yaxis.axis_label = 'Closing Price'
	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)
	return render_template('stock_plot.html',stock_name = app.vars['stock_name'],plot_script=script, plot_div=div,plot_resources=plot_resources)
Beispiel #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)
Beispiel #11
0
def newapplet():
    theme = request.args.get('theme', 'default')
    INLINE = Resources(
        mode="inline",
        minified=False,
    )
    templname = "stocks_custom.html"

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

    p = create_main_plot(theme)
    plot_script, extra_divs = components({
        "main_plot":
        p,
        "selection_plot":
        create_selection_plot(p, theme),
    })
    themes = ["default", "dark"]
    options = {k: 'selected="selected"' if theme == k else "" for k in themes}

    return render_template(
        templname,
        theme=theme,
        extra_divs=extra_divs,
        plot_script=plot_script,
        plot_resources=plot_resources,
        theme_options=options,
    )
Beispiel #12
0
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)
def get_bubble_html():
    layout = _get_plot()
    with open('assets/bubble_template.html', 'r') as f:
        template = Template(f.read())
    bokeh_js = RESOURCES.render(js_raw=INLINE.js_raw)
    script, div = components(layout)
    html = template.render(
        title="Bokeh - Gapminder demo",
        bokeh_js=bokeh_js,
        plot_script=script,
        plot_div=div,
    )
    return html
Beispiel #14
0
def close_price_chart():
    global st, dates, closing_prices

    # receiving data
    st = request.form['stock_ticker']

    today = datetime.datetime.now()
    end_date = today.strftime("%Y-%m-%d")
    month_ago = today - datetime.timedelta(days=30)
    start_date = month_ago.strftime("%Y-%m-%d")

    request_str = 'https://www.quandl.com/api/v3/datasets/WIKI/%s.json/?start_date=%s&end_date=%s' % (st,start_date,end_date)

    r = requests.get(request_str)
    response_json = r.json()
    col_names = response_json['dataset']['column_names']
    all_data = pd.DataFrame(response_json['dataset']['data'], columns=col_names)
    #all_data.set_index('Date', inplace=True)

    #all_data.Close

    # constructing plot
    color = 'Black'

    dates = np.array(all_data['Date'], dtype=np.datetime64)
    closing_prices = np.array(all_data['Close'])

    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)
Beispiel #15
0
def result():
    args = session['company']
    r = rq.get('https://www.quandl.com/api/v1/datasets/WIKI/' + args['company'] + '.json')

    if not r.status_code == 200:
        flask.flash(Message)
        return flask.redirect(flask.url_for('index'))
        # return flask.render_template('welcome.html')

    company = args['company']
    data = r.json()
    price = pd.DataFrame(data['data'])
    price.columns = data['column_names']

    TOOLS = "pan,wheel_zoom,box_zoom,reset,save"

    r = figure(x_axis_type = "datetime", x_axis_label = "Time", tools=TOOLS)

    tim = [np.datetime64(i) for i in price['Date']]

    datatype = ['Close','Adj. Volume','Volume']
    for i in xrange(3):
        if datatype[i] in args.keys():
            r.line(tim, price[datatype[i]], color=colors[i], legend=company+' : '+datatype[i])

    r.title = "Stock data from Quandl WIKI set"
    r.grid.grid_line_alpha=0.3

    # 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(r, INLINE)
    html = flask.render_template(
        'result.html',
        plot_script=script, plot_div=div, plot_resources=plot_resources,
        company=company
    )
    return encode_utf8(html)
Beispiel #16
0
def get_bubble_html(plot=None):
    if plot:
        layout = plot
    else:
        layout = _get_plot()
    with open('assets/bubble_template.html', 'r') as f:
        template = Template(f.read())
    resources = Resources(mode='server', root_url='/tree/')
    bokeh_js = RESOURCES.render(js_files=resources.js_files)
    script, div = components(layout)
    html = template.render(
        title="Bokeh - Gapminder demo",
        bokeh_js=bokeh_js,
        plot_script=script,
        plot_div=div,
    )
    return html
def get_bubble_html(plot=None):
    if plot:
        layout = plot
    else:
        layout = _get_plot()
    with open('assets/bubble_template.html', 'r') as f:
        template = Template(f.read())
    resources = Resources(mode='server', root_url='/tree/')
    bokeh_js = RESOURCES.render(js_files=resources.js_files)
    script, div = components(layout)
    html = template.render(
        title="Bokeh - Gapminder demo",
        bokeh_js=bokeh_js,
        plot_script=script,
        plot_div=div,
    )
    return html
Beispiel #18
0
def newapplet():
    symbol = request.args.get('symbol', '')

    INLINE = Resources(mode="inline", minified=False,)

    if symbol:
        templname = "feat_static.html"
    else:
        symbol = 'HEMP'
        templname = "feat_home.html"

    app = StaticDash.create(symbol)
    plot_resources = RESOURCES.render(
        js_raw=INLINE.js_raw,
        css_raw=INLINE.css_raw,
        js_files=INLINE.js_files,
        css_files=INLINE.css_files,
    )

    plot_script, extra_divs = components(
        {
            "table_ranks": app.table_stocks_rank,
            "main_app": app.children[0],
            "btn_detect_pumps": app.btn_detect_pumps,
            "dlg_peaks": app.PEAKS,
        },
        INLINE
    )

    def get_id(div):
        soup = BeautifulSoup(div)
        tag=soup.div
        return soup.div.get('id')

    div_ids = {k: get_id(v) for k, v in extra_divs.items()}
    return render_template(
        templname,
        app_url = gen_config['bokeh_url'] + "/bokeh/jsgenerate/VBox/Dashboard/Dashboard",
        symbol = symbol,
        extra_divs = extra_divs,
        plot_script = plot_script,
        plot_resources=plot_resources,
        bokeh_divs_id_json = json.dumps(div_ids),
        bokeh_divs_id = div_ids
    )
Beispiel #19
0
def newapplet():
    symbol = request.args.get('symbol', '')

    INLINE = Resources(
        mode="inline",
        minified=False,
    )

    if symbol:
        templname = "feat_static.html"
    else:
        symbol = 'HEMP'
        templname = "feat_home.html"

    app = StaticDash.create(symbol)
    plot_resources = RESOURCES.render(
        js_raw=INLINE.js_raw,
        css_raw=INLINE.css_raw,
        js_files=INLINE.js_files,
        css_files=INLINE.css_files,
    )

    plot_script, extra_divs = components(
        {
            "table_ranks": app.table_stocks_rank,
            "main_app": app.children[0],
            "btn_detect_pumps": app.btn_detect_pumps,
            "dlg_peaks": app.PEAKS,
        }, INLINE)

    def get_id(div):
        soup = BeautifulSoup(div)
        tag = soup.div
        return soup.div.get('id')

    div_ids = {k: get_id(v) for k, v in extra_divs.items()}
    return render_template(templname,
                           app_url=gen_config['bokeh_url'] +
                           "/bokeh/jsgenerate/VBox/Dashboard/Dashboard",
                           symbol=symbol,
                           extra_divs=extra_divs,
                           plot_script=plot_script,
                           plot_resources=plot_resources,
                           bokeh_divs_id_json=json.dumps(div_ids),
                           bokeh_divs_id=div_ids)
Beispiel #20
0
def index():
    args = flask.request.args
    color = flask.request.values.get("color", "black")

    p = create_plot(300, np.sin, np.cos, color=color)
    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,
                                 color=color)
    return encode_utf8(html)
Beispiel #21
0
def static_html(template, resources=CDN, as_utf8=True, **kw):
    """Render static html document.

    This is a minor modification of bokeh.embed.file_html

    Args:
      template (Template): jinja2 HTML document template
      resources (Resources): a resource configuration for BokehJS assets
      kw: keyword argument list of bokeh components. Keywords must match with keywords in template
      
    Returns:
      html : standalone HTML document with embedded plot
    """
    plot_resources = RESOURCES.render(
        js_raw = resources.js_raw,
        css_raw = resources.css_raw,
        js_files = resources.js_files,
        css_files = resources.css_files,
    )

    with open (os.path.join(sml_base_path(), 'static/basic.css')) as fh:
        css = "".join(fh.readlines())

    # Hack to get on-the-fly double mapping. Can this be rewritten with e.g. map?
    def _update(kw):
        tmp = {}
        for k,v in kw.items():
            if (isinstance(v, Widget)):
                tmp.update({k : [{'script' : s, 'div' : d } for s,d in [components(v, resources)]][0]})
            elif (isinstance(v, dict)):
                if not v:
                    tmp.update(v)
                else:
                    v.update(_update(v))
            else:
                tmp.update({k:v})
        return tmp

    kw.update(_update(kw))
    if as_utf8:
        return encode_utf8(template.render(plot_resources=plot_resources, css=css, **kw))
    else:
        return template.render(plot_resources=plot_resources, css=css, **kw)
Beispiel #22
0
def index():
    if request.method == 'GET':
        return render_template('index.html')
    else:
        #request was a POST
        app.vars['ticker'] = request.form['ticker']
        app.vars['feature'] = request.form['features']

        url = 'https://www.quandl.com/api/v3/datasets/WIKI/' + str(
            app.vars['ticker']
        ) + '.json?order=asc&rows=31&start_date=2015-08-01&end_date=2015-08-31'

        r = requests.get(url)
        dat1 = json.loads(r.text)
        df = pd.DataFrame(dat1['dataset']['data'],
                          columns=dat1['dataset']['column_names'])
        df['Date'] = pd.to_datetime(df['Date'])

        if app.vars['feature'] == 'Close':
            ylab = "Closing price"
        if app.vars['feature'] == 'Adj. Close':
            ylab = "Adjusted closing price"
        if app.vars['feature'] == 'Volume':
            ylab = "Volume"

        fig = TimeSeries(df[str(app.vars['feature'])],
                         df['Date'],
                         title=str(app.vars['ticker']) + " August 2015",
                         ylabel=ylab)

    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 = render_template('index_post.html',
                           plot_script=script,
                           plot_div=div,
                           plot_resources=resources)
    return encode_utf8(html)
Beispiel #23
0
def root():
    resources = Resources("inline")
    scatter = scatter_example()

    scatter_el = VBox(children=[HBox(children=[scatter])])

    plot_script, plot_div = components(scatter_el, resources)

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

    html = render_template("test.html",
                           plot_resources=plot_resources,
                           plot_script=plot_script,
                           plot_div=plot_div)
    return encode_utf8(html)
Beispiel #24
0
    def index(self):
        args = flask.request.args

        filters = select_filter()
        pairs = select_pair()

        # Get all the form arguments in the url with defaults
        filter = int(getitem(args, 'filter', 1))
        pair = int(getitem(args, 'pair', 0))
        component = getitem(args, 'component', 'ZZ')
        format = getitem(args, 'format', 'stack')

        db = connect()
        station1, station2 = pairs[pair]['text'].replace('.','_').split(' - ')
        start, end, dates = build_ref_datelist(db)
        i, result = get_results(db,station1, station2, filter, component, dates, format=format)

        if format == 'stack':
            if i != 0:
                maxlag = float(get_config(db, 'maxlag'))
                x = np.linspace(-maxlag, maxlag, get_maxlag_samples(db))
                y = result
        db.close()

        fig = figure(title=pairs[pair]['text'], plot_width=1000)
        fig.line(x, y, line_width=2)

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

        script, div = components(fig, INLINE)
        return self.render(
            'admin/results.html',
            plot_script=script, plot_div=div, plot_resources=plot_resources,
            filter_list=filters,
            pair_list=pairs
        )
Beispiel #25
0
def index():
    args = flask.request.args
    color = flask.request.values.get("color", "black")


    p = create_plot(300, np.sin, np.cos, color=color)
    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,
        color=color
    )
    return encode_utf8(html)
Beispiel #26
0
def root():
    resources = Resources("inline")
    scatter = scatter_example()

    scatter_el = VBox(children=[HBox(children=[scatter])])

    plot_script, plot_div = components(scatter_el, resources)

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

    html = render_template("test.html",
         plot_resources = plot_resources,
         plot_script = plot_script,
         plot_div = plot_div 
        )
    return encode_utf8(html) 
Beispiel #27
0
def stock_plot():
    # compute start and end time
    end_time = time.strftime('%Y-%m-%d', time.localtime(time.time()))
    start_time = time.strftime('%Y-%m-%d',
                               time.localtime(time.time() - 60 * 60 * 24 * 30))
    # construct API request
    req = 'https://www.quandl.com/api/v3/datasets/WIKI/' + app.vars[
        'stock_name'] + '.json?start_date=' + start_time + '&end_date=' + end_time

    # read API results using pandas
    df = pandas.read_json(req)
    df = df['dataset']
    id = df["column_names"].index('Close')
    date_id = df["column_names"].index('Date')
    data = np.asarray(df['data'])
    plot_time = data[:, date_id]
    plot_data = data[:, id]
    plot_time = np.asarray(plot_time, dtype=np.datetime64)
    plot_data = np.asarray(plot_data)

    # construct response html
    # Get all the form arguments in the url with defaults
    fig = figure(title="Closing Price of " + app.vars['stock_name'],
                 x_axis_type="datetime")
    fig.line(plot_time, plot_data)
    fig.xaxis.axis_label = 'Date'
    fig.yaxis.axis_label = 'Closing Price'
    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)
    return render_template('stock_plot.html',
                           stock_name=app.vars['stock_name'],
                           plot_script=script,
                           plot_div=div,
                           plot_resources=plot_resources)
Beispiel #28
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)
Beispiel #29
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)
Beispiel #30
0
def wordcloud():
    req_id = cache_request()
    req = REQUESTS[req_id]

    start_years = []
    end_years = []
    for i in range(req.num_intervals):
        start_years.append(i*req.interval_len + req.year1)
        end_years.append(min(req.year2, start_years[-1] + req.interval_len))
    plot_resources = RESOURCES.render(
        js_raw=INLINE.js_raw,
        css_raw=INLINE.css_raw,
        js_files=INLINE.js_files,
        css_files=INLINE.css_files,
    )

    plot_scripts, plot_divs = req.get_bokeh_word_frequencies()
    num_docs = req.get_num_docs()
    return render_template('wordcloud.html', year1=req.year1, year2=req.year2, words=req.stop_words, req_id=req_id,
                           percent1=req.percent1, percent2=req.percent2, num_intervals=req.num_intervals,
                           start_years=start_years, end_years=end_years,
                           plot_resources=plot_resources, plot_scripts=plot_scripts, plot_divs=plot_divs,
                           num_docs=num_docs, side_by_side=req.side_by_side)
Beispiel #31
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)
Beispiel #32
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)
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)
Beispiel #34
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)
Beispiel #35
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)
Beispiel #36
0
def index():
  if request.method == 'GET':
    return render_template('index.html')
  else:
        #request was a POST
        app.vars['ticker'] = request.form['ticker']
        app.vars['features'] = request.form.getlist('features')
        
        #### my code from ipython notebook ####
        # set variables closing, adj_closing, volume
        ticker = app.vars['ticker']
        closing = 'Close' in app.vars['features']
        adj_closing = 'Adj. Close' in app.vars['features']
        volume = 'Volume' in app.vars['features']
        """
        f = open('%s.txt'%(app.vars['ticker']),'w')
        f.write('Ticker: %s\n'%(app.vars['ticker']))
        f.write('Features: %s\n'%(app.vars['features']))
        f.write('Include Closing: %s\n'%(closing))
        f.write('Include Adjusted Closing: %s\n'%(adj_closing))
        f.write('Include Volume: %s\n'%(volume))
        f.close()
        """        
        # import data from Quandle WIKI 
        r = requests.get('https://www.quandl.com/api/v3/datasets/WIKI/'+ticker+'.json?order=asc')

        parsed_json = json.loads(r.text)
        
        # import to dataframe
        df = pd.DataFrame(parsed_json['dataset']['data'])

        # rename columns, set date to datetime type
        df.columns = parsed_json['dataset']['column_names']
        df['Date'] = pd.to_datetime(df['Date'])

        company = parsed_json['dataset']['name'].split('.')
        company = company[0]

        def generate_close(ticker, closing):
            if closing:
                return p1.line(df['Date'], df['Close'], color='#0000FF', legend=ticker+": Close")

        def generate_adjclose(ticker,adj_closing):
            if adj_closing:
                return p1.line(df['Date'], df['Adj. Close'], color='#009933', legend=ticker+": Adj. Close")
            
        def generate_volume(ticker, volume):
            if volume:
                return p1.line(df['Date'], df['Volume'], color='#CC3300', legend=ticker+": Volume")


        from bokeh.plotting import figure, show, output_file, vplot

        output_file("stockstest.html", title=company)

        p1 = figure(x_axis_type = "datetime")

        # generate lines for the selected options
        generate_close(ticker, closing)
        generate_adjclose(ticker, adj_closing)
        generate_volume(ticker, volume)

        if not (closing or adj_closing or volume):
            generate_close(ticker, True)

        p1.title = ticker + " (Data from Quandle WIKI set)"
        p1.grid.grid_line_alpha=1.0
        p1.xaxis.axis_label = 'Date'

        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(p1, INLINE)
        html = flask.render_template(
        'index_post.html',
        plot_script=script, plot_div=div, plot_resources=plot_resources, ticker=ticker, company=company
        )
        return encode_utf8(html)
Beispiel #37
0
def index():
  if request.method == 'GET':
    return render_template('index.html')
  else:
        #request was a POST
        app.vars['ticker'] = request.form['ticker']
        app.vars['features'] = request.form.getlist('features')
        
        #### my code from ipython notebook ####
        # set variables closing, adj_closing, volume
        ticker = app.vars['ticker']
        closing = 'Close' in app.vars['features']
        adj_closing = 'Adj. Close' in app.vars['features']
        volume = 'Volume' in app.vars['features']
        """
        f = open('%s.txt'%(app.vars['ticker']),'w')
        f.write('Ticker: %s\n'%(app.vars['ticker']))
        f.write('Features: %s\n'%(app.vars['features']))
        f.write('Include Closing: %s\n'%(closing))
        f.write('Include Adjusted Closing: %s\n'%(adj_closing))
        f.write('Include Volume: %s\n'%(volume))
        f.close()
        """        
        # import data from Quandle WIKI 
        r = requests.get('https://www.quandl.com/api/v3/datasets/WIKI/'+ticker+'.json?order=asc')

        parsed_json = json.loads(r.text)
        
        # import to dataframe
        df = pd.DataFrame(parsed_json['dataset']['data'])

        # rename columns, set date to datetime type
        df.columns = parsed_json['dataset']['column_names']
        df['Date'] = pd.to_datetime(df['Date'])

        company = parsed_json['dataset']['name'].split('.')
        company = company[0]

        def generate_close(ticker, closing):
            if closing:
                return p1.line(df['Date'], df['Close'], color='#0000FF', legend=ticker+": Close")

        def generate_adjclose(ticker,adj_closing):
            if adj_closing:
                return p1.line(df['Date'], df['Adj. Close'], color='#009933', legend=ticker+": Adj. Close")
            
        def generate_volume(ticker, volume):
            if volume:
                return p1.line(df['Date'], df['Volume'], color='#CC3300', legend=ticker+": Volume")


        from bokeh.plotting import figure, show, output_file, vplot

        output_file("stockstest.html", title=company)

        p1 = figure(x_axis_type = "datetime")

        # generate lines for the selected options
        generate_close(ticker, closing)
        generate_adjclose(ticker, adj_closing)
        generate_volume(ticker, volume)

        if not (closing or adj_closing or volume):
            generate_close(ticker, True)

        p1.title = ticker + " (Data from Quandle WIKI set)"
        p1.grid.grid_line_alpha=1.0
        p1.xaxis.axis_label = 'Date'

        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(p1, INLINE)
        html = flask.render_template(
        'index_post.html',
        plot_script=script, plot_div=div, plot_resources=plot_resources, ticker=ticker, company=company
        )
        return encode_utf8(html)
Beispiel #38
0
def salt_step_peptide_analysis(dtafile_pk):

    ''' Determines how many filtered peptides are present 
        per chromatography step and draws a plot
    '''

    current_dtafile = models.DTAFile.query.get_or_404(dtafile_pk)

    dtafile_quickinfo_dict = views_helpers.get_json_response('api.dtafile_quickinfo', dtafile_pk)
    dtafile_quickinfo_dict = json.loads(dtafile_quickinfo_dict)

    dtafile_json = views_helpers.get_json_response('api.dtafile_json', dtafile_pk)
    dtafile_json = json.loads(dtafile_json)

    parent_dbsearch = models.DBSearch.query.get_or_404(dtafile_quickinfo_dict['parent_dbsearch'])
    sqt_files = parent_dbsearch.sqtfiles.all()
    parent_dataset = models.Dataset.query.get_or_404(parent_dbsearch.dataset_id)

    def get_distinct_psm_ids(dtaselect_parser):
        psms = set()
        for locus in dtaselect_parser:
            for peptide in locus['peptides']:
                psm_id = str(peptide['LCStep'])+'_'+str(peptide['Scan'])+'_'+str(peptide['ChargeState'])
                psms.add(psm_id)
        return psms

    def make_LCStep_histogram(psm_ids_set):
        full_lcstep_count = []
        for psm in psm_ids_set:
            full_lcstep_count.append(psm.split('_')[0])

        return Counter(full_lcstep_count)

    psm_ids = get_distinct_psm_ids(dtafile_json['data'])
    hist = make_LCStep_histogram(psm_ids)
    labels, values = zip(*sorted(hist.items(), key=lambda x: int(x[0])))
    labels = np.array(labels)
    values = np.array(values)

    fig = figure(title="Peptides per LC Step", y_range=[0, max(values)*1.25], plot_height=400, plot_width=700)
    fig.rect(x=labels, y=values/2, width=0.8, height=values)
    fig.xaxis.axis_label = 'chromatography step'
    fig.yaxis.axis_label = '# peptides identified'
    from bokeh.models import FixedTicker
    fig.xaxis[0].ticker.desired_num_ticks = len(labels)

    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)

    return render_template( 'plots/empty.html', 
                            dtafile_quickinfo_dict=dtafile_quickinfo_dict, 
                            current_dtafile=current_dtafile, 
                            parent_dbsearch=parent_dbsearch, 
                            sqt_files=sqt_files, 
                            parent_dataset=parent_dataset, 
                            plot_script=script, 
                            plot_div=div, 
                            plot_resources=plot_resources, 
                            # color=color, 
                            # _from=_from, 
                            # to=to, 
                            )
Beispiel #39
0
def stock_plot():
    """30-day price history for a user-provided stock ticker"""
    # Grab the inputs arguments from the URL
    # This is automated by the button
    args = flask.request.args

    # Set default for ticker
    ticker = getitem(args, 'ticker', 'TWTR')
    url = 'https://www.quandl.com/api/v1/datasets/WIKI/' + ticker + '.json'
    r = requests.get(url)
    if (type(r.json().get('error')) == unicode):
        # any returned error message means there's uh, an error
        return flask.render_template('error.html')
    else:
        # otherwise, we've got our stock
        ticker_data = r.json().get('data')

        # highly silly way to extract the full company name from the data
        ticker_company_name = r.json().get('name')
        ticker_company_name = \
         ticker_company_name[0:(ticker_company_name.find(')'))+1]
        # gather column names
        ticker_columns = r.json().get('column_names')
        # and chuck everything into a DataFrame
        temp_df = pd.DataFrame(ticker_data, columns=ticker_columns)
        # then pare down for the DataFrame we'll use
        df = temp_df[['Date', 'Open', 'Close', 'Low', 'High']]
        df.columns = ['date', 'open', 'close', 'low', 'high']
        df["date"] = pd.to_datetime(df["date"])
        df.index = df.date

        # various gyrations to grab the last month worth of data
        # find the last day in the data
        lastdate = df['date'][0]
        # set the first date to one month back from the last date
        firstdate = lastdate - pd.DateOffset(months=1)
        # then grab the last month worth of data
        df = df[lastdate:firstdate]

        # calculations associated with generating candlesticks, taken from:
        # http://bokeh.pydata.org/en/latest/docs/gallery/candlestick.html
        mids = (df.open + df.close) / 2
        spans = abs(df.close - df.open)
        inc = df.close > df.open
        dec = df.open > df.close
        # set candlestick duration (in ms)
        w = 24 * 60 * 60 * 1000

        # configure plot
        TOOLS = "pan,wheel_zoom,box_zoom,reset,save"
        p = figure(title=ticker + " Daily Candles", x_axis_type="datetime", \
         tools=TOOLS, plot_width=1000, toolbar_location="left")
        p.segment(df.date, df.high, df.date, df.low, color="black")
        p.rect(df.date[inc], mids[inc], w, spans[inc], fill_color="#abdb8d", \
         line_color="black")
        p.rect(df.date[dec], mids[dec], w, spans[dec], fill_color="#F2583E", \
         line_color="black")
        p.title = ticker_company_name + ' Daily Candles'
        p.xaxis.major_label_orientation = pi / 4
        p.grid.grid_line_alpha = 0.3
        p.xaxis.axis_label = 'Date'
        p.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(p, INLINE)
        html = flask.render_template('embed.html',
                                     plot_script=script,
                                     plot_div=div,
                                     plot_resources=plot_resources,
                                     ticker=ticker)
        return encode_utf8(html)
Beispiel #40
0
def stock():
    stockcode = request.args.get('stockcode')
    stockperiod = str(request.args.get('period'))

    if stockcode and stockcode.strip():
        #request data from QuanDL
        baseURL = 'https://www.quandl.com/api/v1/datasets/WIKI/'
        periodURL = {
            '1M':
            '?trim_start=' +
            (datetime.datetime.now() -
             datetime.timedelta(days=30)).strftime('%Y-%m-%d'),
            '6M':
            '?trim_start=' +
            (datetime.datetime.now() -
             datetime.timedelta(days=183)).strftime('%Y-%m-%d'),
            '1Y':
            '?trim_start=' +
            (datetime.datetime.now() -
             datetime.timedelta(days=365)).strftime('%Y-%m-%d'),
            'All':
            '',
            'None':
            ''
        }
        jsonURL = baseURL + stockcode + '.json' + periodURL[stockperiod]
        jsonRespond = requests.get(jsonURL)
        HTTPstatusCode = jsonRespond.status_code

        print '[URL]      ' + jsonURL
        print '[HTTP]     ' + str(HTTPstatusCode)
        print '[Stockcode]' + stockcode
        print '[Period]   ' + stockperiod

        #parse data if HTTP Status is OK
        if HTTPstatusCode == 200:
            jheader = (jsonRespond.json())['column_names']
            jdata = (jsonRespond.json())['data']
            stockdata = pd.DataFrame(jdata, columns=jheader)
            stockdata["Date"] = pd.to_datetime(stockdata["Date"])
            print stockdata.head()

            #To calculate the positions of the bars
            mids = (stockdata.Open + stockdata.Close) / 2
            spans = abs(stockdata.Close - stockdata.Open)
            #To check the up/down of the day to determin the bar color
            inc = stockdata.Close > stockdata.Open
            dec = stockdata.Open > stockdata.Close

            w = 12 * 60 * 60 * 1000  # half day in ms

            #Render Chart
            fig = figure(
                title=None,
                plot_width=600,
                plot_height=480,
                x_axis_type="datetime",
                toolbar_location="below",
                tools="crosshair, pan,wheel_zoom,box_zoom,reset,resize")

            fig.segment(stockdata.Date,
                        stockdata.High,
                        stockdata.Date,
                        stockdata.Low,
                        color="black")
            fig.rect(stockdata.Date[inc],
                     mids[inc],
                     w,
                     spans[inc],
                     fill_color="#D5E1DD",
                     line_color="black")
            fig.rect(stockdata.Date[dec],
                     mids[dec],
                     w,
                     spans[dec],
                     fill_color="#F2583E",
                     line_color="black")

            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 = render_template('stock.html',
                                   status={
                                       'code': 1,
                                       'msg': 'OK'
                                   },
                                   stock={
                                       'code': stockcode,
                                       'period': stockperiod
                                   },
                                   plot={
                                       'script': script,
                                       'div': div,
                                       'resources': plot_resources
                                   })
        else:
            html = render_template('stock.html',
                                   status={
                                       'code': 2,
                                       'msg': 'Server Error'
                                   },
                                   stock={
                                       'code': stockcode,
                                       'period': stockperiod
                                   })
    else:
        html = render_template('stock.html',
                               status={
                                   'code': 3,
                                   'msg': 'Please Enter a Stockcode'
                               },
                               stock={
                                   'code': 'None',
                                   'period': 'None'
                               })

    return html
Beispiel #41
0
def stock():
    stockcode = request.args.get("stockcode")
    stockperiod = str(request.args.get("period"))

    if stockcode and stockcode.strip():
        # request data from QuanDL
        baseURL = "https://www.quandl.com/api/v1/datasets/WIKI/"
        periodURL = {
            "1M": "?trim_start=" + (datetime.datetime.now() - datetime.timedelta(days=30)).strftime("%Y-%m-%d"),
            "6M": "?trim_start=" + (datetime.datetime.now() - datetime.timedelta(days=183)).strftime("%Y-%m-%d"),
            "1Y": "?trim_start=" + (datetime.datetime.now() - datetime.timedelta(days=365)).strftime("%Y-%m-%d"),
            "All": "",
            "None": "",
        }
        jsonURL = baseURL + stockcode + ".json" + periodURL[stockperiod]
        jsonRespond = requests.get(jsonURL)
        HTTPstatusCode = jsonRespond.status_code

        print "[URL]      " + jsonURL
        print "[HTTP]     " + str(HTTPstatusCode)
        print "[Stockcode]" + stockcode
        print "[Period]   " + stockperiod

        # parse data if HTTP Status is OK
        if HTTPstatusCode == 200:
            jheader = (jsonRespond.json())["column_names"]
            jdata = (jsonRespond.json())["data"]
            stockdata = pd.DataFrame(jdata, columns=jheader)
            stockdata["Date"] = pd.to_datetime(stockdata["Date"])
            print stockdata.head()

            # To calculate the positions of the bars
            mids = (stockdata.Open + stockdata.Close) / 2
            spans = abs(stockdata.Close - stockdata.Open)
            # To check the up/down of the day to determin the bar color
            inc = stockdata.Close > stockdata.Open
            dec = stockdata.Open > stockdata.Close

            w = 12 * 60 * 60 * 1000  # half day in ms

            # Render Chart
            fig = figure(
                title=None,
                plot_width=600,
                plot_height=480,
                x_axis_type="datetime",
                toolbar_location="below",
                tools="crosshair, pan,wheel_zoom,box_zoom,reset,resize",
            )

            fig.segment(stockdata.Date, stockdata.High, stockdata.Date, stockdata.Low, color="black")
            fig.rect(stockdata.Date[inc], mids[inc], w, spans[inc], fill_color="#D5E1DD", line_color="black")
            fig.rect(stockdata.Date[dec], mids[dec], w, spans[dec], fill_color="#F2583E", line_color="black")

            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 = render_template(
                "stock.html",
                status={"code": 1, "msg": "OK"},
                stock={"code": stockcode, "period": stockperiod},
                plot={"script": script, "div": div, "resources": plot_resources},
            )
        else:
            html = render_template(
                "stock.html",
                status={"code": 2, "msg": "Server Error"},
                stock={"code": stockcode, "period": stockperiod},
            )
    else:
        html = render_template(
            "stock.html",
            status={"code": 3, "msg": "Please Enter a Stockcode"},
            stock={"code": "None", "period": "None"},
        )

    return html
Beispiel #42
0
import bokeh
from bokeh.embed import components
from bokeh.plotting import figure
from bokeh.resources import INLINE
from bokeh.templates import RESOURCES
from bokeh.io import vplot, hplot
import numpy as np


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


def plot_table_by_time(table):
    plots = []
    table = table.set_index('time')
    for col in table:
        s = table[col]
        s.dropna(inplace=True)
        if not np.isscalar(s.values[0]):
            # replace with the sum
            s = s.apply(np.sum)
        x_range = plots[0].x_range if plots else None
        fig = figure(title=col, x_axis_type='datetime', x_range=x_range)
        fig.line(s.index, s, line_width=2)
        fig.circle(s.index, s, fill_color='white', size=8)
        plots.append(fig)
        {{ plot_resources }}
    </head>
    <body>
    <h2>Resize the window to see some plots resizing</h2>
    <h3>Red - pan with responsive</h3>
    {{ plot_div.red }}
    <h3>Green - pan with resize & responsive (should maintain new aspect ratio)</h3>
    {{ plot_div.green }}
    <h3>Blue - pan no responsive</h3>
    {{ plot_div.blue }}

    {{ plot_script }}
    </body>
</html>
''')

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,
)
script, div = components({'red': red, 'blue': blue, 'green': green})
html = template.render(plot_resources=plot_resources, plot_script=script, plot_div=div)
html_file = 'embed_multiple_responsive.html'
with open(html_file, 'w') as f:
    f.write(html)

view(html_file)
Beispiel #44
0
def process():
    """
    Receive the upload smiles, process and retrieve results.
    """
    from alchemy import alchemy
    from collections import OrderedDict

    if request.method == 'POST':
        render_template('pages/process.html')

        input_file = request.files['input_file']
        background_file = request.files['background_file']
        if input_file and allowed_file(input_file.filename):
            input_filename = secure_filename(input_file.filename)
            input_file.save(os.path.join(app.config['UPLOAD_FOLDER'], input_filename))

            if background_file and allowed_file(background_file.filename):
                background_filename = secure_filename(background_file.filename)
                background_file.save(os.path.join(app.config['UPLOAD_FOLDER'], background_filename))

            # Assemble arguments
            # input_file
            args = [
                os.path.join(app.config['UPLOAD_FOLDER'], input_filename)]
            # background
            if background_file and allowed_file(background_file.filename):
                args += [
                    "-b",
                    os.path.join(app.config['UPLOAD_FOLDER'], background_filename)]
            # input_type
            args += [
                "-t",
                request.form.get('input_type')]
            # delimiter
            args += [
                "-d",
                request.form.get('delimiter')]
            # header
            # annotation_output
            # background_annotation_output
            # enrichment_output
            # enrich
            # processors
            # tmp_dir

            # start processing data
            annotated_query, enriched_query = alchemy.main(args)

            # return results

            # Bokeh graph
            fig = figure(title="Volcano plot")
            fig.scatter(enriched_query.oddsratio, enriched_query.corrected_pvalue, color="#000000")
            fig.logo = None
            fig.toolbar_location = None

            # 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)
            html = flask.render_template(
                'pages/results.html',
                plot_script=script,
                plot_div=div,
                plot_resources=plot_resources,
                compounds=OrderedDict(zip(
                    enriched_query.index, enriched_query.corrected_pvalue))
            )

            return encode_utf8(html)

    return render_template('pages/home.html')
Beispiel #45
0
def stock_plot():
	"""30-day price history for a user-provided stock ticker"""
	# Grab the inputs arguments from the URL
	# This is automated by the button
	args = flask.request.args

    # Set default for ticker
	ticker = getitem(args, 'ticker', 'TWTR')
	url = 'https://www.quandl.com/api/v1/datasets/WIKI/' + ticker + '.json'
	r = requests.get(url)
	if(type(r.json().get('error')) == unicode):
		# any returned error message means there's uh, an error
		return flask.render_template('error.html')
	else:
		# otherwise, we've got our stock
		ticker_data = r.json().get('data')
		
		# highly silly way to extract the full company name from the data
		ticker_company_name = r.json().get('name')
		ticker_company_name = \
			ticker_company_name[0:(ticker_company_name.find(')'))+1]
		# gather column names
		ticker_columns = r.json().get('column_names')
		# and chuck everything into a DataFrame
		temp_df = pd.DataFrame(ticker_data,columns=ticker_columns)
		# then pare down for the DataFrame we'll use
		df = temp_df[['Date','Open', 'Close', 'Low', 'High']]
		df.columns = ['date','open', 'close', 'low', 'high']
		df["date"] = pd.to_datetime(df["date"])
		df.index = df.date
		
		# various gyrations to grab the last month worth of data
		# find the last day in the data
		lastdate = df['date'][0]
		# set the first date to one month back from the last date
		firstdate = lastdate - pd.DateOffset(months=1)
		# then grab the last month worth of data
		df = df[lastdate:firstdate] 
		
		# calculations associated with generating candlesticks, taken from:
		# http://bokeh.pydata.org/en/latest/docs/gallery/candlestick.html
		mids = (df.open + df.close)/2
		spans = abs(df.close-df.open)
		inc = df.close > df.open
		dec = df.open > df.close
		# set candlestick duration (in ms)
		w = 24*60*60*1000 
		
		# configure plot
		TOOLS = "pan,wheel_zoom,box_zoom,reset,save"
		p = figure(title=ticker + " Daily Candles", x_axis_type="datetime", \
			tools=TOOLS, plot_width=1000, toolbar_location="left")
		p.segment(df.date, df.high, df.date, df.low, color="black")
		p.rect(df.date[inc], mids[inc], w, spans[inc], fill_color="#abdb8d", \
			line_color="black")
		p.rect(df.date[dec], mids[dec], w, spans[dec], fill_color="#F2583E", \
			line_color="black")
		p.title = ticker_company_name +' Daily Candles'
		p.xaxis.major_label_orientation = pi/4
		p.grid.grid_line_alpha=0.3
		p.xaxis.axis_label = 'Date'
		p.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(p, INLINE)
		html = flask.render_template(
			'embed.html',
			plot_script=script, plot_div=div, plot_resources=plot_resources,
			ticker=ticker
		)
		return encode_utf8(html)