Ejemplo n.º 1
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.º 2
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.º 3
0
def author_frequency_barplot(nb_top_ners=50, tf=True):
    if tf:
        output_file('../figures/tf_authors.html')
        ner_freqs = pickle.load(open('../workspace/tf.m', "rb"))
    else:
        output_file('../figures/df_authors.html')
        ner_freqs = pickle.load(open('../workspace/df.m', "rb"))

    top_ners = [w for w, _ in ner_freqs.most_common(nb_top_ners)]
    top_freqs = [c for _, c in ner_freqs.most_common(nb_top_ners)]

    names = []
    for name in top_ners:
        name = name.replace('*', '')
        if '(' in name:
            name = name.split('(')[0].strip()
        name = ' '.join([n.lower().capitalize() for n in name.split('_')])
        name = ''.join([
            c for c in unicodedata.normalize('NFKD', name)
            if not unicodedata.combining(c)
        ])
        names.append(name)

    data = pd.DataFrame({'values': top_freqs[:25], 'labels': names[:25]})
    bar1 = Bar(data,
               label=CatAttr(columns=['labels'], sort=False),
               values='values',
               title='Author Frequency (1-25)',
               width=800,
               height=400)
    xaxis = bar1.select(dict(type=Axis))[1]
    xaxis.major_label_standoff = 0
    xaxis.major_label_orientation = np.pi / 2
    xaxis.major_label_standoff = 6
    xaxis.major_tick_out = 0

    data = pd.DataFrame({'values': top_freqs[25:50], 'labels': names[25:50]})
    bar2 = Bar(data,
               label=CatAttr(columns=['labels'], sort=False),
               values='values',
               title='Author Frequency (25-50)',
               width=800,
               height=400)
    xaxis = bar2.select(dict(type=Axis))[1]
    xaxis.major_label_standoff = 0
    xaxis.major_label_orientation = np.pi / 2
    xaxis.major_label_standoff = 6
    xaxis.major_tick_out = 0
    p = vplot(bar1, bar2)
    save(p)
Ejemplo n.º 4
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)
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)
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.º 7
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.º 8
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.º 9
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
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.º 11
0
def plotG(data, ttl):
    fig = Bar(data,
              label=CatAttr(columns=['Group'], sort=False),
              values='Height',
              group='Spec',
              legend=True,
              plot_width=1000,
              plot_height=600,
              title=ttl,
              ylabel='MiB/s')
    fig.title.text_font_size = '18pt'
    # Show value in img
    fig.add_tools(HoverTool())
    hover = fig.select(dict(type=HoverTool))
    hover.tooltips = [('Spec', ' $x'), ('MiB/s', ' @height')]
    return fig
Ejemplo n.º 12
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
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.º 14
0
def display_graph(df):
    df['tweet_ratio'] = 1.0 * df['count'] / df['population']
    df['partisan_split'] = [df['partisan_split'].iloc[i] if df['main_party'].iloc[i] == 'Democratic'\
                            else -df['partisan_split'].iloc[i] for i in range(len(df))]
    df = df[['tweet_ratio', 'partisan_split', 'sentiment', 'location']]
    colors = []
    for i in range(len(df)):
        if df['sentiment'].iloc[i] < df['sentiment'].describe()['25%']:
            colors.append('quartile_1')
        elif (df['sentiment'].iloc[i] < df['sentiment'].describe()['50%']) & (
                df['sentiment'].iloc[i] > df['sentiment'].describe()['25%']):
            colors.append('quartile_2')
        elif (df['sentiment'].iloc[i] < df['sentiment'].describe()['75%']) & (
                df['sentiment'].iloc[i] > df['sentiment'].describe()['50%']):
            colors.append('quartile_3')
        else:
            colors.append('quartile_4')
    df['colors'] = colors
    source = ColumnDataSource(df)

    #p = figure(tools='pan, hover, box_zoom, reset, wheel_zoom')
    p = Bar(
        values='tweet_ratio',
        label='partisan_split',
        color='colors',
        palette=YlOrRd4[::-1],
        data=df,
        legend=False,
        plot_width=1100,
        plot_height=700,
        stack='location',
        title=
        'Tweets per Capita vs Partisan Split and average tweet sentiment (redder = higher sentiment)',
        tools='hover')
    p.yaxis.axis_label = 'Tweet per Person'
    p.xaxis.axis_label = 'Partisan Split (positive number = more self identified democrats)'

    hover = p.select(dict(type=HoverTool))
    hover.tooltips = OrderedDict([('State', '@location'),
                                  ('Tweet per Capita', '@height'),
                                  ('Partisanship', '@partisan_split'),
                                  ('sentiment', '@colors')])
    #   output_file("bar.html")
    return p
Ejemplo n.º 15
0
def generate_single_bar(df, time_str, color_dict, colors):

	df = df[df.percent_total >= 3]
	title = "Failure Rate " + time_str
	fill = [color_dict[model_key] if model_key in color_dict else 'grey' for model_key in df.model]
	source = ColumnDataSource(dict(color=[c for c in df['color']],
		model=[m for m in df['model']],
		failure_rate=[f for f in df['failure_rate']],
		count=[co for co in df['count']]))

	plot = Bar(df, 'model', values='failure_rate', title=title, source=source, tools=['hover'],color='color', legend=None)
	# outline_line_color="color", border_fill_color='color', 
	hover = plot.select(dict(type=HoverTool))
	hover.tooltips = [
        ("Model ", "@model"),
        ("Failure rate ", "@y"),
        ("Number of drives", "@count")        #("Time ", "@timeline"),
        ]
	hover.mode = 'mouse'
	plot.xaxis.axis_label = 'Model Serial Number'
	plot.yaxis.axis_label = 'Naive Failure Rate'
	plot.title_text_font_size="18px"
	plot.grid.grid_line_alpha = 0
	plot.ygrid.grid_line_color = None
	plot.toolbar.logo = None
	plot.outline_line_width = 0
	plot.outline_line_color = "white"
	plot.plot_height = 600
	plot.plot_width = 800
	plot.xaxis.major_tick_line_color = None
	plot.yaxis.major_tick_line_color = None
	plot.xaxis.axis_line_width = 2
	plot.yaxis.axis_line_width = 2
	plot.title.text_font_size = '16pt'
	plot.xaxis.axis_label_text_font_size = "14pt"
	plot.xaxis.major_label_text_font_size = "14pt"
	plot.yaxis.axis_label_text_font_size = "14pt"
	plot.yaxis.major_label_text_font_size = "14pt"
	return(plot)
