Ejemplo n.º 1
0
def bar_color_by_year():
    df = odo(g.ds, pd.DataFrame)

    df1 = df.groupby(['production_year', 'color'
                      ]).size().reset_index().rename(columns={0: 'count'})
    sums = df.groupby(
        ['production_year',
         'color']).agg('size').reset_index().groupby('production_year').sum()
    df1['prc'] = df1.apply(lambda x: x[2] * 100 / sums.loc[x[0]], axis=1)

    form = CarsRelativeValuesForm(request.args, csrf_enabled=False)

    field = 'prc' if 'submit' in request.args and form.validate(
    ) and form.is_relative.data else 'count'

    p = Bar(
        df1,
        values=field,
        label='production_year',
        stack='color',
        legend=False,  #'top_right',
        title='Colors by Year of production',
        xlabel="Year",
        ylabel="Count",
    )

    p.background_fill_color = "beige"

    return render(p, dict(form=form))
Ejemplo n.º 2
0
def fnCreate_Chart_Bar1(df,strS):   
    pd.options.html.border=1 
    label1=CatAttr(columns=['Airline'], sort=False)
    plot = Bar(df, label=label1, values='Ticket Price',group='Airline', title="Average of Ticket Price- Airline wise"  + strS, legend=False,  bar_width=100, xlabel='Airlines',ylabel='Average Ticket Price')
    plot.logo=None
    script, div = components(plot,CDN)    
    return script, div 
Ejemplo n.º 3
0
def generate_chart(year):
    data = get_data(year)

    barchart = Bar(data,
                   values=blend(*SCORED_EVENTS, labels_name='event'),
                   label=cat(columns='Team', sort=False),
                   stack=cat(columns='event', sort=False),
                   color=color(columns='event', palette=Spectral9, sort=False),
                   xgrid=False, ygrid=False, legend='top_right',
                   plot_width=1000, plot_height=625,
                   tools="pan,wheel_zoom,box_zoom,reset,resize")

    barchart.title = "Formula SAE Michigan " + str(year) + " Total Scores by Place"

    barchart._xaxis.axis_label = "Teams"
    barchart._xaxis.axis_line_color = None
    barchart._xaxis.major_tick_line_color = None
    barchart._xaxis.minor_tick_line_color = None
    barchart._xaxis.major_label_text_font_size = '0.6em'

    barchart._yaxis.axis_label = "Total Score"
    barchart._yaxis.axis_line_color = None
    barchart._yaxis.major_tick_line_color = None
    barchart._yaxis.minor_tick_line_color = None

    barchart.outline_line_color = None

    barchart.toolbar_location = 'right'

    barchart.logo = None

    return barchart
def make_datasources_for_comparison(idd_dataframe, years, measure_codes):
    
    # filter out SHAx measures calculated with METH2012
    row_filter = (idd_dataframe.methodo == '0') & (idd_dataframe.measure_code.isin(measure_codes))                

    bar_charts = []
    countries = set()
    sources = {}
    
    for year in years:
        chart_data = idd_dataframe[row_filter & (idd_dataframe.year == year)]
        
        [countries.add(x) for x in chart_data.location_name.unique()]
        
        bar = Bar(data=chart_data,
                  stack='measure_name',
                  values='observation',
                  label='location_name',
                  legend='top_right',
                  bar_width=1)

        bar_charts.append(bar)
        
        base_source_df = \
            pd.concat([x.to_df() for x in bar.select(dict(type=ColumnDataSource))])
    
        sources['_' + year] = ColumnDataSource(base_source_df)  

    # return the dictionary of ColumnDataSources and 1 bar chart --
    # we want to keep a bar chart so we can reconstruct the legend, later
    return sources, bar_charts[0], countries
Ejemplo n.º 5
0
    def calculate_average_accuracy(self, confusion_matrix):
        if confusion_matrix is None:
            return None

        scores = []
        n = np.shape(confusion_matrix)[0]
        mean_acc = 0
        for index, r in enumerate(confusion_matrix):
            ss = sum(r)
            if ss != 0:
                scores.append(float(r[index]) / ss)
            

        scores = np.hstack((scores,np.mean(scores)))
        class_labels = self.class_labels[:]
        class_labels.append('average')
        data = {"accuracy": scores}
        s = Bar(data, cat=class_labels, title="Per Class Accuracy",
        xlabel='categories', ylabel='accuracy', width=500, height=500,
        tools="pan,resize,box_zoom,hover,save,reset", stacked=True, palette=["#ec5d5e"])  
        
        hover = s.select(dict(type=HoverTool))
        hover.tooltips = OrderedDict([
                         ('accuracy', '@accuracy'),
                          ])

        p = hplot(s)
        script, div = components(p)
        return (script, div)
Ejemplo n.º 6
0
def fnCreate_Chart_Bar(df):   
    pd.options.html.border=0
    
    plot = Bar(df, 'Sub_Attbt', values='FY2013', title="Total DISPL by Attribute", bar_width=0.4)
    plot.logo=None
    script, div = components(plot,CDN)    
    return script, div  
Ejemplo n.º 7
0
def plot3():
    p = figure(title='something', x_axis_label='date', x_axis_type='datetime')
    df = pd.read_csv('chart.csv')
    df3 = pd.read_csv('df3d.csv')
    output_file("stacked_bar.html")
    p = Bar(df3,
            label='Country',
            values='Population wo access water',
            stack='category',
            color=color(columns='category',
                        palette=['Orange', 'Red'],
                        sort=False),
            legend='top_right')

    script, div = components(p)
    df4 = df[df['status'] == 'water supplier']
    output_file("bar.html")
    q = Bar(df4,
            label='Country',
            values='Possible water provider',
            legend=False,
            color="Green")
    script2, div2 = components(q)
    return render_template('plot3.html',
                           script=script,
                           div=div,
                           script2=script2,
                           div2=div2)
Ejemplo n.º 8
0
    def calculate_average_accuracy(self, confusion_matrix):
        if confusion_matrix is None:
            return None

        scores = []
        n = np.shape(confusion_matrix)[0]
        mean_acc = 0
        for index, r in enumerate(confusion_matrix):
            ss = sum(r)
            if ss != 0:
                scores.append(float(r[index]) / ss)

        scores = np.hstack((scores, np.mean(scores)))
        class_labels = self.class_labels[:]
        class_labels.append('average')
        data = {"accuracy": scores}
        s = Bar(data,
                cat=class_labels,
                title="Per Class Accuracy",
                xlabel='categories',
                ylabel='accuracy',
                width=500,
                height=500,
                tools="pan,resize,box_zoom,hover,save,reset",
                stacked=True,
                palette=["#ec5d5e"])

        hover = s.select(dict(type=HoverTool))
        hover.tooltips = OrderedDict([
            ('accuracy', '@accuracy'),
        ])

        p = hplot(s)
        script, div = components(p)
        return (script, div)
Ejemplo n.º 9
0
    def plot_scores2(self):

        if self.scores is None:
            return None

        scores = np.vstack(self.scores)
        data = OrderedDict()
        for i in xrange(len(self.class_labels)):
            data[self.class_labels[i]] = scores[:2, i]
        s1 = Bar(data,
                 cat=['precision', 'recall'],
                 title="Per Class Scores",
                 width=500,
                 height=500,
                 legend=True,
                 tools="pan,resize,box_zoom,hover,save,reset")

        data = OrderedDict()
        for i in xrange(len(self.class_labels)):
            data[self.class_labels[i]] = scores[3:4, i]
        s2 = Bar(data,
                 cat=['support'],
                 title="Support",
                 width=500,
                 height=500,
                 legend=True,
                 tools="pan,resize,box_zoom,hover,save,reset")

        p = hplot(s1, s2)

        script, div = components(p)
        return (script, div)
Ejemplo n.º 10
0
def bar_response(results_list, output_path):

    output_dir = os.path.join(output_path, "charts")
    if os.path.isdir(output_dir) is False:
        os.mkdir(output_dir)

    tools = "pan,wheel_zoom,box_zoom,reset,hover,save"

    for df in results_list:
        print(df)
        p = Bar(df,
                label='hh_type',
                values='perc_res',
                stack='digital',
                title="a_title",
                legend='top_right',
                tools=tools)

        hover = p.select_one(HoverTool)
        hover.point_policy = "follow_mouse"
        hover.tooltips = [
            ("count", "@height"),
        ]
        output_file_path = os.path.join(output_dir, 'test bar.html')
        output_file(output_file_path)
        show(p)
Ejemplo n.º 11
0
def report():

    cursor = get_hive_cursor()

    if cursor is None:
        return render_template('/main/bi_connection_issue.html')

    # FIXME we probably want to create aggregates on hadoop
    #       and cache them rather than returning the whole data
    #       set here

    # we need to ignore monitoring pings which have rating user_id = -1 
    # and movie_id = -1
    try:
        cursor.execute(
            "select * from movie_ratings where customer_id <> '-1' and movie_id <> '-1'", 
            configuration={ 
                'hive.mapred.supports.subdirectories': 'true', 
                'mapred.input.dir.recursive': 'true' 
                })
    except:
        return render_template('/main/bi_connection_issue.html')

    df = as_pandas(cursor)
    
    count = df.shape[0]

    if count == 0:
       return render_template('/main/bi_no_records.html')

    from bokeh.charts import Bar, output_file, show

    fig = Bar(
            df,
            label='movie_ratings.rating',
            values='movie_ratings.rating',
            agg='count',
            title='Distribution of movie ratings',
            legend=False
            )


    fig.plot_height = 400
    fig.xaxis.axis_label = 'Rating'
    fig.yaxis.axis_label = 'Count ( Rating )'

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

    script, div = components(fig)
    html = flask.render_template(
        '/main/embed.html',
        plot_script=script,
        plot_div=div,
        js_resources=js_resources,
        css_resources=css_resources,
    )
    return encode_utf8(html)
Ejemplo n.º 12
0
def fnCreate_Chart_Bar(df):   
    pd.options.html.border=1  
#    pd.options.display.html.border=1  
    
    label1=CatAttr(columns=['Routes'], sort=False)
    plot = Bar(df, label=label1, values='Ticket Price',group='Routes', title="Average of Ticket Price- Routes wise", legend=False,  bar_width=50, xlabel='Routes',ylabel='Average Ticket Price')
    plot.logo=None
    script, div = components(plot,CDN)    
    return script, div 
Ejemplo n.º 13
0
def fnCreate_Chart_Bar_Full(df):   
    pd.options.html.border=0    
    plot = Bar(df, label='Attbt', values='FY2013', agg='sum', group='Attbt',
        title="Total Sum, grouped by Attribute", legend='top_left')
    
   # plot = Bar(df, 'Sub_Attbt', values='FY2013', title="Total DISPL by Attribute", bar_width=0.4)
    plot.logo=None
    script, div = components(plot,CDN)     
    return script, div 
Ejemplo n.º 14
0
 def goChart(label, stack_or_group, values, ylabel=None, color=None):
     convertPDFDate(workingPDF, keyFields[0])
     if ylabel is None:
         ylabel=values
     label=label if isinstance(label, (list, tuple)) else [label]
     if stacked:
         charts.append( Bar(workingPDF, label=CatAttr(columns=label, sort=False), stack=stack_or_group, color=color, values=values, legend=self.showLegend(), ylabel=ylabel))
     else:
         charts.append( Bar(workingPDF, label=CatAttr(columns=label, sort=False), group=stack_or_group, color=color, values=values, legend=self.showLegend(), ylabel=ylabel))
Ejemplo n.º 15
0
	def withbokeh(self,dfMergeWithInfo):
		from bokeh.charts import Bar, output_file, show
		details = dfMergeWithInfo["videoSid"].values.tolist()

		amount = list(dfMergeWithInfo["playCount"].astype(float).values)
		print amount
		bar = Bar(dfMergeWithInfo, filename="bar.html")
		bar.title("MN Capital Budget - 2014").xlabel("Detail").ylabel("Amount")
		show(bar)