Ejemplo n.º 16
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 show_kvm_exit_types(df, task_re, label):

    df = df[df['event'] == 'kvm_exit']
    df = df[df['task_name'].str.match(task_re)]
    # the next_comm column contains the exit code
    exit_codes = Series(KVM_EXIT_REASONS)
    # add  new column congaining the exit reason in clear text
    df['exit_reason'] = df['next_comm'].map(exit_codes)
    time_span_msec = get_time_span_msec(df)
    df.drop(
        ['cpu', 'duration', 'event', 'next_pid', 'pid', 'next_comm', 'usecs'],
        inplace=True,
        axis=1)

    # Get the list of exit reasons, sorted alphabetically
    reasons = pandas.unique(df.exit_reason.ravel()).tolist()
    reasons.sort()

    # group by task name then exit reasons
    gb = df.groupby(['task_name', 'exit_reason'])
    # number of exit types
    size_series = gb.size()
    df = size_series.to_frame('count')
    df.reset_index(inplace=True)

    p = Bar(df,
            label='task_name',
            values='count',
            stack='exit_reason',
            title="KVM Exit types per task (%s, %d msec window)" %
            (label, time_span_msec),
            legend='top_right',
            tools="resize,hover,save",
            width=1000,
            height=800)
    p._xaxis.axis_label = "Task Name"
    p._xaxis.axis_label_text_font_size = "12pt"
    p._yaxis.axis_label = "Exit Count (sum)"
    p._yaxis.axis_label_text_font_size = "12pt"

    # Cannot find a way to display the exit reason in the tooltip
    # from bokeh.models.renderers import GlyphRenderer
    # glr = p.select(dict(type=GlyphRenderer))
    # bar_source = glr[0].data_source
    # print bar_source.data
    # bar_source = glr[1].data_source
    # bar_source.data['exit_reason'] = ['HOHO']
    hover = p.select(dict(type=HoverTool))
    hover.tooltips = OrderedDict([
        ("task", "$x"),
        # {"reason", "@exit_reason"},
        ("count", "@height")
    ])
    # specify how to output the plot(s)

    # table with counts
    gb = df.groupby(['exit_reason'])
    keys = gb.groups.keys()
    dfr_list = []
    for reason in keys:
        dfr = gb.get_group(reason)
        # drop the exit reason column
        dfr = dfr.drop(['exit_reason'], axis=1)
        # rename the count column with the reason name
        dfr.rename(columns={'count': reason}, inplace=True)
        # set the task name as the index
        dfr.set_index('task_name', inplace=True)
        dfr_list.append(dfr)
    # concatenate all task columns into 1 dataframe that has the exit reason as the index
    # counts for missing exit reasons will be set to NaN
    dft = pandas.concat(dfr_list, axis=1)
    dft.fillna(0, inplace=True)
    # Add a total column
    dft['TOTAL'] = dft.sum(axis=1)
    sfmt = StringFormatter(text_align='center', font_style='bold')
    nfmt = NumberFormatter(format='0,0')

    col_names = list(dft.columns.values)
    col_names.sort()
    # move 'TOTAL' at end of list
    col_names.remove('TOTAL')
    col_names.append('TOTAL')
    # convert index to column name
    dft.reset_index(level=0, inplace=True)
    dft.rename(columns={'index': 'Task'}, inplace=True)
    columns = [
        TableColumn(field=name, title=name, formatter=nfmt)
        for name in col_names
    ]
    columns.insert(0, TableColumn(field='Task', title='Task', formatter=sfmt))
    table = DataTable(source=ColumnDataSource(dft),
                      columns=columns,
                      width=1000,
                      row_headers=False,
                      height='auto')
    output_html(vplot(p, table), 'kvm-types', task_re)
    '''
Ejemplo n.º 18
0
def dashboard():
    # Creating all the queries
    items = getItems(suffix='items', apiKey=apiKey)
    users = getItems(suffix='users', apiKey=apiKey)

    # %% Creating df defining the ratio of right swipes to left swipes
    df_right_left = pd.DataFrame(items)

    # Grouping by, and performing different aggregations
    df_right_left = df_right_left[[
        'category', 'nuSwipesRight', 'nuSwipesLeft'
    ]].groupby('category', as_index=False).agg({
        'nuSwipesRight': 'sum',
        'nuSwipesLeft': 'sum'
    })

    # Finding the ratio
    df_right_left['RightOverLeft'] = df_right_left['nuSwipesRight'].div(
        df_right_left['nuSwipesLeft'])

    # Creating the first bar chart
    p1 = Bar(data=df_right_left,
             label='category',
             values='RightOverLeft',
             title="Category vs Right-Left Ratio",
             color='category',
             tools='hover',
             ylabel='Right / Left Swipes',
             agg='mean',
             legend=False)

    # Defining the hover tools
    hover = p1.select(dict(type=HoverTool))

    # Defining p1 tooltips
    hover.tooltips = [('Value', '@y'), ('Category', '@x')]
    #show(p1)
    # %% Creating df of time-per-controller variables
    df_users = pd.io.json.json_normalize(users)
    df_users = df_users.filter(regex='timePerController')
    cols = [col.split('.')[1] for col in df_users.columns.values]
    df_users.columns = cols

    # Melting df
    df_users = pd.melt(df_users, value_name='TimeSpent', var_name='Variable')

    # Creating p2
    p2 = Bar(data=df_users,
             label='Variable',
             values='TimeSpent',
             title='Average Time Spent on Controllers',
             color='Variable',
             tools='hover',
             agg='mean',
             legend=False)

    # Defining the hover tools
    hover = p2.select(dict(type=HoverTool))

    # Defining p1 tooltips
    hover.tooltips = [('Value', '@y'), ('Controller Type', '@x')]

    # show(p2)
    # Defining dashboard layout

    p1_script, p1_div = components(p1)
    p2_script, p2_div = components(p2)

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

    tab1 = Panel(child=p1, title='Right-Left Ratio')
    tab2 = Panel(child=p2, title='Time on Controllers')

    tab_plot = Tabs(tabs=[tab1, tab2])

    #show(tab_plot)
    #script, div = components(dict(plot=tabs))
    script, div = components(dict(plot=tab_plot))

    return (render_template('index.html',
                            script=script,
                            div=div,
                            js_resources=js_resources,
                            css_resources=css_resources))
              value_vars=['bronze', 'silver', 'gold', 'total'],
              value_name='medal_count',
              var_name='medal')

bar1 = Bar(df1,
           values='medal_count',
           label='abbr',
           agg='mean',
           group=['medal'],
           title="Olympics Mdeals",
           color=['brown', 'silver', 'gold', 'green'],
           plot_width=1000,
           tools='hover')

# set the tooltip for detail information of the bars
hover1 = bar1.select(dict(type=HoverTool))
hover1.tooltips = [('medals', '@height'), ('Country', '@abbr')]

output_file("bar1.html")

# melt the data for second bar chart
df2 = pd.melt(df,
              id_vars=['abbr'],
              value_vars=['bronze', 'silver', 'gold'],
              value_name='medal_count',
              var_name='medal')

bar2 = Bar(df2,
           values='medal_count',
           label='abbr',
           agg='mean',
Ejemplo n.º 20
0
def make_plot(dataframe=pd.DataFrame(),
              highlight=[],
              top=100,
              minvalues=0.01,
              stacked=True,
              lgaxis=True,
              errorbar=True,
              showS1=True,
              showST=True):
    """
    Basic method to plot first and total order sensitivity indices.

    This is the method to generate a Bokeh plot similar to the burtin example
    template at the Bokeh website. For clarification, parameters refer to an
    input being measured (Tmax, C, k2, etc.) and stats refer to the 1st or
    total order sensitivity index.

    Parameters
    -----------
    dataframe  : pandas dataframe
                 Dataframe containing sensitivity analysis results to be
                 plotted.
    highlight  : lst, optional
                 List of strings indicating which parameter wedges will be
                 highlighted.
    top        : int, optional
                 Integer indicating the number of parameters to display
                 (highest sensitivity values) (after minimum cutoff is
                 applied).
    minvalues  : float, optional
                 Cutoff minimum for which parameters should be plotted.
                 Applies to total order only.
    stacked    : bool, optional
                 Boolean indicating in bars should be stacked for each
                 parameter (True) or unstacked (False).
    lgaxis     : bool, optional
                 Boolean indicating if log axis should be used (True) or if a
                 linear axis should be used (False).
    errorbar   : bool, optional
                 Boolean indicating if error bars are shown (True) or are
                 omitted (False).
    showS1     : bool, optional
                 Boolean indicating whether 1st order sensitivity indices
                 will be plotted (True) or omitted (False).
    showST     : bool, optional
                 Boolean indicating whether total order sensitivity indices
                 will be plotted (True) or omitted (False).

                 **Note if showS1 and showST are both false, the plot will
                 default to showing ST data only instead of a blank plot**

    Returns
    --------
    p : bokeh figure
        A Bokeh figure of the data to be plotted
    """

    df = dataframe
    top = int(top)
    # Initialize boolean checks and check dataframe structure
    if (('S1' not in df) or ('ST' not in df) or ('Parameter' not in df)
            or ('ST_conf' not in df) or ('S1_conf' not in df)):
        raise Exception('Dataframe not formatted correctly')

    # Remove rows which have values less than cutoff values
    df = df[df['ST'] > minvalues]
    df = df.dropna()

    # Only keep top values indicated by variable top
    df = df.sort_values('ST', ascending=False)
    df = df.head(top)
    df = df.reset_index(drop=True)

    # Create arrays of colors and order labels for plotting
    colors = ["#a1d99b", "#31a354", "#546775", "#225ea8"]
    s1color = np.array(["#31a354"] * df.S1.size)
    sTcolor = np.array(["#a1d99b"] * df.ST.size)
    errs1color = np.array(["#225ea8"] * df.S1.size)
    errsTcolor = np.array(["#546775"] * df.ST.size)
    firstorder = np.array(["1st (S1)"] * df.S1.size)
    totalorder = np.array(["Total (ST)"] * df.S1.size)

    # Add column indicating which parameters should be highlighted
    tohighlight = df.Parameter.isin(highlight)
    df['highlighted'] = tohighlight

    back_color = {
        True: "#aeaeb8",
        False: "#e6e6e6",
    }
    # Switch to bar chart if dataframe shrinks below 5 parameters
    if len(df) <= 5:
        if stacked is False:
            data = {
                'Sensitivity':
                pd.Series.append(df.ST, df.S1),
                'Parameter':
                pd.Series.append(df.Parameter, df.Parameter),
                'Order':
                np.append(np.array(['ST'] * len(df)),
                          np.array(['S1'] * len(df))),
                'Confidence':
                pd.Series.append(df.ST_conf, df.S1_conf)
            }
            p = Bar(data,
                    values='Sensitivity',
                    label='Parameter',
                    group='Order',
                    legend='top_right',
                    color=["#31a354", "#a1d99b"],
                    ylabel='Sensitivity Indices')
        else:
            data = {
                'Sensitivity':
                pd.Series.append(df.S1, (df.ST - df.S1)),
                'Parameter':
                pd.Series.append(df.Parameter, df.Parameter),
                'Order':
                np.append(np.array(['S1'] * len(df)),
                          np.array(['ST'] * len(df))),
                'Confidence':
                pd.Series.append(df.S1_conf, df.ST_conf)
            }
            p = Bar(data,
                    values='Sensitivity',
                    label='Parameter',
                    color='Order',
                    legend='top_right',
                    stack='Order',
                    palette=["#31a354", "#a1d99b"],
                    ylabel='Sensitivity Indices')

        return p

    # Create Dictionary of colors
    stat_color = OrderedDict()
    error_color = OrderedDict()
    for i in range(0, 2):
        stat_color[i] = colors[i]
    # Reset index of dataframe.
    for i in range(2, 4):
        error_color[i] = colors[i]

    # Sizing parameters
    width = 800
    height = 800
    inner_radius = 90
    outer_radius = 300 - 10

    # Determine wedge size based off number of parameters
    big_angle = 2.0 * np.pi / (len(df) + 1)
    # Determine division of wedges for plotting bars based on # stats plotted
    # for stacked or unstacked bars
    if stacked is False:
        small_angle = big_angle / 5
    else:
        small_angle = big_angle / 3
    # tools enabled for bokeh figure
    plottools = "hover, wheel_zoom, save, reset, resize"  # , tap"
    # Initialize figure with tools, coloring, etc.
    p = figure(plot_width=width,
               plot_height=height,
               title="",
               x_axis_type=None,
               y_axis_type=None,
               x_range=(-350, 350),
               y_range=(-350, 350),
               min_border=0,
               outline_line_color="#e6e6e6",
               background_fill_color="#e6e6e6",
               border_fill_color="#e6e6e6",
               tools=plottools)
    # Specify labels for hover tool
    hover = p.select(dict(type=HoverTool))
    hover.tooltips = [("Order", "@Order"), ("Parameter", "@Param"),
                      ("Sensitivity", "@Sens"), ("Confidence", "@Conf")]
    hover.point_policy = "follow_mouse"

    p.xgrid.grid_line_color = None
    p.ygrid.grid_line_color = None

    # annular wedges divided into smaller sections for bars
    # Angles for axial line placement
    num_lines = np.arange(0, len(df) + 1, 1)
    line_angles = np.pi / 2 - big_angle / 2 - num_lines * big_angle

    # Angles for data placement
    angles = np.pi / 2 - big_angle / 2 - df.index.to_series() * big_angle

    # circular axes and labels
    minlabel = min(round(np.log10(min(df.ST))), round(np.log10(min(df.S1))))
    labels = np.power(10.0, np.arange(0, minlabel - 1, -1))

    # Set max radial line to correspond to 1.1 * maximum value + error
    maxvalST = max(df.ST + df.ST_conf)
    maxvalS1 = max(df.S1 + df.S1_conf)
    maxval = max(maxvalST, maxvalS1)
    labels = np.append(labels, 0.0)
    labels[0] = round(1.1 * maxval, 1)

    # Determine if radial axis are log or linearly scaled
    if lgaxis is True:
        radii = (((np.log10(labels / labels[0])) + labels.size) *
                 (outer_radius - inner_radius) / labels.size + inner_radius)
        radii[-1] = inner_radius
    else:
        labels = np.delete(labels, -2)
        radii = (outer_radius -
                 inner_radius) * labels / labels[0] + inner_radius

    # Convert sensitivity values to the plotted values
    # Same conversion as for the labels above
    # Also calculate the angle to which the bars are placed
    # Add values to the dataframe for future reference
    cols = np.array(['S1', 'ST'])
    for statistic in range(0, 2):
        if lgaxis is True:
            radius_of_stat = (
                ((np.log10(df[cols[statistic]] / labels[0])) + labels.size) *
                (outer_radius - inner_radius) / labels.size + inner_radius)
            lower_of_stat = (((np.log10(
                (df[cols[statistic]] - df[cols[statistic] + '_conf']) /
                labels[0])) + labels.size) *
                             (outer_radius - inner_radius) / labels.size +
                             inner_radius)
            higher_of_stat = (((np.log10(
                (df[cols[statistic]] + df[cols[statistic] + '_conf']) /
                labels[0])) + labels.size) *
                              (outer_radius - inner_radius) / labels.size +
                              inner_radius)
        else:

            radius_of_stat = ((outer_radius - inner_radius) *
                              df[cols[statistic]] / labels[0] + inner_radius)
            lower_of_stat = (
                (outer_radius - inner_radius) *
                (df[cols[statistic]] - df[cols[statistic] + '_conf']) /
                labels[0] + inner_radius)
            higher_of_stat = ((outer_radius - inner_radius) * (
                (df[cols[statistic]] + df[cols[statistic] + '_conf']) /
                labels[0]) + inner_radius)

        if stacked is False:
            startA = -big_angle + angles + (2 * statistic + 1) * small_angle
            stopA = -big_angle + angles + (2 * statistic + 2) * small_angle
            df[cols[statistic] + '_err_angle'] = pd.Series(
                (startA + stopA) / 2, index=df.index)
        else:
            startA = -big_angle + angles + (1) * small_angle
            stopA = -big_angle + angles + (2) * small_angle
            if statistic == 0:
                df[cols[statistic] + '_err_angle'] = pd.Series(
                    (startA * 2 + stopA) / 3, index=df.index)
            if statistic == 1:
                df[cols[statistic] + '_err_angle'] = pd.Series(
                    (startA + stopA * 2) / 3, index=df.index)
        df[cols[statistic] + 'radial'] = pd.Series(radius_of_stat,
                                                   index=df.index)
        df[cols[statistic] + 'upper'] = pd.Series(higher_of_stat,
                                                  index=df.index)
        df[cols[statistic] + 'lower'] = pd.Series(lower_of_stat,
                                                  index=df.index)
        df[cols[statistic] + '_start_angle'] = pd.Series(startA,
                                                         index=df.index)
        df[cols[statistic] + '_stop_angle'] = pd.Series(stopA, index=df.index)

        # df[cols[statistic]+'_err_angle'] = pd.Series((startA+stopA)/2,
        #                                              index=df.index)
        inner_rad = np.ones_like(angles) * inner_radius
        df[cols[statistic] + 'lower'] = df[cols[statistic] +
                                           'lower'].fillna(90)
    # Store plotted values into dictionary to be add glyphs
    pdata = pd.DataFrame({
        'x':
        np.append(np.zeros_like(inner_rad), np.zeros_like(inner_rad)),
        'y':
        np.append(np.zeros_like(inner_rad), np.zeros_like(inner_rad)),
        'ymin':
        np.append(inner_rad, inner_rad),
        'ymax':
        pd.Series.append(df[cols[1] + 'radial'],
                         df[cols[0] + 'radial']).reset_index(drop=True),
        'starts':
        pd.Series.append(df[cols[1] + '_start_angle'],
                         df[cols[0] + '_start_angle']).reset_index(drop=True),
        'stops':
        pd.Series.append(df[cols[1] + '_stop_angle'],
                         df[cols[0] + '_stop_angle']).reset_index(drop=True),
        'Param':
        pd.Series.append(df.Parameter, df.Parameter).reset_index(drop=True),
        'Colors':
        np.append(sTcolor, s1color),
        'Error Colors':
        np.append(errsTcolor, errs1color),
        'Conf':
        pd.Series.append(df.ST_conf, df.S1_conf).reset_index(drop=True),
        'Order':
        np.append(totalorder, firstorder),
        'Sens':
        pd.Series.append(df.ST, df.S1).reset_index(drop=True),
        'Lower':
        pd.Series.append(df.STlower, df.S1lower).reset_index(drop=True),
        'Upper':
        pd.Series.append(
            df.STupper,
            df.S1upper,
        ).reset_index(drop=True),
        'Err_Angle':
        pd.Series.append(
            df.ST_err_angle,
            df.S1_err_angle,
        ).reset_index(drop=True)
    })
    # removed S1 or ST values if indicated by input
    if showS1 is False:
        pdata = pdata.head(len(df))
    if showST is False:
        pdata = pdata.tail(len(df))
    # convert dataframe to ColumnDataSource for glyphs
    pdata_s = ColumnDataSource(pdata)

    colors = [back_color[highl] for highl in df.highlighted]
    p.annular_wedge(
        0,
        0,
        inner_radius,
        outer_radius,
        -big_angle + angles,
        angles,
        color=colors,
    )
    # Adding axis lines and labels
    p.circle(0, 0, radius=radii, fill_color=None, line_color="white")
    p.text(0,
           radii[:], [str(r) for r in labels[:]],
           text_font_size="8pt",
           text_align="center",
           text_baseline="middle")

    # Specify that the plotted bars are the only thing to activate hovertool
    hoverable = p.annular_wedge(x='x',
                                y='y',
                                inner_radius='ymin',
                                outer_radius='ymax',
                                start_angle='starts',
                                end_angle='stops',
                                color='Colors',
                                source=pdata_s)
    hover.renderers = [hoverable]

    # Add error bars
    if errorbar is True:
        p.annular_wedge(0,
                        0,
                        pdata['Lower'],
                        pdata['Upper'],
                        pdata['Err_Angle'],
                        pdata['Err_Angle'],
                        color=pdata['Error Colors'],
                        line_width=1.0)

        p.annular_wedge(0,
                        0,
                        pdata['Lower'],
                        pdata['Lower'],
                        pdata['starts'],
                        pdata['stops'],
                        color=pdata['Error Colors'],
                        line_width=2.0)

        p.annular_wedge(0,
                        0,
                        pdata['Upper'],
                        pdata['Upper'],
                        pdata['starts'],
                        pdata['stops'],
                        color=pdata['Error Colors'],
                        line_width=2.0)
    # Placement of parameter labels
    xr = (radii[0] * 1.1) * np.cos(np.array(-big_angle / 2 + angles))
    yr = (radii[0] * 1.1) * np.sin(np.array(-big_angle / 2 + angles))

    label_angle = np.array(-big_angle / 2 + angles)
    label_angle[label_angle < -np.pi / 2] += np.pi

    # Placing Labels and Legend
    legend_text = ['ST', 'ST Conf', 'S1', 'S1 Conf']
    p.text(xr,
           yr,
           df.Parameter,
           angle=label_angle,
           text_font_size="9pt",
           text_align="center",
           text_baseline="middle")

    p.rect([-40, -40], [30, -10],
           width=30,
           height=13,
           color=list(stat_color.values()))
    p.rect([-40, -40], [10, -30],
           width=30,
           height=1,
           color=list(error_color.values()))
    p.text([-15, -15, -15, -15], [30, 10, -10, -30],
           text=legend_text,
           text_font_size="9pt",
           text_align="left",
           text_baseline="middle")
    p.annular_wedge(0,
                    0,
                    inner_radius - 10,
                    outer_radius + 10,
                    -big_angle + line_angles,
                    -big_angle + line_angles,
                    color="#999999")

    return p
Ejemplo n.º 21
0
def make_plot(dataframe=pd.DataFrame(), highlight=[],
              top=100, minvalues=0.01, stacked=True, lgaxis=True,
              errorbar=True, showS1=True, showST=True):
    """
    Basic method to plot first and total order sensitivity indices.

    This is the method to generate a Bokeh plot similar to the burtin example
    template at the Bokeh website. For clarification, parameters refer to an
    input being measured (Tmax, C, k2, etc.) and stats refer to the 1st or
    total order sensitivity index.

    Parameters
    -----------
    dataframe  : pandas dataframe
                 Dataframe containing sensitivity analysis results to be
                 plotted.
    highlight  : lst, optional
                 List of strings indicating which parameter wedges will be
                 highlighted.
    top        : int, optional
                 Integer indicating the number of parameters to display
                 (highest sensitivity values) (after minimum cutoff is
                 applied).
    minvalues  : float, optional
                 Cutoff minimum for which parameters should be plotted.
                 Applies to total order only.
    stacked    : bool, optional
                 Boolean indicating in bars should be stacked for each
                 parameter (True) or unstacked (False).
    lgaxis     : bool, optional
                 Boolean indicating if log axis should be used (True) or if a
                 linear axis should be used (False).
    errorbar   : bool, optional
                 Boolean indicating if error bars are shown (True) or are
                 omitted (False).
    showS1     : bool, optional
                 Boolean indicating whether 1st order sensitivity indices
                 will be plotted (True) or omitted (False).
    showST     : bool, optional
                 Boolean indicating whether total order sensitivity indices
                 will be plotted (True) or omitted (False).

                 **Note if showS1 and showST are both false, the plot will
                 default to showing ST data only instead of a blank plot**

    Returns
    --------
    p : bokeh figure
        A Bokeh figure of the data to be plotted
    """

    df = dataframe
    top = int(top)
    # Initialize boolean checks and check dataframe structure
    if (('S1' not in df) or ('ST' not in df) or ('Parameter' not in df) or
       ('ST_conf' not in df) or ('S1_conf' not in df)):
        raise Exception('Dataframe not formatted correctly')

    # Remove rows which have values less than cutoff values
    df = df[df['ST'] > minvalues]
    df = df.dropna()

    # Only keep top values indicated by variable top
    df = df.sort_values('ST', ascending=False)
    df = df.head(top)
    df = df.reset_index(drop=True)

    # Create arrays of colors and order labels for plotting
    colors = ["#a1d99b", "#31a354", "#546775", "#225ea8"]
    s1color = np.array(["#31a354"]*df.S1.size)
    sTcolor = np.array(["#a1d99b"]*df.ST.size)
    errs1color = np.array(["#225ea8"]*df.S1.size)
    errsTcolor = np.array(["#546775"]*df.ST.size)
    firstorder = np.array(["1st (S1)"]*df.S1.size)
    totalorder = np.array(["Total (ST)"]*df.S1.size)

    # Add column indicating which parameters should be highlighted
    tohighlight = df.Parameter.isin(highlight)
    df['highlighted'] = tohighlight

    back_color = {
                  True: "#aeaeb8",
                  False: "#e6e6e6",
                 }
    # Switch to bar chart if dataframe shrinks below 5 parameters
    if len(df) <= 5:
        if stacked is False:
            data = {
                    'Sensitivity': pd.Series.append(df.ST, df.S1),
                    'Parameter': pd.Series.append(df.Parameter, df.Parameter),
                    'Order': np.append(np.array(['ST']*len(df)),
                                       np.array(['S1']*len(df))),
                    'Confidence': pd.Series.append(df.ST_conf,
                                                   df.S1_conf)
                    }
            p = Bar(data, values='Sensitivity', label='Parameter',
                    group='Order', legend='top_right',
                    color=["#31a354", "#a1d99b"], ylabel='Sensitivity Indices')
        else:
            data = {
                    'Sensitivity': pd.Series.append(df.S1, (df.ST-df.S1)),
                    'Parameter': pd.Series.append(df.Parameter, df.Parameter),
                    'Order': np.append(np.array(['S1']*len(df)),
                                       np.array(['ST']*len(df))),
                    'Confidence': pd.Series.append(df.S1_conf,
                                                   df.ST_conf)
                    }
            p = Bar(data, values='Sensitivity', label='Parameter',
                    color='Order', legend='top_right',
                    stack='Order', palette=["#31a354", "#a1d99b"],
                    ylabel='Sensitivity Indices')

        return p

    # Create Dictionary of colors
    stat_color = OrderedDict()
    error_color = OrderedDict()
    for i in range(0, 2):
        stat_color[i] = colors[i]
    # Reset index of dataframe.
    for i in range(2, 4):
        error_color[i] = colors[i]

    # Sizing parameters
    width = 800
    height = 800
    inner_radius = 90
    outer_radius = 300 - 10

    # Determine wedge size based off number of parameters
    big_angle = 2.0 * np.pi / (len(df)+1)
    # Determine division of wedges for plotting bars based on # stats plotted
    # for stacked or unstacked bars
    if stacked is False:
        small_angle = big_angle / 5
    else:
        small_angle = big_angle / 3
    # tools enabled for bokeh figure
    plottools = "hover, wheel_zoom, save, reset, resize"  # , tap"
    # Initialize figure with tools, coloring, etc.
    p = figure(plot_width=width, plot_height=height, title="",
               x_axis_type=None, y_axis_type=None,
               x_range=(-350, 350), y_range=(-350, 350),
               min_border=0, outline_line_color="#e6e6e6",
               background_fill_color="#e6e6e6", border_fill_color="#e6e6e6",
               tools=plottools)
    # Specify labels for hover tool
    hover = p.select(dict(type=HoverTool))
    hover.tooltips = [("Order", "@Order"), ("Parameter", "@Param"),
                      ("Sensitivity", "@Sens"), ("Confidence", "@Conf")]
    hover.point_policy = "follow_mouse"

    p.xgrid.grid_line_color = None
    p.ygrid.grid_line_color = None

    # annular wedges divided into smaller sections for bars
    # Angles for axial line placement
    num_lines = np.arange(0, len(df)+1, 1)
    line_angles = np.pi/2 - big_angle/2 - num_lines*big_angle

    # Angles for data placement
    angles = np.pi/2 - big_angle/2 - df.index.to_series()*big_angle

    # circular axes and labels
    minlabel = min(round(np.log10(min(df.ST))), round(np.log10(min(df.S1))))
    labels = np.power(10.0, np.arange(0, minlabel-1, -1))

    # Set max radial line to correspond to 1.1 * maximum value + error
    maxvalST = max(df.ST+df.ST_conf)
    maxvalS1 = max(df.S1+df.S1_conf)
    maxval = max(maxvalST, maxvalS1)
    labels = np.append(labels, 0.0)
    labels[0] = round(1.1*maxval, 1)

    # Determine if radial axis are log or linearly scaled
    if lgaxis is True:
            radii = (((np.log10(labels / labels[0])) +
                     labels.size) * (outer_radius - inner_radius) /
                     labels.size + inner_radius)
            radii[-1] = inner_radius
    else:
        labels = np.delete(labels, -2)
        radii = (outer_radius - inner_radius)*labels/labels[0] + inner_radius

    # Convert sensitivity values to the plotted values
    # Same conversion as for the labels above
    # Also calculate the angle to which the bars are placed
    # Add values to the dataframe for future reference
    cols = np.array(['S1', 'ST'])
    for statistic in range(0, 2):
        if lgaxis is True:
            radius_of_stat = (((np.log10(df[cols[statistic]] / labels[0])) +
                              labels.size) * (outer_radius - inner_radius) /
                              labels.size + inner_radius)
            lower_of_stat = (((np.log10((df[cols[statistic]] -
                               df[cols[statistic]+'_conf']) / labels[0])) +
                              labels.size) * (outer_radius - inner_radius) /
                             labels.size + inner_radius)
            higher_of_stat = (((np.log10((df[cols[statistic]] +
                               df[cols[statistic]+'_conf']) / labels[0])) +
                              labels.size) * (outer_radius - inner_radius) /
                              labels.size + inner_radius)
        else:

            radius_of_stat = ((outer_radius - inner_radius) *
                              df[cols[statistic]]/labels[0] + inner_radius)
            lower_of_stat = ((outer_radius - inner_radius) *
                             (df[cols[statistic]] -
                             df[cols[statistic]+'_conf'])/labels[0] +
                             inner_radius)
            higher_of_stat = ((outer_radius - inner_radius) *
                              ((df[cols[statistic]] +
                               df[cols[statistic]+'_conf'])/labels[0]) +
                              inner_radius)

        if stacked is False:
            startA = -big_angle + angles + (2*statistic + 1)*small_angle
            stopA = -big_angle + angles + (2*statistic + 2)*small_angle
            df[cols[statistic]+'_err_angle'] = pd.Series((startA+stopA)/2,
                                                         index=df.index)
        else:
            startA = -big_angle + angles + (1)*small_angle
            stopA = -big_angle + angles + (2)*small_angle
            if statistic == 0:
                df[cols[statistic]+'_err_angle'] = pd.Series((startA*2 +
                                                              stopA)/3,
                                                             index=df.index)
            if statistic == 1:
                df[cols[statistic]+'_err_angle'] = pd.Series((startA +
                                                              stopA*2)/3,
                                                             index=df.index)
        df[cols[statistic]+'radial'] = pd.Series(radius_of_stat,
                                                 index=df.index)
        df[cols[statistic]+'upper'] = pd.Series(higher_of_stat,
                                                index=df.index)
        df[cols[statistic]+'lower'] = pd.Series(lower_of_stat,
                                                index=df.index)
        df[cols[statistic]+'_start_angle'] = pd.Series(startA,
                                                       index=df.index)
        df[cols[statistic]+'_stop_angle'] = pd.Series(stopA,
                                                      index=df.index)

        # df[cols[statistic]+'_err_angle'] = pd.Series((startA+stopA)/2,
        #                                              index=df.index)
        inner_rad = np.ones_like(angles)*inner_radius
        df[cols[statistic]+'lower'] = df[cols[statistic]+'lower'].fillna(90)
    # Store plotted values into dictionary to be add glyphs
    pdata = pd.DataFrame({
                         'x': np.append(np.zeros_like(inner_rad),
                                        np.zeros_like(inner_rad)),
                         'y': np.append(np.zeros_like(inner_rad),
                                        np.zeros_like(inner_rad)),
                         'ymin': np.append(inner_rad, inner_rad),
                         'ymax': pd.Series.append(df[cols[1]+'radial'],
                                                  df[cols[0]+'radial']
                                                  ).reset_index(drop=True),
                         'starts': pd.Series.append(df[cols[1] +
                                                    '_start_angle'],
                                                    df[cols[0] +
                                                    '_start_angle']
                                                    ).reset_index(drop=True),
                         'stops': pd.Series.append(df[cols[1] +
                                                      '_stop_angle'],
                                                   df[cols[0] +
                                                      '_stop_angle']
                                                   ).reset_index(drop=True),
                         'Param': pd.Series.append(df.Parameter,
                                                       df.Parameter
                                                   ).reset_index(drop=True),
                         'Colors': np.append(sTcolor, s1color),
                         'Error Colors': np.append(errsTcolor, errs1color),
                         'Conf': pd.Series.append(df.ST_conf,
                                                        df.S1_conf
                                                  ).reset_index(drop=True),
                         'Order': np.append(totalorder, firstorder),
                         'Sens': pd.Series.append(df.ST, df.S1
                                                  ).reset_index(drop=True),
                         'Lower': pd.Series.append(df.STlower,
                                                   df.S1lower
                                                   ).reset_index(drop=True),
                         'Upper': pd.Series.append(df.STupper,
                                                   df.S1upper,
                                                   ).reset_index(drop=True),
                         'Err_Angle': pd.Series.append(df.ST_err_angle,
                                                       df.S1_err_angle,
                                                       ).reset_index(drop=True)
                         })
    # removed S1 or ST values if indicated by input
    if showS1 is False:
        pdata = pdata.head(len(df))
    if showST is False:
        pdata = pdata.tail(len(df))
    # convert dataframe to ColumnDataSource for glyphs
    pdata_s = ColumnDataSource(pdata)

    colors = [back_color[highl] for highl in df.highlighted]
    p.annular_wedge(
                    0, 0, inner_radius, outer_radius, -big_angle+angles,
                    angles, color=colors,
                    )
    # Adding axis lines and labels
    p.circle(0, 0, radius=radii, fill_color=None, line_color="white")
    p.text(0, radii[:], [str(r) for r in labels[:]],
           text_font_size="8pt", text_align="center", text_baseline="middle")

    # Specify that the plotted bars are the only thing to activate hovertool
    hoverable = p.annular_wedge(x='x', y='y', inner_radius='ymin',
                                outer_radius='ymax',
                                start_angle='starts',
                                end_angle='stops',
                                color='Colors',
                                source=pdata_s
                                )
    hover.renderers = [hoverable]

    # Add error bars
    if errorbar is True:
        p.annular_wedge(0, 0, pdata['Lower'], pdata['Upper'],
                        pdata['Err_Angle'],
                        pdata['Err_Angle'],
                        color=pdata['Error Colors'], line_width=1.0)

        p.annular_wedge(0, 0, pdata['Lower'], pdata['Lower'],
                        pdata['starts'],
                        pdata['stops'],
                        color=pdata['Error Colors'], line_width=2.0)

        p.annular_wedge(0, 0, pdata['Upper'], pdata['Upper'],
                        pdata['starts'],
                        pdata['stops'],
                        color=pdata['Error Colors'], line_width=2.0)
    # Placement of parameter labels
    xr = (radii[0]*1.1)*np.cos(np.array(-big_angle/2 + angles))
    yr = (radii[0]*1.1)*np.sin(np.array(-big_angle/2 + angles))

    label_angle = np.array(-big_angle/2+angles)
    label_angle[label_angle < -np.pi/2] += np.pi

    # Placing Labels and Legend
    legend_text = ['ST', 'ST Conf', 'S1', 'S1 Conf']
    p.text(xr, yr, df.Parameter, angle=label_angle,
           text_font_size="9pt", text_align="center", text_baseline="middle")

    p.rect([-40, -40], [30, -10], width=30, height=13,
           color=list(stat_color.values()))
    p.rect([-40, -40], [10, -30], width=30, height=1,
           color=list(error_color.values()))
    p.text([-15, -15, -15, -15], [30, 10, -10, -30], text=legend_text,
           text_font_size="9pt", text_align="left", text_baseline="middle")
    p.annular_wedge(0, 0, inner_radius-10, outer_radius+10,
                    -big_angle+line_angles, -big_angle+line_angles,
                    color="#999999")

    return p
def show_kvm_exit_types(df, task_re, label):

    df = df[df['event'] == 'kvm_exit']
    df = df[df['task_name'].str.match(task_re)]
    # the next_comm column contains the exit code
    exit_codes = Series(KVM_EXIT_REASONS)
    # add  new column congaining the exit reason in clear text
    df['exit_reason'] = df['next_comm'].map(exit_codes)
    time_span_msec = get_time_span_msec(df)
    df.drop(['cpu', 'duration', 'event', 'next_pid', 'pid', 'next_comm', 'usecs'], inplace=True, axis=1)

    # Get the list of exit reasons, sorted alphabetically
    reasons = pandas.unique(df.exit_reason.ravel()).tolist()
    reasons.sort()

    # group by task name then exit reasons
    gb = df.groupby(['task_name', 'exit_reason'])
    # number of exit types
    size_series = gb.size()
    df = size_series.to_frame('count')
    df.reset_index(inplace=True)

    p = Bar(df, label='task_name', values='count', stack='exit_reason',
            title="KVM Exit types per task (%s, %d msec window)" % (label, time_span_msec),
            legend='top_right',
            tools="resize,hover,save",
            width=1000, height=800)
    p._xaxis.axis_label = "Task Name"
    p._xaxis.axis_label_text_font_size = "12pt"
    p._yaxis.axis_label = "Exit Count (sum)"
    p._yaxis.axis_label_text_font_size = "12pt"

    # Cannot find a way to display the exit reason in the tooltip
    # from bokeh.models.renderers import GlyphRenderer
    # glr = p.select(dict(type=GlyphRenderer))
    # bar_source = glr[0].data_source
    # print bar_source.data
    # bar_source = glr[1].data_source
    # bar_source.data['exit_reason'] = ['HOHO']
    hover = p.select(dict(type=HoverTool))
    hover.tooltips = OrderedDict([
        ("task", "$x"),
        # {"reason", "@exit_reason"},
        ("count", "@height")
    ])
    # specify how to output the plot(s)

    # table with counts
    gb = df.groupby(['exit_reason'])
    keys = gb.groups.keys()
    dfr_list = []
    for reason in keys:
        dfr = gb.get_group(reason)
        # drop the exit reason column
        dfr = dfr.drop(['exit_reason'], axis=1)
        # rename the count column with the reason name
        dfr.rename(columns={'count': reason}, inplace=True)
        # set the task name as the index
        dfr.set_index('task_name', inplace=True)
        dfr_list.append(dfr)
    # concatenate all task columns into 1 dataframe that has the exit reason as the index
    # counts for missing exit reasons will be set to NaN
    dft = pandas.concat(dfr_list, axis=1)
    dft.fillna(0, inplace=True)
    # Add a total column
    dft['TOTAL'] = dft.sum(axis=1)
    sfmt = StringFormatter(text_align='center', font_style='bold')
    nfmt = NumberFormatter(format='0,0')

    col_names = list(dft.columns.values)
    col_names.sort()
    # move 'TOTAL' at end of list
    col_names.remove('TOTAL')
    col_names.append('TOTAL')
    # convert index to column name
    dft.reset_index(level=0, inplace=True)
    dft.rename(columns={'index': 'Task'}, inplace=True)
    columns = [TableColumn(field=name, title=name, formatter=nfmt) for name in col_names]
    columns.insert(0, TableColumn(field='Task', title='Task', formatter=sfmt))
    table = DataTable(source=ColumnDataSource(dft), columns=columns, width=1000,
                      row_headers=False,
                      height='auto')
    output_html(vplot(p, table), 'kvm-types', task_re)

    '''
Ejemplo n.º 23
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
            'rock':         { "words" : rock_len_words}
            }
data = []
for corp in raw_data:
    for x in raw_data[corp]:
        entry = { 'val': raw_data[corp][x],'cat': x ,'group' : corp}
        data.append(entry)

#print(data)
data_frame = pd.DataFrame(data)


p = Bar(data_frame ,values='val', label='cat', xlabel='corpora', ylabel='word count' , group='group',
        title="Total words for different corpora", legend='top_right' )

yaxis = p.select(dict(type=Axis, layout="left"))[0]
yaxis.formatter.use_scientific = False

output_file("word statistics.html")
show(p)

#
raw_data = {
            'brown':        { "vocabulary" : brown_len_vocab},
            'all_lyrics' :  { "vocabulary" : total_len_vocab},
            'pop' :         { "vocabulary" : pop_len_vocab},
            'rock':         { "vocabulary" : rock_len_vocab}
            }
data = []
for corp in raw_data:
    for x in raw_data[corp]:
Ejemplo n.º 25
0
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!
#**************************************************************************************

print(channel1_data)
print(channel2_data)
Ejemplo n.º 26
0
def compare_libraries_somy(request, experimentId):
    """
	Display somy chart(s)
	:param request: libcodes, referencegenome/resultids
	:return: all chart objects
	"""

    kwargs = {}
    #kwargs['user']=user
    kwargs['listoflinks'] = listoflinks
    kwargs['title'] = "Comparing Somy"

    if request.method == 'POST':

        libcodes = request.POST.getlist('libcodes', '')

        color_list = []
        legendvalues = []
        for libcode in libcodes:
            libobj = Library.objects.get(library_code=libcode)
            legendvalues.append(libobj.library_code + '(' +
                                libobj.sampleid.samplename + ')')
            color = request.POST.get(libcode)
            color_list.append(color)

        somyobjects = CNV.objects.filter(
            library__library_code__in=libcodes).filter(cnv_type__cvterm='Somy')
        contignames = []
        for contig in sorted(
                list(
                    set(
                        somyobjects.values_list('chromosome__chromosome_name',
                                                flat=True)))):
            contignames.append(re.sub(r'\D+', '', re.sub(r'_.+', '', contig)))

        somy_dict = {}
        max_somy = 0
        for libcode in libcodes:
            somy_for_lib = []
            for somyvalue in somyobjects.filter(
                    library__library_code=libcode).order_by(
                        'chromosome__chromosome_name').values_list('cnv_value',
                                                                   flat=True):
                somy_for_lib.append(somyvalue)

                if somyvalue > max_somy:
                    max_somy = somyvalue

            somy_dict[libcode] = somy_for_lib

        plot = Bar(somy_dict,
                   cat=contignames,
                   xlabel="Chromosomes",
                   ylabel="Somy Values",
                   width=1000,
                   height=500,
                   palette=color_list,
                   legend=True,
                   tools='hover')

        hover = plot.select(dict(type=HoverTool))
        hover.tooltips = [("Chromosome", "$x"), ("CNV Value", "@y")]

        script, div = components(plot)

        return render_to_response('snpdb/compare_libraries_somy.html', {
            "script": script,
            "div": div
        },
                                  context_instance=RequestContext(request))

    else:
        exp = Experiment.objects.get(id=experimentId)
        kwargs['exp'] = exp
        libs = []
        for sample in exp.samples.all():
            for lib in sample.library_set.all():
                libs.append(lib)

        kwargs['libs'] = libs
        kwargs['display_form'] = 'yes'
        kwargs['colors'] = [
            'blue', 'orange', 'red', 'green', 'yellow', 'purple', 'pink',
            'black', 'gray', 'cyan', 'white'
        ]

    return render_to_response('snpdb/compare_libraries_somy.html',
                              kwargs,
                              context_instance=RequestContext(request))