Ejemplo n.º 16
0
def plt_barchart_grupped(data, param_dict, mode='object', output_path=None):
    '''
    data: rows = list of dicts(): keywords with neat naming straight to put in charts
    param_dict: dictionary with settings as follows:
    {'x':'name of column to put on x axis',
     'y':'name of column to put in y axis',
     'agg':'name of aggregate function: 'sum'/'count' /etc',
     'color':'name of name of column to create siloses by/to apply aggr funct',
     'tooltips':['list() of strings with column names to put in tooltip cloud']}
    mode: 'object'/'save'/'show'/'embed' - either returns plot object / saves to path + returns True / saves to path and shows plot
    output_path: string with html ext to save chart to. If None then emmbed is returned
    returns: True(saved to file) or emmbed data code
    '''
    # tooltips=[
    # ("Date", "$x"),
    # ("version", "@HVAC_version")]

    # p = Bar(data, label='Date', values='HVAC_version', agg='count', group='HVAC_version',
    # title="Median MPG by YR, grouped by ORIGIN", legend='bottom_right', bar_width=3.0,
    # plot_width=1000, plot_height=400, tooltips = tooltips)
    # p.legend.background_fill_alpha = 0.8

    # output_file("bar.html")

    # show(p)
    #to_date(data,'%Y-%m-01')
    tooltips = create_tooltips(param_dict)

    title = "{} of {} by {}, grouped by {}".format(param_dict['agg'],
                                                   param_dict['y'].upper(),
                                                   param_dict['x'].upper(),
                                                   param_dict['color'].upper())

    p = Bar(data=data,
            label=param_dict['x'],
            values=param_dict['y'],
            agg=param_dict['agg'],
            group=param_dict['color'],
            title=title,
            legend='bottom_right',
            bar_width=3.0,
            plot_width=1000,
            plot_height=600,
            tooltips=tooltips)
    #legend_sort_field = param_dict['group'])
    p.legend.background_fill_alpha = 0.8

    if type(data[0][param_dict['x']]) == str:
        x_rng = sort_axis(data, param_dict['x'], False, True)
        p.x_range = x_rng

    if type(data[0][param_dict['y']]) == str:
        y_rng = sort_axis(data, param_dict['y'], False, True)
        p.y_range = y_rng

    return do_output(p, mode, output_path)
Ejemplo n.º 17
0
def fnCreate_Chart_Bar2(df):   
    output_file("line_bar.html") 
    pd.options.html.border=0    
    plot = Bar(df, label='Attbt', values='FY2013', agg='sum', group='Attbt',
        title="Total Sum, grouped by Attribute", legend='top_left')
    
   # plot = Bar(df, 'Sub_Attbt', values='FY2013', title="Total DISPL by Attribute", bar_width=0.4)
    plot.logo=None
    show(plot) 
    return True
Ejemplo n.º 18
0
def get_user_type():
    subscriber_count = 0
    customer_count = 0
    unknown_count = 0

    start_date_range = datetime.datetime.strptime(request.form['start_date'], "%Y-%m-%d").date()
    end_date_jinja2 = datetime.datetime.strptime(request.form['stop_date'], "%Y-%m-%d").date()
    end_date_range = datetime.datetime.strptime(request.form['stop_date'], "%Y-%m-%d").date()

    date_start = str(start_date_range)
    date_stop = str(end_date_range)
    date_stop_jinja2 = str(end_date_jinja2)

    #df = get_dataframe(start_date_range, end_date_range)

    if 'submitDateFilter' in request.form:
        df = date_form(df_init, date_start, date_stop)

    if 'submit_station' in request.form:
        df = station_form(df_init, date_start, date_stop)

    if 'submit_gender' in request.form:
        df = gender_form(df_init, date_start, date_stop)

    if 'submit_age' in request.form:
        df = age_form(df_init, date_start, date_stop)

    if 'submit_time' in request.form:
        df = time_form(df_init, date_start, date_stop)

    df = df_init
    user_type_series = df['usertype'].values

    for x in user_type_series:
        if x == 'Subscriber':
            subscriber_count += 1
        elif x == 'Customer':
            customer_count += 1
        else:
            unknown_count += 1
    if unknown_count == 0:
        #customer_type = [subscriber_count, customer_count]
        df = pd.DataFrame({'User Type': ['Subscriber', 'Customer'],
                           'Type': [subscriber_count, customer_count]})
    else:
        #customer_type = [subscriber_count, customer_count, unknown_count]
        df = pd.DataFrame({'User Type': ['Subscriber', 'Customer', 'Null'],
                           'Type': [subscriber_count, customer_count, unknown_count]})
    #b = Bar(customer_type, title="Bar example", label='categories', ylabel='values', width=400, height=400)
    b = Bar(df, title="User Types", label='User Type', values='Type')
    b.select(dict(type=GlyphRenderer))
    b.left[0].formatter.use_scientific = False
    scriptb, divb = components(b)
    return render_template('userType.html', s=subscriber_count, c=customer_count, u=unknown_count,
                           d1=date_start, d2=date_stop_jinja2, scriptb=scriptb, divb=divb)
Ejemplo n.º 19
0
def plotbar(events, userid):
    """
    Arch: I tried to install bokeh 0.10.0 ver and that was
    giving a lot of errors in the Bar(method args)- StopIteration
    and also while trying to load the latest bokeh.min.js from CDN
    So I am going back to the bokeh 0.8.1 ver- at least it works
    """

    xr = [x.title for x in events]
    y1values = [y1.prefearfactor for y1 in events]
    y2values = [y2.postfearfactor for y2 in events]
    yr = OrderedDict(PredictedFear=y1values, ActualFear=y2values)
    """
    height=400
    width=600
    bar = figure(plot_width=width, plot_height=height, title="Imagined vs real")
    # use the `rect` renderer to display stacked bars of the medal results. Note
    # that we set y_range explicitly on the first renderer
    bar.rect(xr, y1values, height=0.5, width=0.4, color="red", alpha=0.6)
    bar.rect(xr, y2values, height=0.5, width=0.4, color="blue", alpha=0.6)
    """

    bar = Bar(yr,
              xr,
              xlabel="Events",
              ylabel="Fear factor",
              title="Imagined vs real fear",
              width=800,
              height=600,
              legend=True,
              palette=['#c1ff55', '#b7feea'],
              stacked=True,
              tools=None,
              xgrid=None,
              ygrid=None)
    bar.toolbar_location = None

    #output_file("stacked_bar.html", autosave=True)
    #show(bar) - commented out so it doesnt try to open display in linux

    #generating unique filenames by- concatenating userid to a rolledindex-
    #we dont expect a user to generate more than
    """
    global rollingindex
    userfilepath = filepath+str(userid)+str(rollingindex.next())+'.js'
    """
    userfilepath = filepath + str(userid) + '.js'
    js, tag = autoload_static(
        bar, CDN, '/' + userfilepath + '?id=' + str(randint(1, 1000000)))

    with open(userfilepath, 'w') as f:
        f.write(js)

    return js, tag
Ejemplo n.º 20
0
def plot(df):
    print("-" * 10)
    print(df)
    print("-" * 10)
    from bokeh.charts import Bar, show
    p = Bar(df, label=["model", "dim reduction"], \
            values="accuracy", agg="mean", color="model",\
            legend=None, bar_width=0.3, plot_width=600, plot_height=600)
    p.logo = None
    # will open a browser to show the plot.
    show(p)
Ejemplo n.º 21
0
def fnCreate_Chart_Bar(df):    
    plot = Bar(df, label='Aspects', values='Count',group='Polarity',
               title="Average Sentiment for various Aspects", legend='top_left', 
               bar_width=0.9,color=["green","red"],
               xlabel='Aspects',ylabel='Count')
 
    plot.logo=None
    plot.legend.label_text_font_size = "7pt"
    plot.legend.orientation = "horizontal"
#    plot.legend.click_policy="hide"

    script, div = components(plot,CDN)    
    return script, div
Ejemplo n.º 22
0
def fnCreate_Stacked_Bar(df): 
#    label1=CatAttr(columns=['Aspects'], sort=True)   
    tmp=df
    plot = Bar(tmp, stack=tmp.columns[0], 
               label=tmp.columns[1], values=tmp.columns[2], 
               legend=True,title="Sentiment segmentation based on top 7 Aspects",
               xlabel='Polarity',ylabel='Count')
    plot.logo=None
    plot.legend.label_text_font_size = "7pt"
    plot.legend.orientation = "horizontal"
    
    script, div = components(plot,CDN)    
    return script, div
Ejemplo n.º 23
0
def make_bar_plot(labels, values):
    data = {'labels': labels, 'values': values}
    bar = Bar(data,
              values='values',
              label=CatAttr(columns=['labels'], sort=False),
              legend=False,
              agg='mean',
              bar_width=0.6,
              plot_width=500,
              plot_height=350)
    bar.y_range = Range1d(0.0, 1.0)
    script, div = components(bar)
    return script, div
Ejemplo n.º 24
0
def draw_regional_fig_bokeh(make, model, year):
    """
    Returns a bar graph figure rendered in Bokeh; for cars similar to the given
    car, groups price and mileage according to region in greater Boston
    """
    try:
        min_auto_year = int(year) - 2
        max_auto_year = int(year) + 2
    except:
        min_auto_year = 2012
        max_auto_year = 2016

    listings = get_listings(make, model, year)

    df = pd.DataFrame(data=listings)
    if len(df) == 0: return row()  #"No results found, check your spelling"
    df['mileage'] = df.apply(lambda row: get_mileage(row['description']),
                             axis=1)
    df['price'] = df.apply(lambda row: get_price(row['price']), axis=1)
    df['region'] = df['link'].str[1:5]
    df['year'] = df.apply(lambda row: get_year(row['description']), axis=1)
    df['full_region'] = df.apply(
        lambda row: region_dict[row['region'].strip('/')]
        if row['region'].strip('/') in region_dict else None,
        axis=1)
    mileage_count = len(df[df['mileage'].notnull()])

    title1 = 'Average Price of Used {0} {1}, {2}-{3}, by region, n={4}'.format(
        make, model, min_auto_year, max_auto_year, len(df))
    title2 = 'Average Mileage of Used {0} {1}, {2}-{3}, by region, n={4}'.format(
        make, model, min_auto_year, max_auto_year, mileage_count)
    bar1 = Bar(df,
               label='full_region',
               values='price',
               agg='mean',
               title=title1,
               legend=None,
               xlabel="Region",
               ylabel="Price",
               y_range=(0, 20000))
    bar2 = Bar(df,
               label='full_region',
               values='mileage',
               agg='mean',
               title=title2,
               legend=None,
               xlabel="Region",
               ylabel="Mileage",
               y_range=(0, 150000),
               color='dodgerblue')
    return row(bar1, bar2)