Ejemplo n.º 27
0
def robots():
	

	def choose_channel():
		channel_name = raw_input('Enter a channel name: ')
		return channel_name

	def retrieve_links(name_of_channel):
		
		root_url = "https://www.youtube.com"
		url = urllib2.urlopen("https://www.youtube.com/user/" + name_of_channel + "/videos")

		content = url.read()

		soup = BeautifulSoup(content, "html.parser")
		list_of_links = []

		#searches for all 'a' tags that have "/watch" in them.
		for elem in soup.find_all('a', href=re.compile('/watch')):
			list_of_links.append(root_url + elem['href'])

		#This loop gets rid of duplicate links
		i = 0
		while i < len(list_of_links):
		   if list_of_links[i] == list_of_links[i+1]:
		       list_of_links.remove(list_of_links[i])
		       i += 1

		#print("Links for the %d most recent videos:" % len(list_of_links))

		#for x in range(len(list_of_links)):
			#print(list_of_links[x])

		return list_of_links


	#This function will go to each link and scrape data of subscribers, views, likes and dislikes
	def get_data(list_of_links = []):
		
		data = {}
		data['total_views'] = 0
		data['total_likes'] = 0
		data['total_dislikes'] = 0
		data['total_subscribers'] = 0
		

	 	for x in range(len(list_of_links)):

	 		url = urllib2.urlopen(list_of_links[x])
	 		link_content = url.read()
	 		link_soup = BeautifulSoup(link_content, "html.parser")

	 		#print("Video number: %d" % (x+1))
	 		views = link_soup.find('div', {'class' : 'watch-view-count'})
	 		views = views.get_text()
	 		views = views.replace(",", "")
	 		views = views.replace(" views", "")
	 		data['total_views'] += int(views)
	 		#print("%s views" % views)

	 		likes = link_soup.find('button', {'class' : "yt-uix-button yt-uix-button-size-default yt-uix-button-opacity yt-uix-button-has-icon no-icon-markup like-button-renderer-like-button like-button-renderer-like-button-unclicked yt-uix-clickcard-target   yt-uix-tooltip"})
	 		likes = likes.get_text()
	 		likes = likes.replace(",", "")
	 		data['total_likes'] += int(likes)
	 		#print("%s likes" % likes)

	 		dislikes = link_soup.find('button', {'class' : "yt-uix-button yt-uix-button-size-default yt-uix-button-opacity yt-uix-button-has-icon no-icon-markup like-button-renderer-dislike-button like-button-renderer-dislike-button-unclicked yt-uix-clickcard-target   yt-uix-tooltip"})
	 		dislikes = dislikes.get_text()
	 		dislikes = dislikes.replace(",", "")
	 		data['total_dislikes'] += int(dislikes)
	 		#print("%s dislikes" % dislikes)
	 		#print(" ")
	 	
		subscribers = link_soup.find('span', {'class' : "yt-subscription-button-subscriber-count-branded-horizontal yt-subscriber-count"})
		subscribers = subscribers.get_text()
		subscribers = subscribers.replace(",", "")
		data['total_subscribers'] = int(subscribers)

		return data

	name1 = request.args['example']
	name2 = request.args['example2']

	ch1 = name1
	ch2 = name2

	channel1 = retrieve_links(ch1)
	channel2 = retrieve_links(ch2)

	channel1_data = get_data(channel1)
	channel2_data = get_data(channel2)

	#*************************************************************************************************
	#Graphing functions added here:

	# Puts integer values into variables to be used in bokeh graphing:
	ch1TotalViews = channel1_data["total_views"]
	ch2TotalViews = channel2_data["total_views"]

	ch1TotalLikes = channel1_data["total_likes"]
	ch2TotalLikes = channel2_data["total_likes"]

	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!
	#**************************************************************************************

	return render_template("resultsPage.html")
Ejemplo n.º 28
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.º 29
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.º 30
0
cursor = db.cursor()
cursor.execute(
    "select cust_id,quantity from new_schema.cust2 where prod_id=21975 ;")
data = cursor.fetchall()
print(data)

df = pd.DataFrame([[ij for ij in i] for i in data])
df.rename(columns={
    0: 'Customer ID',
    1: 'Quantity'
}, inplace=True)
df = df.sort_values(['Customer ID'], ascending=[1])
#df['new'] = 0
df = df.groupby("Customer ID").sum()
print(df.head(10))

from bokeh.charts import Bar, output_file, save
from bokeh.models import HoverTool

bar = Bar(df,
          'Customer ID',
          values='Quantity',
          title="test chart",
          responsive=True,
          tools='hover',
          legend=False)
hover = bar.select(dict(type=HoverTool))
hover.tooltips = [("Customer ID", "$x"), ("Quantity", "$y")]
output_file('listofcust.html')
save(bar)