Ejemplo n.º 25
0
def generate_chart(event):
    data = get_data(TIMED_EVENTS[event])

    # Bokeh doesn't let me control the order of the grouping! This is
    # frustrating since it will be different on every server launch
    barchart = Bar(data,
                   values='percentage_dnf',
                   label='year',
                   color="FireBrick",
                   xgrid=False,
                   ygrid=False,
                   plot_width=800,
                   plot_height=500,
                   tools="pan,wheel_zoom,box_zoom,reset,resize")

    barchart.title = "Formula SAE Michigan DNFs - " + event

    barchart._xaxis.axis_label = "Year"
    barchart._xaxis.axis_line_color = None
    barchart._xaxis.major_tick_line_color = None
    barchart._xaxis.minor_tick_line_color = None

    barchart._yaxis.axis_label = "Percentage DNF"
    barchart._yaxis.axis_line_color = None
    barchart._yaxis.major_tick_line_color = None
    barchart._yaxis.minor_tick_line_color = None
    barchart._yaxis.formatter = NumeralTickFormatter(format="0%")
    barchart.y_range = Range1d(0, 1)

    barchart.outline_line_color = None

    barchart.toolbar_location = 'right'

    barchart.logo = None

    for renderer in barchart.select(GlyphRenderer):
        if renderer.data_source.data['height'] != [0]:
            year = renderer.data_source.data['year']
            num_dnf = data['dnfs'].loc[data['year'] == year]
            num_entries = data['entries'].loc[data['year'] == year]
            percent_dnf = data['percentage_dnf'].loc[data['year'] == year]
            hover = HoverTool(renderers=[renderer],
                              tooltips=[
                                  ("# DNFs", '%d' % num_dnf.values[0]),
                                  ("# Entries", '%d' % num_entries.values[0]),
                                  ("% DNF",
                                   '%.2f%%' % (100 * percent_dnf.values[0]))
                              ])
            barchart.add_tools(hover)

    return barchart
Ejemplo n.º 26
0
def fnCreate_Chart_Bar_wf(df,stS= "all type reviews"):
    label1=CatAttr(columns=['word'], sort=False)    
    plot = Bar(df, label=label1, values='freq',group='word',
               title="Top 10 Frequent Words for " + stS, legend=None, 
               bar_width=0.9,xlabel='word',ylabel='freq')  #,plot_width=450, plot_height=450
    
    
    
    plot.logo=None
    plot.legend.label_text_font_size = "7pt"
    plot.legend.orientation = "horizontal"

    script, div = components(plot,CDN)    
    return script, div
Ejemplo n.º 27
0
def systemEvolutionBarPlot(df, yLabel, values):
    with Timer(key='systemEvolutionBarPlot', verbose=True):
        p = Bar(df, label='snapshot', values=values, agg='sum', stack='software',
            legend='bottom_left', bar_width=0.5, xlabel="Snapshots", ylabel=yLabel, responsive=True, height=200,tools='hover')

        glyph_renderers = p.select(GlyphRenderer)
        bar_source = [glyph_renderers[i].data_source for i in range(len(glyph_renderers))]
        hover = p.select(HoverTool)
        hover.tooltips = [
            ('software',' @software'),
            ('value', '@height'),
        ]
        p.xaxis.formatter=FuncTickFormatter.from_py_func(getWeekStringTick)
        p.axis.minor_tick_line_color = None

        p.background_fill_color = "#fafafa"
        p.legend.location = "top_left"
        p.toolbar.logo = None
        p.toolbar_location = None

        legend=p.legend[0].legends
        p.legend[0].legends=[]
        l = Legend( location=(0, -30))
        l.items=legend
        p.add_layout(l, 'right')

        return p
Ejemplo n.º 28
0
def get_counties_plot(data_frame):
    plot = Bar(data_frame,
               label='CTYNAME',
               values='TOT_POP',
               agg='max',
               plot_width=1200,
               plot_height=500,
               title='Population by County',
               legend=False)
    plot.xaxis.axis_label = 'County'
    plot.yaxis.axis_label = 'Population'
    plot.yaxis.formatter = NumeralTickFormatter(format="0a")
    plot.sizing_mode = 'scale_width'
    return plot
Ejemplo n.º 29
0
def main():
    # check recalculation request
    if 'recalculate' in request.args:
        if request.args.get('recalculate') == 'True':
            betalyzer.recalculate()

    # build sector betas bar chart
    sector_betas = betalyzer.df_tickers.groupby('sector')['beta'].mean()
    bk_sector_betas = Bar(sector_betas,
                          plot_width=550,
                          plot_height=400,
                          legend=None)
    bk_sector_betas_script, bk_sector_betas_div = components(bk_sector_betas)

    # build market cap betas bar chart
    mktcap_betas = betalyzer.df_tickers.groupby(
        'market_cap_decile')['beta'].mean()
    bk_mc_betas = Bar(mktcap_betas,
                      plot_width=550,
                      plot_height=400,
                      legend=None)
    bk_mc_betas_script, bk_mc_betas_div = components(bk_mc_betas)

    # build market cap scatter plot
    scatter = Scatter(betalyzer.df_tickers,
                      x='market_cap_log',
                      y='beta',
                      plot_width=550,
                      plot_height=400)
    scatter_script, scatter_div = components(scatter)

    # build line plot for top three stocks
    top_tickers = betalyzer.df_tickers['ticker'].head(3)
    bk_history = Line(betalyzer.df_betas[top_tickers],
                      plot_width=550,
                      plot_height=400)
    bk_history_script, bk_history_div = components(bk_history)

    return render_template(
        'main.html',
        dt_tickers=betalyzer.df_tickers.to_dict(orient='records'),
        bk_sector_betas_script=bk_sector_betas_script,
        bk_sector_betas_div=bk_sector_betas_div,
        bk_mc_betas_script=bk_mc_betas_script,
        bk_mc_betas_div=bk_mc_betas_div,
        scatter_script=scatter_script,
        scatter_div=scatter_div,
        bk_history_script=bk_history_script,
        bk_history_div=bk_history_div)
Ejemplo n.º 30
0
def fnCreate_Chart_Bar(df):
    pd.options.html.border = 1

    plot = Bar(df,
               label='ID',
               values='Tweet Count',
               group='ID',
               title="Top 5 contributors",
               legend=False,
               bar_width=1.8,
               xlabel='Users',
               ylabel='Tweets Count')
    plot.logo = None
    script, div = components(plot, CDN)
    return script, div
Ejemplo n.º 31
0
    def createBokehChart(self):
        data = self.getWorkingPandasDataFrame()
        keyFields = self.getKeyFields()
        valueFields = self.getValueFields()

        clusterby = self.options.get("clusterby")
        stacked = self.options.get("charttype", "grouped") == "stacked"
        subplots = self.isSubplot()

        # self.debug("keyF={0}, valueF={1}, cluster={2}, stacked={3}".format(keyFields[0], valueFields[0], clusterby, stacked))
        charts = []
        params = []

        if subplots and len(valueFields) > 1:
            for val in valueFields:
                series = clusterby if clusterby is not None else False
                values = val
                params.append((values, series))
        elif clusterby is not None and len(valueFields) <= 1:
            params.append((valueFields[0], clusterby))
        else:
            series = '_'.join(valueFields)
            values = blend(*valueFields,
                           name=series.replace('_', ','),
                           labels_name=series)
            if clusterby is not None:
                self.addMessage(
                    "Warning: 'Cluster By' ignored when you have multiple Value Fields but subplots option is not selected"
                )
            params.append((values, series))

        for p in params:
            if stacked:
                b = Bar(data,
                        label=keyFields[0],
                        values=p[0],
                        stack=p[1],
                        legend=self.showLegend())
            else:
                b = Bar(data,
                        label=keyFields[0],
                        values=p[0],
                        group=p[1],
                        legend=self.showLegend())

            charts.append(b)

        return charts
Ejemplo n.º 32
0
    def plot_top_topic_of_author_by_year(self, df_author_eval, plot=True):
        '''needs output from plot_author_evolution_plot(a_id) as input
        Plots the top topic of the author for the given year'''

        years = [y for y in range(1987, 2017)]
        dc = df_author_eval.cumsum(axis=1)
        p = [dc[y].idxmax() for y in years]
        if (plot):
            #            plt.bar(years,p)
            #            plt.show()
            df_f = pd.DataFrame({'Years': years, 'TopTopic': p})

            output_file("toptopicbyyear.html")

            pl = Bar(df_f,
                     'Years',
                     values='TopTopic',
                     title="Bar Plot of top Topic",
                     color='blue',
                     legend=False)
            show(pl)
            print("The author changed the topic %d times" % len(np.unique(p)))
            print("\n Following are the topics:")
            for i in np.unique(p):
                print("\nTopic %d" % (i + 1))
                print('\n Top Words:')
                print(self.model.show_topic(i))
                print('\n')

        return p
Ejemplo n.º 33
0
def plot_crashes_vs_year(air_data, method, save_fig=True):
    """
                        姣忓勾绌洪毦鏁板垎鏋�
      """
    if method == 'sns':

        # Seaborn 缁樺浘
        plt.figure(figsize=(15.0, 10.0))
        sns.countplot(x='Year', data=air_data)
        # 瑙e喅matplotlib鏄剧ず涓枃闂
        plt.rcParams['font.sans-serif'] = ['SimHei']  # 鎸囧畾榛樿瀛椾綋
        plt.rcParams[
            'axes.unicode_minus'] = False  # 瑙e喅淇濆瓨鍥惧儚鏄礋鍙�-'鏄剧ず涓烘柟鍧楃殑闂
        plt.title(u'绌洪毦娆℃暟  vs 骞翠唤')

        plt.xlabel(u'骞翠唤')
        plt.ylabel(u'绌洪毦娆℃暟')
        plt.xticks(rotation=90)

        if save_fig:
            plt.savefig('crashes_year.png')
        plt.show()

    elif method == 'bokeh':
        # Boken 缁樺浘
        p = Bar(air_data,
                'Year',
                title='绌洪毦娆℃暟 vs 骞翠唤',
                plot_width=1000,
                legend=False,
                xlabel='骞翠唤',
                ylabel='绌洪毦娆℃暟')
        p.xaxis.major_label_orientation = pi / 2
        output_file('crashes_year.html')
        show(p)
Ejemplo n.º 34
0
    def topic_evolution_by_year(self, topic, sp=True):
        year_dist = self.year_dist
        topic_score = []
        for i in range(len(year_dist)):
            topic_score.append(year_dist[i].sum()[topic])
        tf = pd.DataFrame({
            'Topic' + str(topic) + 'Score': topic_score,
            'Year': [y for y in range(1987, 2017)]
        })
        #        ax=tf.plot(kind='bar')
        #        ax.set_xticklabels([y for y in range(1987,2017)], rotation=90)
        #        plt.show()
        #
        output_file("topicevolutionbyyear.html")

        p = Bar(tf,
                'Year',
                values='Topic' + str(topic) + 'Score',
                title="Bar Plot of Topic %d score for all years " % topic,
                color='green',
                legend=False)
        if (sp):
            show(p)

        print('\n Following are the top words in topic %d:' % topic)
        print(self.model.show_topic(topic))

        return topic_score, p
Ejemplo n.º 35
0
def leagues():
    grouped = df_squads.groupby('year')
    club_country = df_squads.club_country.unique()
    club_country.sort()
    df_clb_ctry = pd.DataFrame({"club_country":club_country})
    
    for year in df_squads.year.unique():
        country_to_club = grouped.club_country.value_counts()[year] / grouped.team.value_counts()[year]
        df_clb_ctry = df_clb_ctry.join(country_to_club.to_frame(year))
        
    df_clb_ctry = df_clb_ctry.fillna(0) # If NaN, country league not represented at the world cup
    df_clb_ctry = df_clb_ctry.T
    
    plot_nat_leagues = figure(tools=TOOLS,
                  x_axis_label='World Cup Year',
                  toolbar_location=None
                  )
    
    # take the top 11 countries and plot
    for num, country in enumerate(df_clb_ctry.sum().sort_values(ascending=False).head(11).index):
        plot_nat_leagues.scatter(df_clb_ctry.index, df_clb_ctry[country],legend=country,color=RdBu11[num],size=8, alpha=0.5)
    
    plot_nat_leagues.legend.location = "top_left"
    
    df_expats = df_league_data[df_league_data.nation!=df_league_data.nationality]
    
    seasons = df_expats.season.unique()
    
    min = int(seasons[0].split('-')[0])
    max = int(seasons[-1].split('-')[0])
    
    wc_year_slider = Slider(start=min, end=max, value=max, step=1, title="Soccer Season")
    
    for season in seasons:
        nationality_expats = df_expats.groupby('season').nationality.value_counts()[season].head(5)
        nation_expats = df_expats.groupby('season').nation.value_counts()[season]
    
    plot_expats = Bar(nationality_expats, toolbar_location=None)
    plot_expats.x_range = FactorRange(factors=nationality_expats.index.tolist())
    
    plot_dict = {"nations":plot_nat_leagues, "expats":plot_expats}
    
    script, div = components(plot_dict)
    
    return render_template('league.html', js_resources=js_resources, script=script, div=div)
Ejemplo n.º 36
0
def plot_average_dts(df, hours):
    
    lasti = 0
    tmp = 0
    tmplist = []
    ### Currently using a fixed method timeset, if there is a better way to do a log loop this could be changed. ###
    lasti = 0
    tmp = 0
    tmplist = []
    xlist = []
    for i in range(1,10):
        tmp = 0
        for item in df['noao_time']:
            if item > lasti and item < i:
                tmp = tmp + 1
        tmplist.append(tmp)
        xlist.append(i)
        lasti = i
    for i in range(10,100,10):
        tmp = 0
        for item in df['noao_time']:
            if item > lasti and item < i:
                tmp = tmp + 1
        tmplist.append(tmp)
        xlist.append(i)
        lasti = i
    for i in range(100,1000,100):
        tmp = 0
        for item in df['noao_time']:
            if item > lasti and item < i:
                tmp = tmp + 1
        tmplist.append(tmp)
        xlist.append(i)
        lasti = i


    graph_info = {}
    graph_info['values'] = tmplist
    graph_info['Time in minutes'] = xlist
    p = Bar(graph_info, values='values', label='Time in minutes', ylabel='Number of transfers', color='navy', title='DTS time plot')
    
    p.plot_height = 500
    p.plot_width = 1000   

    return p
def bar_plot_table(table, **kwargs):
    """Plot a tabular DataFrame with an index and multiple columns representing
    categories using a Bokeh bar chart.

    In addition to the keyword parameters accepted by bokeh.charts.Bar, this
    function accepts the following additional keyword arguments:

    number_of_categories: integer
        The number of categories ranked by total value to use.
    xaxis_formatter: TickFormatter
        The formatter to use for x axis values.
    yaxis_formatter: TickFormatter
        The formatter to use for y axis values.
    x_range: Range1d
        A range to use for the X-axis.
    y_range: Range1d
        A range to use for the Y-axis.
    """
    if kwargs.has_key('number_of_categories'):
        revenue_table = analysis.select_top_n_columns(
            table, kwargs['number_of_categories'])
    else:
        revenue_table = table
    revenue_stacked = revenue_table.stack().reset_index()
    revenue_stacked.columns = ['year', 'commodity_desc', 'value']
    revenue_plot = Bar(
        revenue_stacked,
        label='year',
        stack='commodity_desc',
        values='value',
        **_remove_custom_keys(kwargs)
    )
    if kwargs.has_key('x_range'):
        revenue_plot.x_range = kwargs['x_range']
    if kwargs.has_key('y_range'):
        revenue_plot.y_range = kwargs['y_range']
    else:
        revenue_plot.y_range = Range1d(0, revenue_table.max().sum())
    if kwargs.has_key('xaxis_formatter'):
        revenue_plot._xaxis.formatter = kwargs['xaxis_formatter']
    if kwargs.has_key('yaxis_formatter'):
        revenue_plot._yaxis.formatter = kwargs['yaxis_formatter']
    return revenue_plot
Ejemplo n.º 38
0
def generate_chart(event):
    data = get_data(TIMED_EVENTS[event])

    # Bokeh doesn't let me control the order of the grouping! This is
    # frustrating since it will be different on every server launch
    barchart = Bar(data,
                   values='percentage_dnf',
                   label='year',
                   color="FireBrick",
                   xgrid=False, ygrid=False,
                   plot_width=800, plot_height=500,
                   tools="pan,wheel_zoom,box_zoom,reset,resize")

    barchart.title = "Formula SAE Michigan DNFs - " + event

    barchart._xaxis.axis_label = "Year"
    barchart._xaxis.axis_line_color = None
    barchart._xaxis.major_tick_line_color = None
    barchart._xaxis.minor_tick_line_color = None

    barchart._yaxis.axis_label = "Percentage DNF"
    barchart._yaxis.axis_line_color = None
    barchart._yaxis.major_tick_line_color = None
    barchart._yaxis.minor_tick_line_color = None
    barchart._yaxis.formatter = NumeralTickFormatter(format="0%")
    barchart.y_range = Range1d(0, 1)

    barchart.outline_line_color = None

    barchart.toolbar_location = 'right'

    barchart.logo = None

    for renderer in barchart.select(GlyphRenderer):
        if renderer.data_source.data['height'] != [0]:
            year = renderer.data_source.data['year']
            num_dnf = data['dnfs'].loc[data['year'] == year]
            num_entries = data['entries'].loc[data['year'] == year]
            percent_dnf = data['percentage_dnf'].loc[data['year'] == year]
            hover = HoverTool(renderers=[renderer],
                              tooltips=[("# DNFs", '%d' % num_dnf.values[0]),
                                        ("# Entries", '%d' % num_entries.values[0]),
                                        ("% DNF", '%.2f%%' % (100 * percent_dnf.values[0]))])
            barchart.add_tools(hover)
    

    return barchart
Ejemplo n.º 39
0
def bar_response(results_list, output_path):

    output_dir = os.path.join(output_path, "charts")
    if os.path.isdir(output_dir) is False:
        os.mkdir(output_dir)

    tools = "pan,wheel_zoom,box_zoom,reset,hover,save"

    for df in results_list:
        print(df)
        p = Bar(df, label='hh_type', values='perc_res', stack='digital', title="a_title",
                legend='top_right', tools=tools)

        hover = p.select_one(HoverTool)
        hover.point_policy = "follow_mouse"
        hover.tooltips = [
            ("count", "@height"),
        ]
        output_file_path = os.path.join(output_dir, 'test bar.html')
        output_file(output_file_path)
        show(p)
Ejemplo n.º 40
0
def generate_chart(team):
    data = generate_data(team)
    selectable_years = list(map(str, data.index.unique()))

    # Generate the chart UNFORTUNATELY using the high level plots. Streaming
    # a bunch of quads resulted in lots of graphics corruption when switching
    # teams. I would rather have the plots work all the time but really slow
    # then have the plot show the wrong information.
    barchart = Bar(data,
                   values=blend(*SCORED_EVENTS, labels_name='event'),
                   label=cat(columns='Year', sort=False),
                   stack=cat(columns='event', sort=False),
                   color=color(columns='event', palette=Spectral9, sort=False),
                   xgrid=False, ygrid=False,
                   plot_width=1000, plot_height=625,
                   tools="pan,wheel_zoom,box_zoom,reset,resize")

    barchart.title = "Formula SAE Michigan - " + team

    barchart._xaxis.axis_label = "Teams"
    barchart._xaxis.axis_line_color = None
    barchart._xaxis.major_tick_line_color = None
    barchart._xaxis.minor_tick_line_color = None

    barchart._yaxis.axis_label = "Total Score"
    barchart._yaxis.axis_line_color = None
    barchart._yaxis.major_tick_line_color = None
    barchart._yaxis.minor_tick_line_color = None

    barchart.outline_line_color = None

    barchart.toolbar_location = 'right'

    barchart.logo = None

    # Hacky tooltips
    for renderer in barchart.select(GlyphRenderer):
        if renderer.data_source.data['height'] != [0]:
            year = renderer.data_source.data['Year']
            place = data['Place'].loc[data['Year'] == year]
            score = data['Total Score'].loc[data['Year'] == year]
            hover = HoverTool(renderers=[renderer],
                              tooltips=[("Year", '@Year'),
                                        ("Selection", '@event'),
                                        ("Event Score", '@height'),
                                        ("Total Score", '%.2f' % score.values[0]),
                                        ("Overall Place", '%d' % place.values[0])])
            barchart.add_tools(hover)

    return barchart
Ejemplo n.º 41
0
def MonthGraph(request):
    if request.method =='GET' :

        if request.user.is_authenticated():
            now = datetime.now()
            now = formats.date_format(now,"SHORT_DATETIME_FORMAT")

            #data = DeviceUsage.objects.values('date').annotate(sumusage=Sum('usage'))# Group by date
            y = [0,0,0,0,0,0,0,0,0,0
                ,0,0,0,0,0,0,0,0,0,0
                ,0,0,0,0,0,0,0,0,0,0,0,0]

            print "Don't select data"
            head=""

            plot = Bar(y,title=head, xlabel='date', ylabel='Unit', width=800, height=400)
            plot.toolbar_location = None
            plot.outline_line_color = None

            script, div = components(plot, CDN)
            return render(request, "monthgraph.html", {"the_script": script, "the_div": div,'devices': DeviceProfile.objects.filter(owner=request.user),"date":str(now)})

        else:
            return redirect('/authen/')

    elif request.method == 'POST':
        now = datetime.now()
        now = formats.date_format(now,"SHORT_DATETIME_FORMAT")

        #data = DeviceUsage.objects.values('date').annotate(sumusage=Sum('usage'))# Group by date
        y = [0,0,0,0,0,0,0,0,0,0
            ,0,0,0,0,0,0,0,0,0,0
            ,0,0,0,0,0,0,0,0,0,0,0,0]

        head=""

        if request.POST.get('deviceid') is not None:
            id = request.POST.get('deviceid')
            if request.POST.get('month') is not None:
                month = request.POST.get('month')
                do = DeviceProfile.objects.get(device_id=id)
                data = DeviceUsage.objects.filter(device_id=do,date__month=month).values('date').annotate(sumusage=Sum('usage'),sumtime=Sum('time'))
                #print data # data[0].get('date').strftime("%d") get only date from year-month-date
                for d in data:
                    hr = (float(d.get('sumtime'))/3600)
                    kw = float(d.get('sumusage'))
                    y[int(d.get('date').strftime("%d"))] = kw * hr
                    head = "usage of device name: "+ do.device_name +" at "+request.POST.get('month')+"th Month"
        else:
            print "Don't select data"
            head=""

        plot = Bar(y,title=head, xlabel='date', ylabel='Unit', width=800, height=400)
        plot.toolbar_location = None
        plot.outline_line_color = None

        script, div = components(plot, CDN)
        return render(request, "monthgraph.html", {"the_script": script, "the_div": div,'devices': DeviceProfile.objects.filter(owner=request.user),"date":str(now)})
Ejemplo n.º 42
0
def fun():
    plot_transfer_fee = figure(tools=TOOLS,
                      title='World Record Soccer Transfer Fee',
                      x_axis_label='Year',
                      y_axis_label=u"Fee (\u00A3)",
                      toolbar_location=None
                      )
    
    plot_transfer_fee.line(df_tranfer['year'], df_tranfer['fee_pounds'],color=RdBu11[0],line_width=4)

    month_map = {k: v for k,v in enumerate(calendar.month_abbr)}
    
    df_mth = df_squads.birth_month.value_counts().sort_index()
    df_mth.index = df_mth.index.map(lambda x: month_map[x])
    
    plot_mth_of_birth = Bar(df_mth, toolbar_location=None)
    plot_mth_of_birth.x_range = FactorRange(factors=df_mth.index.tolist())
    
    plots = {"plt_trans_fee": plot_transfer_fee, "plt_mth_birth": plot_mth_of_birth}
    
    script, div = components(plots)
    
    return render_template('interesting.html', js_resources=js_resources, script=script, div=div)
Ejemplo n.º 43
0
def generate_chart(year):
    data = get_data(year)

    plot_data = {'country': data.index.tolist(),
                 'count': [float(i) for i in data.values.tolist()]}

    barchart = Bar(plot_data,
                   label='country',
                   values='count',
                   color="red",
                   xgrid=False, ygrid=False,
                   plot_width=800, plot_height=500,
                   tools="pan,wheel_zoom,box_zoom,reset,resize")

    barchart.title = "Formula SAE Michigan " + year + " Countries"

    barchart.x_range = FactorRange(factors=data.index.tolist())

    barchart._xaxis.axis_label = "Country"
    barchart._xaxis.axis_line_color = None
    barchart._xaxis.major_tick_line_color = None
    barchart._xaxis.minor_tick_line_color = None

    barchart._yaxis.axis_label = "Number of Teams"
    barchart._yaxis.axis_line_color = None
    barchart._yaxis.major_tick_line_color = None
    barchart._yaxis.minor_tick_line_color = None

    barchart.outline_line_color = None

    barchart.toolbar_location = 'right'

    barchart.logo = None

    hover = HoverTool(tooltips=[("Country", '@x'),
                                ("# Teams", '@height')])

    barchart.add_tools(hover)

    return barchart
Ejemplo n.º 44
0
 def plot_scores(self, all_scores):
     
     if all_scores is None:
         return None
     
     scores = all_scores[0][:]
     scores = np.hstack((scores,np.mean(scores)))
     class_labels = self.class_labels[:]
     class_labels.append('average')
     data = {"precision": scores}
     s1 = Bar(data, cat=class_labels, title="Per Class Precision",
     xlabel='categories', ylabel='precision', width=500, height=500,
     tools="pan,resize,box_zoom,hover,save,reset", stacked=True, palette=["#b2df8a"])    
     
     hover = s1.select(dict(type=HoverTool))
     hover.tooltips = OrderedDict([
                      ('precision', '@precision'),
                       ])
     
     scores = all_scores[1][:]
     scores = np.hstack((scores,np.mean(scores)))
     class_labels = self.class_labels[:]
     class_labels.append('average')
     data = {"recall": scores}
     s2 = Bar(data, cat=class_labels, title="Per Class Recall",
     xlabel='categories', ylabel='recall', width=500, height=500,
     tools="pan,resize,box_zoom,hover,save,reset", stacked=True, palette=["#a6cee3"])  
     
     hover = s2.select(dict(type=HoverTool))
     hover.tooltips = OrderedDict([
                      ('recall', '@recall'),
                       ])
     
     data = {"support": all_scores[3]}
     s3 = Bar(data, cat=self.class_labels, title="Per Class Support",
     xlabel='categories', ylabel='support', width=500, height=500,
     tools="pan,resize,box_zoom,hover,save,reset", stacked=True, palette=["#6a3d9a"])    
     
     hover = s3.select(dict(type=HoverTool))
     hover.tooltips = OrderedDict([
                      ('support', '@support'),
                       ])
                       
     p = hplot(s1, s2, s3)
     
  
     
     script, div = components(p)
     return (script, div)
def output_chart(issues_df,output_mode='static'):
    import datetime
    import bokeh
    from bokeh.models import HoverTool


    # Add timestamp to title
    
    issues_chart = Bar(issues_df, label='value_delivered', 
               values='status', agg='count', stack='status',
               title=ISSUES_TITLE+" (Updated "+datetime.datetime.now().strftime('%m/%d/%Y')+")", 
               xlabel="Value Delivered",ylabel="Number of Use Cases",
               legend='top_right',
               tools='hover',
               color=brewer["GnBu"][3]
              )

    issues_chart.plot_width  = DESTINATION_FRAME_WIDTH  - (HTML_BODY_MARGIN * 2)
    issues_chart.plot_height = DESTINATION_FRAME_HEIGHT - (HTML_BODY_MARGIN * 2)
    issues_chart.logo = None
    issues_chart.toolbar_location = None

    hover = issues_chart.select(dict(type=HoverTool))
    hover.tooltips = [ ("Value Delivered", "$x")]


    #--- Configure output ---
    reset_output()

    if output_mode == 'static':
        # Static file.  CDN is most space efficient
        output_file(ISSUES_FILE, title=ISSUES_TITLE, 
            autosave=False, mode='cdn', 
            root_dir=None
               )   # Generate file
        save(issues_chart,filename=ISSUES_FILE)
    elif output_mode == 'notebook':
        output_notebook()   # Show inline
        show(issues_chart)
    else:
        # Server (using internal server IP, rather than localhost or external)
        session = bokeh.session.Session(root_url = BOKEH_SERVER_IP, load_from_config=False)
        output_server("ddod_chart", session=session)
        show(issues_chart)
Ejemplo n.º 46
0
def generate_chart():
    data = get_data()

    # Bokeh doesn't let me control the order of the grouping! This is
    # frustrating since it will be different on every server launch
    barchart = Bar(data,
                   label='year',
                   values='count',
                   group=cat(columns='size', ascending=True, sort=True),
                   color=color(columns='size', palette=Spectral4),
                   legend='top_left',
                   xgrid=False, ygrid=False,
                   plot_width=800, plot_height=500,
                   tools="pan,wheel_zoom,box_zoom,reset,resize")

    barchart.title = "Formula SAE Michigan Engine Cylinders"

    barchart._xaxis.axis_label = "Year"
    barchart._xaxis.axis_line_color = None
    barchart._xaxis.major_tick_line_color = None
    barchart._xaxis.minor_tick_line_color = None

    barchart._yaxis.axis_label = "Frequency"
    barchart._yaxis.axis_line_color = None
    barchart._yaxis.major_tick_line_color = None
    barchart._yaxis.minor_tick_line_color = None

    barchart.outline_line_color = None

    barchart.toolbar_location = 'right'

    barchart.logo = None
    
    hover = HoverTool(tooltips=[("Engine", '@size'),
                                ("# Teams", '@height')])

    barchart.add_tools(hover)

    return barchart
Ejemplo n.º 47
0
for x in portions_sold:
    portions_unsold.append((x[0],1-x[1],x[2],'Unsold',x[4]))

portions = portions_sold + portions_unsold

# Put into a df
portions_df = pd.DataFrame.from_records(portions, columns=["Name", "Portion","HasFeature","SaleStatus", "Feature"] )


# Make the chart
TOOLS = ''
plt2 = Bar(portions_df,
           label="Name",
           values="Portion",
           stack = "SaleStatus",
           legend="bottom_right",
           color=['Green','Red'],
           xlabel="Listing feature",
           ylabel="Portion sold or unsold",
           title="Impact of listing features on likelihood of sale",
           tools=TOOLS)
plt2.logo = None
plt2.toolbar_location = None

plt2.y_range = Range1d(start=0,end=1)
# Save the plot
output_file("./templates/plot3_new.html")
# show(plt2)


#######################################################
# Look at dependence of sale outcome on seller feedback score
Ejemplo n.º 48
0
'''
import pandas as pd
from bokeh.charts import Bar, output_file, show, defaults
import bokeh.plotting as bp 
from bokeh.models import FixedTicker, LinearAxis
from bokeh.io import output_file, show, vplot

crapsArray(100, 5, 300)  
csv=pd.read_csv('test.csv')

output_file("craps.html")

#Plot sizes for charts
defaults.width = 1200
defaults.height = 300

action = Bar(csv, 'roll', values = 'score', title = "Craps Outcomes", bar_width = 1, color = 'score')
money = Bar(csv, 'roll', values = 'bank', title = "Craps Bankroll", bar_width = 1, color = 'score')
winLose = Bar(csv, 'roll', values = 'value', title = "Craps Roll Win/Loss", bar_width = 1, color = 'score')

xaxis=action.select({'type' : LinearAxis})
xaxis.ticker=FixedTicker(ticks=[0,25,50,75,100])
yaxis=action.select({'type' : LinearAxis})
yaxis.ticker=FixedTicker(ticks=[2,3,4,5,6,7,8,9,10,11,12])


p = vplot(action, money,winLose)

show(p)
print("Cashing Out")
Ejemplo n.º 49
0
output_file('data_table.html')
show(data_table)









test3.sort_values('abs_third_less_adv', inplace=True, ascending=False)
test3.reset_index(inplace=True)

source = ColumnDataSource(test3)
p2 = Bar(test3, 'category', values='third_less_adv', title="GDP revisions for 2011 - 2015: Simple", plot_width=1000, plot_height=1000)

output_file('2011_2015_change.html')
show(p2)

p3 = Bar(test3, 'category', values='abs_third_less_adv', title="GDP revisions for 2011 - 2015: absoulte value", plot_width=1000, plot_height=1000)

output_file('2011_2015_abs_change.html')
show(p3)






Ejemplo n.º 50
0
def index():
    if request.method == 'GET':
        return render_template('index.html')
    else:
        # request was a POST

        # store the city code
        # all processing is based on filtering summary tables on city code
        app.vars['citycode'] = request.form['city']
        citycode = app.vars['citycode']
        
        # app.vars['features'] = request.form.getlist('features')


        #######################
        # Summary table loads #
        #######################

        # coll_inj = pd.read_csv('1_coll_inj_ann.csv', encoding='utf-8')
        # top_10 = pd.read_csv('2_top_10.csv', encoding='utf-8')
        # surf_vs_high = pd.read_csv('3_surf_vs_high.csv', encoding='utf-8')
        # inj_causes = pd.read_csv('4_inj_causes.csv', encoding='utf-8')
        # weather = pd.read_csv('5_weather.csv', encoding='utf-8')
        # hour = pd.read_csv('6_hour.csv', encoding='utf-8')
        # city_stats14 = pd.read_csv('7_2014_city_stats.csv', encoding='utf-8')
        # ins_est13 = pd.read_csv('8_2013_ins_est.csv', encoding='utf-8')
        # kfinal = pd.read_csv('9_kmeans_and_pop.csv', encoding='utf-8')
        
        ################################
        # Hardcoded summary statistics #
        ################################

        # California collision stats

        capop2014 = 38357121
        cacol2014 = 384646
        caco1k = np.round(1000.0 * cacol2014 / capop2014, 1)
        cainj2014 = 225044
        cainj1k = np.round(1000.0 * cainj2014 / capop2014, 1)
        cakill2014 = 3068
        cak1m = np.round(1000000.0 * cakill2014 / capop2014, 1)

        # Califonia insurance stats

        human_claims_2013 = 4207773612
        prop_claims_2013 = 7422643259
        inj_2013 = 223128
        sev_inj_2013 = 10664
        kill_2013 = 3104
        parties_2013 = 763086

        # cost per X insurance estimates
        # crude!

        cost_per_inj = np.round(human_claims_2013 / \
            (1.0 * inj_2013 + 9.0 * sev_inj_2013 + 19.0 * kill_2013), 1)
        cost_per_party = np.round(prop_claims_2013 / (1.0 * parties_2013), 1)

        cacpc = np.round(1.0 * (human_claims_2013 + prop_claims_2013) / 37965755, 2)

        # City collision stats

        citystats = city_stats14[city_stats14['cccode'] == int(citycode)]

        cityname = citystats['COUNTY/CITY'].values[0]
        collper1k = np.round(citystats['collper1k'].values[0],1)
        injper1k = np.round(citystats['injper1k'].values[0],1)
        killper1m = np.round(citystats['killper1m'].values[0],1)

        # City insurance Stats

        insstats = ins_est13[ins_est13['cccode'] == int(citycode)]

        citycpc = np.round(insstats['estpercapita'].values[0], 2)

        tools='save'

        # Other City Stats

        citypop = kfinal[kfinal['cccode'] == int(citycode)]['pop2014'].values[0]
        citypop = locale.format("%d", citypop, grouping=True)
        cluster = kfinal[kfinal['cccode'] == int(citycode)]['cluster'].values[0]

        ################
        # Annual Trend #
        ################

        df = coll_inj[coll_inj['cccode'] == int(citycode)]
        print 'before bar definition'
        p1 = Bar(df,
              label='year',
              values='count',
              title="Collisions & Injuries by Year",
              group='type',
              xlabel='Year',
              ylabel='Collisions/Injuries',
              height=400,
              # width=600,
              # bar_width=0.1,
              tools=tools,
              legend='bottom_left'
              )
        
        p1.toolbar_location=None
        p1.responsive=True
        print 'end p1 definition'


        ##############################
        # Top 10 Worst Intersections #
        ##############################

        columns = ['inter', 'numcoll', 'SUM(NUMBER_INJURED)', 'SUM(NUMBER_KILLED)']
        temp = top_10[top_10['CNTY_CITY_LOC'] == int(citycode)][columns]
        newcolumns = ['Intersection', 'Collisions', 'Injuries', 'Fatalities']
        temp.columns = newcolumns

        interhtml = temp.to_html(index=False).replace('border="1"', 'border="0"')
        interhtml = interhtml.replace('\n', '')


        ###############################
        # Surface Streets vs Highways #
        ###############################

        df3 = surf_vs_high[surf_vs_high['cccode'] == int(citycode)]
        df3 = df3[['type', 'count', 'dtype']]

        p2 = Bar(df3,
                  label='dtype',
                  values='count',
                  stack='type',
                  title="Surface Streets vs Freeways and Highways",
                  xlabel='',
                  ylabel='Proportion',
                  height=400,
                  # width=600,
                  bar_width=0.9,
                  tools=tools,
                  legend='bottom_right'
                 )

        p2.toolbar_location=None
        p2.responsive=True
        print 'end p2 definition'


        ##############################################
        # Primary Causes of Collisions with Injuries #
        ##############################################

        df4 = inj_causes[inj_causes['CNTY_CITY_LOC'] == int(citycode)]

        p3 = Bar(df4,
                  label='pcf',
                  values='SUM(NUMBER_INJURED)',
                  title="Primary Violations Leading to Injuries",
                  xlabel='',
                  ylabel='Injuries',
                  height=400,
                  # width=600,
                  bar_width=0.9,
                  tools=tools,
                  color='black'
                 )

        p3.toolbar_location=None
        p3.responsive=True
        print 'end p3 definition'


        ################################
        # Weather at time of collision #
        ################################

        df5 = weather[weather['CNTY_CITY_LOC'] == int(citycode)]

        p4 = Bar(df5, 
                label='weather',
                values='numcoll',
                title="Weather Conditions for Collisions",
                xlabel='',
                ylabel='Collisions',
                height=400,
                # width=600,
                bar_width=0.9,
                tools=tools,
                color='yellow'
                )

        p4.toolbar_location=None
        p4.responsive=True
        print 'end p4 definition'


        ###############
        # Time of Day #
        ###############

        df6 = hour[hour['CNTY_CITY_LOC'] == int(citycode)]

        p5 = Bar(df6,
                label='hour',
                values='numcoll',
                title="Time of Day",
                xlabel='Hour',
                ylabel='Collisions',
                height=400,
                # width=600,
                bar_width=0.9,
                tools=tools,
                color='black'
                )

        p5.toolbar_location=None
        p5.responsive=True


        #################
        # Plot encoding #
        #################

        plots = {'trend': p1, 'streettypes': p2, 'injurycauses': p3,
                'weather': p4, 'hour': p5}
        script, div = components(plots, INLINE)
        # script1 = encode_utf8(script1)


        #############
        # Rendering #
        #############

        print 'before render'
        html = render_template('index_post.html',
                               citycode=citycode, cityname=cityname,
                               collper1k=collper1k, caco1k=caco1k,
                               injper1k=injper1k, cainj1k=cainj1k,
                               killper1m=killper1m, cak1m=cak1m,
                               citycpc=citycpc, cacpc=cacpc,
                               plot_scripts=script, div=div,
                               interhtml=interhtml, citypop=citypop,
                               cluster=cluster)
        print 'after render'
        return encode_utf8(html)
def make_bar(counter, keywords, output_filename):
    data = pd.Series(filter_counter(counter, keywords))
    bar = Bar(data, title='Word Counts')
    output_file(output_filename)
    bar.show()
Ejemplo n.º 52
0
ch1TotalDislikes = channel1_data["total_dislikes"]
ch2TotalDislikes = channel2_data["total_dislikes"]

ch1TotalSubscribers = channel1_data["total_subscribers"]
ch2TotalSubscribers = channel2_data["total_subscribers"]

# Data to be used for graphone ordered into groups
data = {
    'Numbers': ['Dislikes', 'Likes', 'Subscribers', 'Total Views', 'Dislikes', 'Likes', 'Subscribers', 'Total Views'],
    'Channels': [ch1, ch1, ch1, ch1, ch2, ch2, ch2, ch2],
    'Total': [ch1TotalDislikes, ch1TotalLikes, ch1TotalSubscribers, ch1TotalViews, ch2TotalDislikes, ch2TotalLikes, ch2TotalSubscribers, ch2TotalViews]   
}

# Puts all the data into a format which may be graphed with correct parameters:
bar = Bar(data, values='Total', label=['Channels', 'Numbers'],agg = 'sum',
           title="Comparing two Youtube Channels", width=500, height = 1000,
           group = 'Numbers', tools=['hover', 'resize', 'box_zoom', 'wheel_zoom', 'pan'])

# Allows the hover tool to function:
hover = bar.select(dict(type=HoverTool))
hover.tooltips = [('Value of Channel',' $x'),('Value of Total',' @height')]

# outputs a file with the data for the graph:
output_file("stacked_bar.html")

# Shows the graph:
show(hplot(bar))
#
#End of graphing functions code!
#**************************************************************************************
Ejemplo n.º 53
0
def predict():
    
    def weighted_choice(choices):
        total = sum(w for c, w in choices)
        r = random.uniform(0, total)
        upto = 0
        for c, w in choices:
            if upto + w >= r:
                return c
            upto += w
        assert False, "Shouldn't get here"
    
    df_fifa_latest_rank
    
    z = np.polyfit(df_prob_win_fifa_rank.rank_diff, df_prob_win_fifa_rank.prob, 4)
    p_win = np.poly1d(z)
    
    # p_win(_some_rank)
    
    z = np.polyfit(df_prob_draw_fifa_rank.rank_diff.values, df_prob_draw_fifa_rank.prob.values, 3)
    p_draw = np.poly1d(z)
    
    country_codes = {
        "Albania": "ALB",
        "Austria": "AUT",
        "Belgium": "BEL",
        "Croatia": "CRO",
        "Czech Republic": "CZE",
        "England": "ENG",
        "France": "FRA",
        "Germany": "GER",
        "Hungary": "HUN",
        "Iceland": "ISL",
        "Italy": "ITA",
        "Northern Ireland": "NIR",
        "Poland": "POL",
        "Portugal": "POR",
        "Republic of Ireland": "IRL",
        "Romania": "ROU",
        "Russia": "RUS",
        "Slovakia": "SVK",
        "Spain": "ESP",
        "Sweden": "SWE",
        "Switzerland": "SUI",
        "Turkey": "TUR",
        "Ukraine": "UKR",
        "Wales": "WAL",
    }
    
    country_from_codes = {
        "ALB": "Albania",
        "AUT": "Austria",
        "BEL": "Belgium",
        "CRO": "Croatia",
        "CZE": "Czech Republic",
        "ENG": "England",
        "FRA": "France",
        "GER": "Germany",
        "HUN": "Hungary",
        "ISL": "Iceland",
        "ITA": "Italy",
        "NIR": "Northern Ireland",
        "POL": "Poland",
        "POR": "Portugal",
        "IRL": "Republic of Ireland",
        "ROU": "Romania",
        "RUS": "Russia",
        "SVK": "Slovakia",
        "ESP": "Spain",
        "SWE": "Sweden",
        "SUI": "Switzerland",
        "TUR": "Turkey",
        "UKR": "Ukraine",
        "WAL": "Wales",
    }
    
    grp_A_matches = [
        ['2016-06-10', 'France', 'Romania'],
        ['2016-06-11', 'Albania', 'Switzerland'],
        ['2016-06-15', 'Romania', 'Switzerland'],
        ['2016-06-15', 'France', 'Albania'],
        ['2016-06-19', 'Switzerland', 'France'],
        ['2016-06-19', 'Romania', 'Albania'],
    ]
    
    grp_B_matches = [
        ['2016-06-11', 'Wales', 'Slovakia'],
        ['2016-06-11', 'England', 'Russia'],
        ['2016-06-15', 'Russia', 'Slovakia'],
        ['2016-06-16', 'England', 'Wales'],
        ['2016-06-20', 'Slovakia', 'England'],
        ['2016-06-20', 'Russia', 'Wales'],
    ]
    
    grp_C_matches = [
        ['2016-06-12', 'Poland', 'Northern Ireland'],
        ['2016-06-12', 'Germany', 'Ukraine'],
        ['2016-06-16', 'Ukraine', 'Northern Ireland'],
        ['2016-06-16', 'Germany', 'Poland'],
        ['2016-06-21', 'Northern Ireland', 'Germany'],
        ['2016-06-21', 'Ukraine', 'Poland'],
    ]
    
    grp_D_matches = [
        ['2016-06-12', 'Turkey', 'Croatia'],
        ['2016-06-13', 'Spain', 'Czech Republic'],
        ['2016-06-17', 'Czech Republic', 'Croatia'],
        ['2016-06-17', 'Spain', 'Turkey'],
        ['2016-06-21', 'Croatia', 'Spain'],
        ['2016-06-21', 'Czech Republic', 'Turkey'],
    ]
    
    grp_E_matches = [
        ['2016-06-13', 'Republic of Ireland', 'Sweden'],
        ['2016-06-13', 'Belgium', 'Italy'],
        ['2016-06-17', 'Italy', 'Sweden'],
        ['2016-06-18', 'Belgium', 'Republic of Ireland'],
        ['2016-06-22', 'Sweden', 'Belgium'],
        ['2016-06-22', 'Italy', 'Republic of Ireland'],
    ]
    
    grp_F_matches = [
        ['2016-06-14', 'Austria', 'Hungary'],
        ['2016-06-14', 'Portugal', 'Iceland'],
        ['2016-06-18', 'Iceland', 'Hungary'],
        ['2016-06-18', 'Portugal', 'Austria'],
        ['2016-06-22', 'Iceland', 'Austria'],
        ['2016-06-22', 'Hungary', 'Portugal'],
    ]
    
    grp_matchs = grp_A_matches + grp_B_matches + grp_C_matches + grp_D_matches + grp_E_matches + grp_F_matches
    
    df_ctry_codes = df_fifa_latest_rank.country_code
    probailities = []
    plot_dict = {}
    prediction_dict = {}
    results = {}
    for k, match in enumerate(grp_matchs,1):
        rank_diff = df_fifa_latest_rank[df_ctry_codes==country_codes[match[1]]].ranking.values - df_fifa_latest_rank[df_ctry_codes==country_codes[match[2]]].ranking.values
        probs = [p_win(rank_diff*-1)[0], p_draw(abs(rank_diff))[0], p_win(rank_diff)[0]]
        probs = [float(i)/sum(probs) for i in probs]
        probailities = [country_codes[match[1]], 'DRAW', country_codes[match[2]]] + probs
        choices = [(country_codes[match[1]], probs[0]), ('DRAW', probs[1]), (country_codes[match[2]], probs[2])]
        
        prediction = weighted_choice(choices)
        if prediction=='DRAW':
            prediction_dict["match_{0}".format(k)] = prediction
        else:
            prediction_dict["match_{0}".format(k)] = country_from_codes[prediction]
        
        df = pd.DataFrame(probailities[3:], probailities[:3])
        df.columns = ['probability']
        plot_probs = Bar(df, toolbar_location=None, plot_width=200, plot_height=200, agg='mean')
        plot_probs.x_range = FactorRange(factors=probailities[:3])
        plot_dict["match_{0}".format(k)] = plot_probs
    
    gp_A = dict.fromkeys(["France","Romania","Albania","Switzerland"], 0)
    gp_B = dict.fromkeys(["England","Russia","Wales","Slovakia"], 0)
    gp_C = dict.fromkeys(["Germany","Ukraine","Poland","Northern Ireland"], 0)
    gp_D = dict.fromkeys(["Spain","Czech Republic","Turkey","Croatia"], 0)
    gp_E = dict.fromkeys(["Belgium","Italy","Republic of Ireland","Sweden"], 0)
    gp_F = dict.fromkeys(["Portugal","Iceland","Austria","Hungary"], 0)
    for k, match in enumerate(grp_A_matches,1):
        result = prediction_dict["match_{0}".format(k)]
        if result == 'DRAW':
            gp_A[match[1]] += 1
            gp_A[match[2]] += 1
        else:
            gp_A[result] += 3
    
    for k, match in enumerate(grp_B_matches,7):
        result = prediction_dict["match_{0}".format(k)]
        if result == 'DRAW':
            gp_B[match[1]] += 1
            gp_B[match[2]] += 1
        else:
            gp_B[result] += 3

    for k, match in enumerate(grp_C_matches,13):
        result = prediction_dict["match_{0}".format(k)]
        if result == 'DRAW':
            gp_C[match[1]] += 1
            gp_C[match[2]] += 1
        else:
            gp_C[result] += 3

    for k, match in enumerate(grp_D_matches,19):
        result = prediction_dict["match_{0}".format(k)]
        if result == 'DRAW':
            gp_D[match[1]] += 1
            gp_D[match[2]] += 1
        else:
            gp_D[result] += 3

    for k, match in enumerate(grp_E_matches,25):
        result = prediction_dict["match_{0}".format(k)]
        if result == 'DRAW':
            gp_E[match[1]] += 1
            gp_E[match[2]] += 1
        else:
            gp_E[result] += 3

    for k, match in enumerate(grp_F_matches,31):
        result = prediction_dict["match_{0}".format(k)]
        if result == 'DRAW':
            gp_F[match[1]] += 1
            gp_F[match[2]] += 1
        else:
            gp_F[result] += 3
            
    all_groups = [gp_A,gp_B,gp_C,gp_D,gp_E,gp_F]
    gp_labels = {1:"A",2:"B",3:"C",4:"D",5:"E",6:"F"}
    table_html = {}
    for k, group in enumerate(all_groups,1):
        table_string = ['      <table style="width:100%">']
        group_standings = {'team':[], 'points':[]}
        for j in xrange(1,len(group)+1):
            table_string.append('        <tr>')
            top = max(group, key=group.get)
            points = group.get(top)
            group_standings['team'].append(top)
            group_standings['points'].append(points)
            group.pop(top)
            table_string.append('          <td>{0}</td>'.format(j))
            table_string.append('          <td>{0}</td>'.format(top))
            table_string.append('          <td>{0}</td>'.format(points))
            table_string.append('        </tr>')
        table_string.append('        </table>')
        table_html["gp_{0}".format(gp_labels[k])] = '\n'.join(table_string) 
    
    script, div = components(plot_dict)
    
    return render_template('euro.html', js_resources=js_resources, script=script, div=div, pred=prediction_dict, table=table_html)
Ejemplo n.º 54
0
def plot_lcoe(top):

    # all this can probably be done smarter with a Pandas DataFrame?! Any takers?
    aep = top.fin_a.net_aep
    fcr = top.fin_a.fixed_charge_rate
    turbine_lcoe = OrderedDict(Rotor=(fcr / aep * top.tcc_a.tcc.blade_cost * top.tcc_a.tcc.blade_number + fcr / aep * top.tcc_a.tcc.hub_system_cost) * top.turbine_number,
                                Tower=fcr / aep * top.tcc_a.tcc.tower_cost * top.turbine_number,
                                Nacelle=fcr / aep * top.tcc_a.tcc.nacelle_cost * top.turbine_number)

    infra_lcoe = OrderedDict(Assembly=fcr / aep * top.bos_breakdown.assembly_and_installation_costs,
                              Development=fcr / aep * top.bos_breakdown.development_costs,
                              Electrical=fcr / aep * top.bos_breakdown.electrical_costs,
                              Substructure=fcr / aep * top.bos_breakdown.foundation_and_substructure_costs,
                              Other=fcr / aep * top.bos_breakdown.foundation_and_substructure_costs,
                              Preparation=fcr / aep * top.bos_breakdown.preparation_and_staging_costs,
                              Soft=fcr / aep * top.bos_breakdown.soft_costs,
                              Transportation=fcr / aep * top.bos_breakdown.transportation_costs)

    opex_lcoe = OrderedDict(Opex=top.opex_a.avg_annual_opex / aep)

    turbine_sum = np.sum(turbine_lcoe.values()) 
    infra_sum = np.sum(infra_lcoe.values())
    opex_sum = np.sum(opex_lcoe.values())

    total_lcoe = np.array([turbine_sum, infra_sum, opex_sum]) # array containing Turbine, BOS, and OPEX lcoe costs 
    lcoe = total_lcoe.sum() 
    total_lcoe = OrderedDict(Total=lcoe)

    everything_lcoe = turbine_lcoe
    everything_lcoe.update(infra_lcoe)
    everything_lcoe.update(opex_lcoe)

    cumSum = 0 
    invisibleBlock = OrderedDict()
    for key in everything_lcoe.keys():    
        invisibleBlock[key] = cumSum
        cumSum += everything_lcoe[key]

    everything_lcoe.update(total_lcoe)
    invisibleBlock['Total'] = 0

    Combined = invisibleBlock.values()


    colors = ['white' for i in range(len(Combined))]
    next_color = palette.next()
    for i in range(3):
      colors.append(next_color)
    next_color = palette.next()
    for i in range(8):
      colors.append(next_color)
    colors.append(palette.next())
    colors.append('black')


    myGroup=[]
    for x in range(2):
      for i in range(3):
        myGroup.append('turbine')
      for i in range(8):
        myGroup.append('infrastructure')
      myGroup.append('opex')
      myGroup.append('total')


    for stuff in everything_lcoe.values():    
        Combined.append(stuff)

    myKeys = OrderedDict(turbine=turbine_lcoe.keys(), infra=infra_lcoe.keys(), myOpex=opex_lcoe.keys())

    myNames = myKeys['turbine']
    for stuff in list(myKeys['turbine']):
        myNames.append(stuff)

    myStack  = []
    for i in range(13):
      myStack.append(1)
    for i in range(13):
      myStack.append(2)


    myDict = dict(Amount=Combined, Group=myGroup,  Names=myNames, stack=myStack, color=colors)

    myDF = df(data=myDict)
    # print myDF
    myBar = Bar(myDF, values='Amount', label=CatAttr(columns=['Names'], sort=False), stack="stack",
     toolbar_location="above", color="color", ygrid=False, legend=None,
      title='LCOE Costs Breakdown', ylabel="LCOE ($/kWh)", xlabel="Component",
      tools="crosshair,pan,wheel_zoom,box_zoom,reset,hover,previewsave",
)

    hover = myBar.select(dict(type=HoverTool))
    hover.tooltips = OrderedDict([
                ("Component","@Names"),
                # ("Group", "@Group"), # maybe one day bokeh will fix this and it will work. It should show "turbine, infra, or opex"
            ])

    

    return myBar
Ejemplo n.º 55
0
from bokeh.charts import Bar, output_file, show, vplot, hplot, defaults
from bokeh.sampledata.autompg import autompg as df

df['neg_mpg'] = 0 - df['mpg']

defaults.plot_width = 400
defaults.plot_height = 400

bar_plot = Bar(df, label='cyl', title="label='cyl'")
bar_plot.title_text_font_size = '10pt'

bar_plot2 = Bar(df, label='cyl', bar_width=0.4, title="label='cyl' bar_width=0.4")
bar_plot2.title_text_font_size = '10pt'

bar_plot3 = Bar(df, label='cyl', values='mpg', agg='mean',
                title="label='cyl' values='mpg' agg='mean'")
bar_plot3.title_text_font_size = '10pt'

bar_plot4 = Bar(df, label='cyl', title="label='cyl' color='DimGray'", color='dimgray')
bar_plot4.title_text_font_size = '10pt'

# multiple columns
bar_plot5 = Bar(df, label=['cyl', 'origin'], values='mpg', agg='mean',
                title="label=['cyl', 'origin'] values='mpg' agg='mean'")
bar_plot5.title_text_font_size = '10pt'

bar_plot6 = Bar(df, label='origin', values='mpg', agg='mean', stack='cyl',
                title="label='origin' values='mpg' agg='mean' stack='cyl'",
                legend='top_right')
bar_plot6.title_text_font_size = '10pt'
Ejemplo n.º 56
0
def summarize_plans(state, age, npi):
    todaysdate = str(datetime.now())
    age = str(age)
    if age > '65':
      age = '65'
    elif age < '20':
      age = '20'
    # filter based on what plans are current (not expired) and age
    filteredplans = pd.read_hdf('webapp/data/plan-rates.h5', state, where=['(Age==age) & (RateExpirationDate > todaysdate) & (RateEffectiveDate < todaysdate)'],
                                columns = ['IndividualRate', 'MetalLevel', 'Age','URLForSummaryofBenefitsCoverage','PlanMarketingName'])
    stateave = filteredplans.IndividualRate.mean()
    myave = stateave 
    # plot it
    #filteredplans.groupby('MetalLevel').IndividualRate.mean().plot(kind='bar')
    #statebardf = filteredplans.groupby('MetalLevel').IndividualRate.mean()
    statebardf = filteredplans.groupby('MetalLevel', as_index=False).mean()
    
    #p = mpl.to_bokeh()
    if npi == '':
      p = Bar(filteredplans.groupby('MetalLevel').IndividualRate.mean(), values='IndividualRate',
              xlabel="", ylabel="Montly Premium ($)")
    else:
      print 'input npi is ' + npi
      # read hdf5 of provider-plan pairings
      provnplanpd = pd.read_hdf('webapp/data/plan_providers.h5', state)
      # make a list of planids for the input npi
      planlst = provnplanpd[provnplanpd.npi == npi].plan_id.values
      print planlst
      # read in hdf5 of plan info
      planinfo = pd.read_hdf('webapp/data/plan-rates.h5', state, where=['(Age==age) & (RateExpirationDate > todaysdate) & (RateEffectiveDate < todaysdate)'])

      # for each planid, get the first entry and concatenate them together.
      filteredplans = planinfo[planinfo.PlanId==planlst[0]].groupby('PlanId', as_index=False).first()
      filteredplans.head()
      #pd.concat([filteredplans, filteredplans])

      for ii in range(1, len(planlst)):
          filteredplans = pd.concat([filteredplans, planinfo[planinfo.PlanId==planlst[ii]].groupby('PlanId', as_index=False).first()])

    
      provbardf = filteredplans.groupby('MetalLevel', as_index=False).mean()
      provbardf['average'] = ['provider rates']*len(provbardf.MetalLevel.values)
      statebardf['average'] = ['state average']*len(provbardf.MetalLevel.values)
      myave = statebardf.IndividualRate.mean()
      #provbardf['average'] = [1, 1]
      #statebardf['average'] = [2, 2]
      #plotdf = pd.merge(statebardf, provbardf, on='MetalLevel')
      plotdf = pd.concat([provbardf, statebardf]) 
      #plotdf['state average'] = statebardf['IndividualRate']
      #plotdf['provider rates'] = provbardf['IndividualRate']
      print plotdf  
      p = Bar(plotdf, label='MetalLevel', values='IndividualRate', group='average', legend='top_right',
              xlabel="", ylabel="Montly Premium ($)")
    p.logo = None
    p.plot_height=400
    p.toolbar_location = None
    script,div =  components(p)
    print filteredplans.to_dict(orient='records')
    return {'num_plans':len(filteredplans), 'script': script, 'plot_div': div,
            'national_comp': format_price_comp(float(age2nationalAverage(age))-myave),
            'state_comp': format_price_comp(float(stateave)-myave),
            'plans': render_template('plans.html', plans=filteredplans.sort_values(by='IndividualRate').to_dict(orient='records'))}
Ejemplo n.º 57
0
from bokeh.charts import Bar, output_file, show, vplot
from numpy.random import rand
from pandas import DataFrame

N = 10
data = DataFrame({'A': rand(N), 'B': rand(N), 'C': rand(N)})
# Stack columns A,B,C and convert the multiindices to columns
sdata = data.stack().reset_index()
sdata.columns = ['labels', 'stack', 'values']

bar = Bar(sdata, values='values', label='labels', stack='stack', legend='top_right')
bar2 = Bar(sdata, values='values', label='labels', stack='stack', legend='top_right')
bar2.x_range = bar.x_range  # Link the x axes

output_file("stacked_bar.html")
show(vplot(bar, bar2))
Ejemplo n.º 58
0
def comparison(request, stock_id1, stock_id2):
    stock1 = get_object_or_404(Stock, pk=stock_id1)
    stock2 = get_object_or_404(Stock, pk=stock_id2)
    #update(stock1)
    #update(stock2)

    # Graph

    # Last known weekday
    current_day = weekday().isoformat()

    # Retrieve live data YYYY-MM-DD
    historical_price1 = ystockquote.get_historical_prices(stock1, '2013-01-24', current_day)
    correct_order1 = sorted(historical_price1)
    stock_prices1 = []
    dates1 = []
    for values in correct_order1:
        stock_prices1.append(historical_price1[values]['Adj Close'])
        dates1.append(values)

    # Convert to Float
    for p in range(len(stock_prices1)):
        stock_prices1[p] = float(stock_prices1[p])

    # Convert to Datetime Format
    dates_objects1 = []
    for d in dates1:
        dates_objects1.append(datetime.strptime(d, '%Y-%m-%d'))

    # Retrieve live data YYYY-MM-DD
    historical_price2 = ystockquote.get_historical_prices(stock2, '2013-01-24', current_day)
    correct_order2 = sorted(historical_price2)
    stock_prices2 = []
    dates2 = []
    for values in correct_order2:
        stock_prices2.append(historical_price2[values]['Adj Close'])
        dates2.append(values)

    # Convert to Float
    for p in range(len(stock_prices2)):
        stock_prices2[p] = float(stock_prices2[p])

    # Convert to Datetime Format
    dates_objects2 = []
    for d in dates2:
        dates_objects2.append(datetime.strptime(d, '%Y-%m-%d'))

    #Tools
    hover = HoverTool(mode='vline')
    crosshair = CrosshairTool(dimensions=['height'])
    TOOLS = [BoxZoomTool(), crosshair, PreviewSaveTool(), ResetTool()]

    p1 = figure(x_axis_type="datetime", responsive=True, plot_height=250,tools=TOOLS)
    p1.border_fill = "whitesmoke"

    # Multiple Axises
    min1 = min(stock_prices1)
    max1 = max(stock_prices1)
    min2 = min(stock_prices2)
    max2 = max(stock_prices2)

    p1.y_range = Range1d(start= min1- (min1/10),end=max1+ (min1/10))
    p1.extra_y_ranges = {'range2':Range1d(start= min2- (min2/10),end=max2+ (min2/10))}
    p1.add_layout(LinearAxis(y_range_name="range2"), 'right')

    p1.line(np.array(dates_objects1, dtype=np.datetime64), stock_prices1, color='#b41f2e', legend=stock1.ticker)
    p1.line(np.array(dates_objects2, dtype=np.datetime64), stock_prices2, y_range_name='range2', color='#1F78B4', legend=stock2.ticker)

    p1.grid.grid_line_alpha = 0.3
    p1.xaxis.axis_label = 'Date'
    p1.yaxis.axis_label = 'Price'

    script, div = components(p1)

    # Bar Charts
    mc1 = float((stock1.market_cap[:-1]))
    mc2 = float((stock2.market_cap[:-1]))
    pe1 = float(stock1.pe_ratio)
    pe2 = float(stock2.pe_ratio)
    pb1 =float(stock1.pb_ratio)
    pb2 = float(stock2.pb_ratio)
    vol1 = float(stock1.volume)
    vol2 = float(stock2.volume)
    rev1 = float((stock1.revenue[:-1]))
    rev2 = float((stock2.revenue[:-1]))
    peg1 = float(stock1.peg)
    peg2 = float(stock2.peg)

    mc_dict= {'tickers':[stock1.ticker,stock2.ticker],
              'market cap':[mc1,mc2],
              'PB Ratio':[pb1,pb2],
              'PE Ratio':[pe1,pe2],
              'Volume': [vol1,vol2],
              'Revenue': [rev1,rev2],
              'PE Growth': [peg1,peg2]
              }

    #Hover Tools - Not working
    #hover_mc = HoverTool(tooltips=[('Market Cap', '@height'), ('Ticker', '@cat'), ])

    mc_bar = Bar(mc_dict,width=250, height=250,values='market cap',label='tickers',
                 color=color(columns='market cap',palette=['#b41f2e','#1F78B4']), title="Market Cap", ylabel='Billions')
    vol_bar = Bar(mc_dict, width=250, height=250,values='Volume', label='tickers',
                 color=color(columns='Volume',palette=['#b41f2e','#1F78B4']), title="Volume",ylabel='Volume')
    pb_bar = Bar(mc_dict, width=250, height=250,values='PB Ratio', label='tickers',
                 color=color(columns='PB Ratio',palette=['#b41f2e','#1F78B4']),title="PB Ratio",ylabel='Ratio')
    pe_bar = Bar(mc_dict, width=250, height=250,values='PE Ratio', label='tickers',
                 color=color(columns='PE Ratio',palette=['#b41f2e','#1F78B4']),  title="PE Ratio",ylabel='Ratio')
    peg_bar = Bar(mc_dict, width=250, height=250, values='PE Growth', label='tickers',
                 color=color(columns='PE Growth', palette=['#b41f2e', '#1F78B4']), title="PE Growth", ylabel='Percentage(%)')
    rev_bar = Bar(mc_dict, width=250, height=250, values='Revenue', label='tickers',
                 color=color(columns='Revenue', palette=['#b41f2e', '#1F78B4']), title="Revenue", ylabel='Billions')

    mc_bar.border_fill_color = "whitesmoke"
    vol_bar.border_fill_color = "whitesmoke"
    pb_bar.border_fill_color = "whitesmoke"
    pe_bar.border_fill_color = "whitesmoke"
    peg_bar.border_fill_color = "whitesmoke"
    rev_bar.border_fill_color = "whitesmoke"


    grid = gridplot([[mc_bar,rev_bar, pe_bar],[vol_bar, pb_bar, peg_bar]])


    mscript, mdiv = components(grid)

    context = {'stock1': stock1,
               'stock2': stock2,
               'the_script': script,
               'the_div': div,
               'mc1': mscript,
               'mc2': mdiv,
               }

    return render(request, 'stocktracker/comparison.html', context)
	for elem in list_of_elems:
		first = elem[0]
		second = elem[1]
		list_of_words.append(first)
		list_of_num.append(second)
	return list_of_words, list_of_num


a = [(u'colada', 1.06465), (u'mmmmmmmmmmmmmmmmmmmmm', 0.85172), (u'brunched', 0.85172), (u'combinacion', 0.85172), (u'altar', 0.85172), (u'heckled', 0.70977), (u'guitarist', 0.70977), (u'benched', 0.60837), (u'suprisingly', 0.60837), (u'jombot', 0.60837), (u'cpt', 0.53232), (u'pubgrub', 0.53232), (u'prepaired', 0.53232), (u'bestpapersonaltrainercom', 0.53232), (u'touristic', 0.47318), (u'delucas', 0.47318), (u'stickler', 0.47318), (u'parfaits', 0.47318), (u'mochas', 0.45543), (u'bearclaw', 0.42586), (u'isntead', 0.42586), (u'portapottys', 0.42586), (u'centerpieces', 0.42586), (u'newcastle', 0.42586), (u'anf', 0.42586), (u'hollywoodlanes', 0.42586), (u'hideaway', 0.38715), (u'haiku', 0.38715), (u'muffaletta', 0.38715), (u'anazing', 0.38715),(u'balboa', 0.06347), (u'novak', 0.06342), (u'aamco', 0.06337), (u'faded', 0.06317), (u'jojo', 0.06312), (u'unos', 0.06309), (u'proves', 0.06309), (u'refurbish', 0.06309), (u'fleet', 0.06309), (u'koh', 0.06309)]

list_of_words, list_of_num = parse_elements(a)

model = {'TF-IDF': list_of_num, 'Words': list_of_words}
df1 = df(data = model, columns = ['TF-IDF','Words'])

graph1 = Bar(df1, 'Words', values = 'TF-IDF', title = "TF-IDF of top positive words", ylabel = 'TF-IDF  scores', width = 800, height = 400, color = 'blue')
graph1.left[0].formatter.use_scientific= False
graph1.x_range = FactorRange(factors=df1['Words'].tolist())



c = [(u'hoofah', 4.2586), (u'ewwww', 4.2586), (u'disconnected', 0.70977), (u'precooked', 0.70977), (u'crimes', 0.60837), (u'greasiest', 0.60837), (u'redevelopment', 0.60837), (u'sloooooow', 0.53232), (u'yucky', 0.53232), (u'horrifying', 0.53232), (u'rancho', 0.47318), (u'crisco', 0.47318), (u'grabn', 0.42586), (u'gnocci', 0.42586), (u'strictest', 0.38715), (u'clout', 0.38715), (u'unenjoyable', 0.38715), (u't3', 0.36502), (u'terriable', 0.32758), (u'foe', 0.32758), (u'pararell', 0.32758), (u'thrifters', 0.32758), (u'society', 0.30419), (u'cremation', 0.28391), (u'fabricated', 0.28391), (u'yiengling', 0.28391), (u'delish', 0.27475), (u'uncover', 0.26616), (u'm8n', 0.26616), (u'pepparoni', 0.26616),(u'drops', 0.03097), (u'scheduling', 0.03097), (u'towed', 0.03089), (u'stark', 0.03086), (u'bjork', 0.03086), (u'arrogance', 0.03086), (u'maitre', 0.03086), (u'electronica', 0.03086), (u'basing', 0.03086), (u'caters', 0.03086)]
list_of_words2, list_of_num2 = parse_elements(c)
model2 = {'TF-IDF': list_of_num2, 'Words': list_of_words2}
df2 = df(data = model2, columns = ['TF-IDF','Words'])

graph2 = Bar(df2, 'Words', values = 'TF-IDF', title = "TF-IDF of top negative words", ylabel = 'TF-IDF  scores', width = 800, height = 400, color = 'red')
graph2.left[0].formatter.use_scientific= False
graph2.x_range = FactorRange(factors=df2['Words'].tolist())

output_file("swag1.html")
    
    dstat[dname] = grp

    # later, we build a dict containing the grouped data
    


["negative","neutral","positive"]
posavglist = []
negavglist = []
namelist = [] 
for  k,v in dstat.items():
    posavglist.append(list(v.poscount))
    negavglist.append(list(v.negcount))
    namelist.append([k+"_neg",k+"_neu",k+"_pos"])

    
counts = OrderedDict(poscount=posavglist, negcount=negavglist)
bar = Bar(counts, namelist , filename="counts.html")

bar.title("Occurrence of positive and negative counts").xlabel("class").ylabel("count")
bar.legend(True).width(900).height(400).stacked(True)
bar.show()