Example #1
0
def layout():

    date_select = DateRangeSlider(
        name="period",
        title="Period:",
        value=(start, end),
        bounds=(bounds_start, bounds_end),
        value_labels='show',
        range=(dict(days=1), None))
    date_select.on_change('value', on_date_change)

    country_select = Select(title="Host Site Country:", value="World",
                            options=country_choices)
    country_select.on_change('value', on_country_change)

    controls = VBoxModelForm(_children=[Paragraph(text="Date Range"),
                                        Paragraph(text=""),  # spacing hack
                                        Paragraph(text=""),
                                        date_select, country_select])

    vboxsmall = VBoxModelForm(_children=[controls, source_par])
    #hbox1 = HBox(children=[job_loc_plot_builder(), vboxsmall])
    #hbox2 = HBox(children=[weekday_builder(), jobtype_builder()])
    #layout = VBox(children=[hbox1, hbox2])
    layout = VBox(children=[vboxsmall])

    return layout
Example #2
0
    def createControls(self):
        # Setup Select Panes and Input Widgets

        #Obr - Overburden rock  #ResR - Reservoir rock
        #Obf - Oberburden fluid #Resf - Reservoir fluid
        self.selectObr = Select(value=self.odict_rocks.keyslist()[0], options=self.odict_rocks.keyslist(),
                                title="Rock  Model")
        self.selectResR = Select(value=self.odict_rocks.keyslist()[0], options=self.odict_rocks.keyslist(),
                                 title="Rock  Model")
        self.selectObf = Select(value=self.odict_fluids.keyslist()[0], options=self.odict_fluids.keyslist(),
                                title="Fluid Model")
        self.selectResf = Select(value=self.odict_fluids.keyslist()[0], options=self.odict_fluids.keyslist(),
                                 title="Fluid Model")
        self.selectPres = Select(value=self.odict_pres.keyslist()[0], options=self.odict_pres.keyslist(),
                                 title="Pressure Scenario")

        self.slideDepth = Slider(start=0, end=10000, value=self.init_depth, step=10, title='Depth (TVDSS)',
                                 callback_policy='mouseup')

        self.selectObr.on_change('value', self.on_selection_change)
        self.selectResR.on_change('value', self.on_selection_change)
        self.selectObf.on_change('value', self.on_selection_change)
        self.selectResf.on_change('value', self.on_selection_change)
        self.selectPres.on_change('value', self.on_selection_change)
        self.slideDepth.on_change('value', self.on_selection_change)
Example #3
0
    def set_input_selector(self):
        # print ("set_input_selector")
        """Creates and configures each selector (drop-down menu)."""
        col_names = [x['name'] for x in self.columns]
        col_names.append('None')

        self.plot_selector = Select.create(
            title="PlotType",
            name="plot_type",
            value=self.plot_type,
            options=["line", "scatter", "bar"],
        )

        self.x_selector = Select.create(
            name="x",
            value=self.x,
            options=col_names,
        )

        self.y_selector = Select.create(
            name="y",
            value=self.y,
            options=col_names,
        )

        self.agg_selector = Select.create(
            name='agg',
            value=self.agg,
            options=['sum', 'mean', 'last', 'count', 'percent'],
        )
Example #4
0
def make_sidebar():
    global sidebar, master_selector
    master_selector = Select(title="MASTOR SELECTOR:", value="test", options=["test", 'sandbox', 'template', "timeseries", "mdr_history"])
    def selector_func(attrname, old, new):
        new_master_plot( master_selector.value )
    master_selector.on_change('value', selector_func )
    sidebar = vform(master_selector)
Example #5
0
    def make_inputs(self):

        self.ticker1_select = Select(
            name='ticker1',
            title='Portfolio:',
            value='MSFT',
            options = ['INTC', 'Tech Basket', 'IBB', 'IGOV']
        )
        self.ticker2_select = Select(
            name='ticker2',
            title='Risk/Performance Metric:',
            value='Price',
            options=['Daily Prices', 'Daily Returns', 'Daily Cum Returns', 'Max DD Percentage', 'Percentage Up Days', 'Rolling 95% VaR', 'Rolling Ann. Volatility', 'Rolling Worst Dly. Loss', 'Ann. Sharpe Ratio']
        )
        self.ticker3_select = TextInput(
            name='ticker3',
            title='Window Size:',
            value='63'
        )
        self.ticker4_select = TextInput(
            name='ticker4',
            title='Start Date:',
            value='2010-01-01'
        )
        self.ticker5_select = TextInput(
            name='ticker5',
            title='End Date:',
            value='2015-08-01'
        )
Example #6
0
    def create_layout(self):

        # create figure
        self.x_range = Range1d(start=self.model.map_extent[0],
                               end=self.model.map_extent[2], bounds=None)
        self.y_range = Range1d(start=self.model.map_extent[1],
                               end=self.model.map_extent[3], bounds=None)

        self.fig = Figure(tools='wheel_zoom,pan', x_range=self.x_range,
                          y_range=self.y_range)
        self.fig.plot_height = 660
        self.fig.plot_width = 990
        self.fig.axis.visible = False

        # add tiled basemap
        self.tile_source = WMTSTileSource(url=self.model.basemap)
        self.tile_renderer = TileRenderer(tile_source=self.tile_source)
        self.fig.renderers.append(self.tile_renderer)

        # add datashader layer
        self.image_source = ImageSource(url=self.model.service_url,
                                        extra_url_vars=self.model.shader_url_vars)
        self.image_renderer = DynamicImageRenderer(image_source=self.image_source)
        self.fig.renderers.append(self.image_renderer)

        # add ui components
        axes_select = Select.create(name='Axes',
                                        options=self.model.axes)
        axes_select.on_change('value', self.on_axes_change)

        field_select = Select.create(name='Field', options=self.model.fields)
        field_select.on_change('value', self.on_field_change)

        aggregate_select = Select.create(name='Aggregate',
                                         options=self.model.aggregate_functions)
        aggregate_select.on_change('value', self.on_aggregate_change)

        transfer_select = Select.create(name='Transfer Function',
                                        options=self.model.transfer_functions)
        transfer_select.on_change('value', self.on_transfer_function_change)

        basemap_select = Select.create(name='Basemap', value='Toner',
                                       options=self.model.basemaps)
        basemap_select.on_change('value', self.on_basemap_change)

        opacity_slider = Slider(title="Opacity", value=100, start=0,
                                end=100, step=1)
        opacity_slider.on_change('value', self.on_opacity_slider_change)

        controls = [axes_select, field_select, aggregate_select,
                    transfer_select, basemap_select, opacity_slider]
        self.controls = HBox(width=self.fig.plot_width, children=controls)
        self.layout = VBox(width=self.fig.plot_width,
                           height=self.fig.plot_height,
                           children=[self.controls, self.fig])
Example #7
0
 def make_inputs(self):
     self.ticker1_select = Select(
         name='ticker1',
         value='AAPL',
         options=['AAPL', 'GOOG', 'INTC', 'BRCM', 'YHOO']
     )
     self.ticker2_select = Select(
         name='ticker2',
         value='GOOG',
         options=['AAPL', 'GOOG', 'INTC', 'BRCM', 'YHOO']
     )
Example #8
0
def update_station_list(attrname, old, new):
    year_value= select_years.value
    partition_value= select_partition.value
    #
    key= station_partition_key_format.format(year_value, partition_value)
    stations_list= station_partitions[key]
    #
    new_select_station= Select(title='Station', value=stations_list[0], options=stations_list)
    new_select_station.options=stations_list
    #
    new_children= [select_years, select_partition, new_select_station]
    inputs.children= new_children
    def make_inputs(self):
#
#please add any other stocks you have downloaded using stock_data.py 
#
        self.ticker1_select = Select(
            name='ticker1',
            value='Stock',
            options=['A','AES','AN','BAX','BRCM','CCL','CMS', 'CTSH', 'DISCA', 'ECL', 'EW'])
        self.ticker2_select = Select(
            name='ticker2',
            value='Algorithm',
            options=['Arima','Arma','Anfis']
        )
Example #10
0
    def make_inputs(self):
        with open("states.csv") as f:
            states = [line.strip().split(',') for line in f.readlines()]

        self.selectr = Select(
            name='states',
            value='Choose A State',
            options=[s[1] for s in states] + ['Choose A State'],
        )
        labels = ["County Averages", "Hotels"]
        self.check_group = CheckboxGroup(labels=labels, active=[0,1], inline=True)
        ##Filler plot
        x_range = Range1d(0, 300)
        y_range = Range1d(0, 12)
        self.filler = Plot(
            x_range=x_range, y_range=y_range, title="", 
            plot_width=300, plot_height=12, min_border=0, 
            **PLOT_FORMATS
        )  
        x_range = Range1d(0, 300)
        y_range = Range1d(0, 18)
        self.filler2 = Plot(
            x_range=x_range, y_range=y_range, title="", 
            plot_width=300, plot_height=14, min_border=0, 
            **PLOT_FORMATS
        )  
Example #11
0
 def make_star_input(self):
     starnames = sorted(self._ccf_interface.list_stars())
     self.star_select = Select(
         name='Star identifier',
         value=self.star,
         options=starnames
     )
Example #12
0
    def read_file_tab(self):

        """Lets the user choose a data file to read"""

        # Drop down list
        self.file_select = Select(name='Data files',
                                  value='',
                                  options=[],
                                  title='Data files')
        # Status text
        self.file_status = Div(text='', width=self.page_width)

        # Update the file_select and file_status controls with scan data
        self.scan_folder()

        # This line is here deliberately. The scan_folder would trigger
        # the on-change function and we don't want that first time around.
        self.file_select.on_change('value', self.file_changed)

        # Re-scan button
        file_rescan = Button(label="Rescan folder", button_type="success")
        file_rescan.on_click(self.scan_folder)

        # Layout
        c = column(self.file_select,
                   self.file_status,
                   file_rescan)

        return Panel(child=c, title="Read from file")
Example #13
0
File: fpdapp.py Project: cdmbi/FPD
    def init_input(self):
        # create input widgets only once
        self.min_excitation = Slider(
                title="Min Excitation", name="min_excitation",
                value=min_excitation,
                start=min_excitation,
                end=max_excitation,
                )
        self.max_excitation = Slider(
                title="Max Excitation", name="max_excitation",
                value=max_excitation,
                start=min_excitation,
                end=max_excitation,
                )
        self.min_emission = Slider(
                title="Min Emission", name="min_emission",
                value=min_emission,
                start=min_emission,
                end=max_emission,
                )
        self.max_emission = Slider(
                title="Max Emission", name="max_emission",
                value=max_emission,
                start=min_emission,
                end=max_emission,
                )

        self.chrom_class_select = Select(
                title="Chromophore",
                value='All',
                options=['All'] + CHROMOPHORES,
                )
Example #14
0
    def make_inputs(self):

        self.ticker1_select = TextInput(
            name='ticker1',
            title='Drift Function:',
            value='1.2*(1.1-x)',
        )
        self.ticker1p_select = TextInput(
            name='ticker1p',
            title='Drift Derivative:',
            value='-1.2',
        )
        self.ticker2_select = TextInput(
            name='ticker2',
            title='Volatility Function:',
            value='4.0',
        )
        self.ticker2p_select = TextInput(
            name='ticker2p',
            title='Volatility Derivative:',
            value='0.0',
        )
        self.ticker3_select = TextInput(
            name='ticker3',
            title='Number of Paths:',
            value='500'
        )
        self.ticker3_1_select = TextInput(
            name='ticker3_1',
            title='Number of Points:',
            value='252'
        )
        self.ticker3_2_select = TextInput(
            name='ticker3_2',
            title='Time Step:',
            value='0.01'
        )
        self.ticker4_select = TextInput(
            name='ticker4',
            title='Histogram Line:',
            value='100'
        )
        self.ticker4_1_select = TextInput(
            name='ticker4_1',
            title='Initial Value:',
            value='1.01'
        )
        self.ticker4_2_select = Select(
            name='ticker4_2',
            title='MC Scheme:',
            value='Milstein',
            options=['Euler','Milstein', 'Pred/Corr']
        )
        self.button_select = TextInput(
            name='button',
            title='Type any word containing "run" to run Simulation ',
            value = ''
        )
    def make_inputs(self):
        columns = [
            TableColumn(field='x', title='x'),
            TableColumn(field='y', title='y'),
            TableColumn(field='device', title='device'),
            TableColumn(field='platform', title='platform')
        ]

#        obj.data_display0 = DataTable(source=obj.source2, columns=columns)
#        obj.data_display1 = DataTable(source=obj.source3, columns=columns)

        # setup user input
        self.x_axis_options = Select(title="X:", value='size', options=axis_options)
        self.y_axis_options = Select(title="Y:", value='throughput [1/sec]', options=axis_options)
        self.benchmarks = Select(title="Benchmark:", value=benchmark_names[0],
            options=benchmark_names)
        self.device_names = CheckboxGroup(labels=device_names, active=[0])
        self.platform_names = CheckboxButtonGroup(labels=platform_names, active=[0])
def main():
    state_xs, state_ys = get_us_state_outline()
    left, right = minmax(state_xs)
    bottom, top = minmax(state_ys)
    plot = Figure(title=TITLE, plot_width=1000,
                  plot_height=700,
                  tools="pan, wheel_zoom, box_zoom, reset",
                  x_range=Range1d(left, right),
                  y_range=Range1d(bottom, top),
                  x_axis_label='Longitude',
                  y_axis_label='Latitude')

    plot_state_outline(plot, state_xs, state_ys)

    density_overlay = DensityOverlay(plot, left, right, bottom, top)
    density_overlay.draw()

    grid_slider = Slider(title="Details", value=density_overlay.gridcount,
                         start=10, end=100, step=10)
    grid_slider.on_change("value", density_overlay.grid_change_listener)

    radiance_slider = Slider(title="Min. Radiance",
                             value=density_overlay.radiance,
                             start=np.min(density_overlay.rad),
                             end=np.max(density_overlay.rad), step=10)
    radiance_slider.on_change("value", density_overlay.radiance_change_listener)

    listener = ViewListener(plot, density_overlay, name="viewport")

    plot.x_range.on_change("start", listener)
    plot.x_range.on_change("end", listener)
    plot.y_range.on_change("start", listener)
    plot.y_range.on_change("end", listener)

    backends = ["CPU", "HSA"]
    default_value = backends[kde.USE_HSA]
    backend_select = Select(name="backend", value=default_value,
                            options=backends)
    backend_select.on_change('value', density_overlay.backend_change_listener)

    doc = curdoc()
    doc.add(VBox(children=[plot, grid_slider, radiance_slider, backend_select]))
    doc.add_periodic_callback(density_overlay.periodic_callback, 0.5)
Example #17
0
    def create_layout(self):
        self.plot_selector = Select.create(
            title="PlotType",
            name="plot_type",
            value='area',
            options=['area', "line", "scatter", "bar"],
        )

        self.btn_confirm = Button(label='add plot')
        self.layout = vplot(hplot(self.plot_selector, self.btn_confirm), self.plot)
Example #18
0
class DataViewer():

    def __init__(self):
        img = imageio.imread("gray.png").astype(np.uint8)
        self.target = np.empty(img.shape[:2], dtype=np.uint32)
        view = self.target.view(dtype=np.uint8).reshape((img.shape[0], img.shape[1], 4))
        view[:, :, :3] = img
        view[:, :, 3] = 255
        self.fig = self.define_figure('image')
        self.source = ColumnDataSource(data={"image": [self.target],
                                             "dh": [self.target.shape[0]],
                                             "dw": [self.target.shape[1]]})
        self.regist_image(self.fig, self.source)
        self.select = Select(title="Option:",
                             value="gray.png",
                             options=["gray.png", "white.png", "black.png", "julia.jpeg"])
        self.plot = column(self.select, self.fig)
        self.select.on_change("value", self.update_image)

    def define_figure(self, title):
        return figure(title=title,
                      match_aspect=True,
                      tools="",)

    def regist_image(self, fig, source):
        fig.image_rgba('image',
                       x=0, y=0,
                       dh="dh",
                       dw="dw",
                       source=source)

    def update_image(self, attr, old, new):
        print(attr, old, new)
        img = imageio.imread(new).astype(np.uint8)
        img_ = np.empty(img.shape[:2], dtype=np.uint32)
        view = img_.view(dtype=np.uint8).reshape((img.shape[0], img.shape[1], 4))
        view[:, :, :3] = img
        view[:, :, 3] = 255
        self.fig.title.text = new
        self.source.data = {"image": [img_],
                            "dh": [img_.shape[0]],
                            "dw": [img_.shape[1]]}
Example #19
0
    def make_inputs(self):
        with open("states.csv") as f:
            states = [line.strip().split(',') for line in f.readlines()]

        self.selectr = Select(
            name='states',
            value='Choose A State',
            options=[s[1] for s in states] + ['Choose A State']
        )
        labels = ["County Averages", "Hotels"]
        self.check_group = CheckboxGroup(labels=labels, active=[0,1])
Example #20
0
 def make_inst_date_input(self):
     observations = self._ccf_interface.get_observations(self.star)
     observations = ['/'.join(obs).ljust(20, ' ') for obs in observations]
     self.inst_date = observations[0]
     if isinstance(self.inst_date_select, Select):
         self.inst_date_select.update(value=observations[0], options=observations)
     else:
         self.inst_date_select = Select.create(
             name='Instrument/Date',
             value=observations[0],
             options=observations,
         )
Example #21
0
    def compose_layout(self):
        """Compose the layout ot the app, the main elements are the widgets to
        select the dataset, the metric, a div for the title, a plot and a table
        """

        # Load metrics and datasets
        self.metrics = get_metrics(default='AM1')
        self.datasets = get_datasets(default='cfht')

        # Get args from the app URL or use defaults
        args = get_url_args(doc=curdoc,
                            defaults={'metric': self.metrics['default']})

        self.selected_dataset = args['ci_dataset']

        self.selected_metric = args['metric']

        # get specifications for the selected metric
        self.specs = get_specs(self.selected_metric)

        self.selected_window = args['window']

        # dataset select widget
        dataset_select = Select(title="Data Set:",
                                value=self.selected_dataset,
                                options=self.datasets['datasets'], width=100)

        dataset_select.on_change("value", self.on_dataset_change)

        # thresholds are used to make plot annotations
        self.configure_thresholds()

        # metric select widget
        metric_select = Select(title="Metric:", value=self.selected_metric,
                               options=self.metrics['metrics'], width=100)

        metric_select.on_change("value", self.on_metric_change)

        self.data = \
            get_meas_by_dataset_and_metric(self.selected_dataset,
                                           self.selected_metric,
                                           self.selected_window)

        self.update_data_source()
        self.make_plot()
        self.make_table()

        if len(self.data['values']) < 1:
            self.loading.text = "No data to display"
        else:
            self.loading.text = ""

        self.layout = column(row(widgetbox(metric_select, width=150),
                                 widgetbox(dataset_select, width=150)),
                             widgetbox(self.title, width=1000),
                             self.plot,
                             widgetbox(self.table_title, width=1000),
                             self.table)
Example #22
0
    def make_inputs(self):
        x_range = Range1d(0, 30)
        y_range = Range1d(0, 12)
        self.selectr_filler = Plot(
            x_range=x_range, y_range=y_range, title="", 
            plot_width=30, plot_height=12, min_border=0, 
            **PLOT_FORMATS
        )  


        self.selectr = Select(
            name='brands',
            value='Select A Brand',
            options=pop_brands + ['Select A Brand'],
        )
Example #23
0
 def __init__(self):
     img = imageio.imread("gray.png").astype(np.uint8)
     self.target = np.empty(img.shape[:2], dtype=np.uint32)
     view = self.target.view(dtype=np.uint8).reshape((img.shape[0], img.shape[1], 4))
     view[:, :, :3] = img
     view[:, :, 3] = 255
     self.fig = self.define_figure('image')
     self.source = ColumnDataSource(data={"image": [self.target],
                                          "dh": [self.target.shape[0]],
                                          "dw": [self.target.shape[1]]})
     self.regist_image(self.fig, self.source)
     self.select = Select(title="Option:",
                          value="gray.png",
                          options=["gray.png", "white.png", "black.png", "julia.jpeg"])
     self.plot = column(self.select, self.fig)
     self.select.on_change("value", self.update_image)
Example #24
0
def create_layout():
    year_select = Select(title="Year:", value="2010", options=years)
    location_select = Select(title="Location:", value="World", options=locations)

    year_select.on_change('value', on_year_change)
    location_select.on_change('value', on_location_change)

    controls = HBox(children=[year_select, location_select])
    layout = VBox(children=[controls, pyramid(), population()])

    return layout
Example #25
0
def create_layout():
    year_select = Select(title="Year:", value="2010", options=years)
    location_select = Select(title="Location:", value="World", options=locations)

    year_select.on_change('value', on_year_change)
    location_select.on_change('value', on_location_change)

    controls = WidgetBox(children=[year_select, location_select],height=150,width=600)
    layout = Column(children=[controls, pyramid(), population()])

    return layout
Example #26
0
    def create_layout(self):
        from bokeh.models.widgets import Select, HBox, VBox

        years = list(map(str, sorted(self.df.Year.unique())))
        locations = sorted(self.df.Location.unique())

        year_select = Select(title="Year:", value="2010", options=years)
        location_select = Select(title="Location:", value="World", options=locations)

        year_select.on_change('value', self.on_year_change)
        location_select.on_change('value', self.on_location_change)

        controls = HBox(year_select, location_select)
        self.layout = VBox(controls, self.plot)
Example #27
0
def line_config(app, df):
    options = CheckboxGroup(
        labels=['Show peaks', 'Show Std. Dev.', 'Bolinger Bands'],
        name='new_chart_options'
    )

    title = TextInput(title="Chart Title", name='new_chart_title', value="Line")
    new_chart_index = Select.create(options=['---']+list(df.columns), name='"new_chart_index"', title="Chart index")
    chart_values_select = MultiSelect.create(options=df.columns, name="chart_values", title="Values")
    chart_data = AppHBox(app=app, children=[new_chart_index, chart_values_select, options])
    main_tab = AppVBox(app=app, children=[title, chart_data, 'select_palette'])
    confirm_chart_button = Button(label="Confirm", type="success", name='confirm_add_chart')

    return {
        'dlg': Dialog(buttons=[confirm_chart_button], content=main_tab, visible=True),
        "new_chart_index": new_chart_index,
        'new_chart_title': title,
        'chart_values': chart_values_select,
        'new_chart_options': options
    }
Example #28
0
<p><a href="http://scikit-learn.org/stable/modules/generated/sklearn.gaussian_process.GaussianProcessClassifier.html#sklearn.gaussian_process.GaussianProcessClassifier" target="_blank">More information on the parameters</a></p>
<br/>
""")

#obj = client.get_object(Bucket='my-bucket', Key='churn.csv')
#df = pd.read_csv(obj['Body'])

#df = pd.read_csv('/Users/adilkhan/Documents/CS Fall 16/CS297/Bokeh-Demo/EmbedWebsite/cancer.csv')
df = pd.read_csv('http://s3.amazonaws.com/cs297-mlplayground/' + datasetname)

y = df[df.columns[:1]].values.ravel()
df1 = df.drop(df.columns[:1], axis=1)

features = MultiSelect(title="Features", options=df.columns[1:].tolist())
warm_start = Select(title="Warm_start:",
                    value="False",
                    options=["True", "False"])
copy_X_train = Select(title="Copy_X_train:",
                      value="True",
                      options=["True", "False"])
'''
div = Div(text="""Your <a href="https://en.wikipedia.org/wiki/HTML">HTML</a>-supported text is initialized with the <b>text</b> argument.  The
remaining div arguments are <b>width</b> and <b>height</b>. For this example, those values
are <i>200</i> and <i>100</i> respectively.""",
width=200, height=100)
'''
stats = Paragraph(text='', width=800, height=200, name='Selected Features:')

#columns =['avg_dist', 'avg_rating_by_driver','avg_rating_of_driver','avg_surge','surge_pct','trips_in_first_30_days','luxury_car_user','weekday_pct','city_Astapor',"city_KingsLanding",'city_Winterfell','phone_Android','phone_no_phone']
#columns = ['luxury_car_user','avg_dist','city_Astapor',"city_KingsLanding",'phone_Android','phone_iPhone']
Example #29
0
<h2 style="font-family="Arial">
Select the features to be included in the Multi Layer Perceptron Model
</h2>

<p><a href="http://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPClassifier.html#sklearn.neural_network.MLPClassifier" target="_blank">Click here </a>for more information on the parameters </p>
""",
           width=1100)

df = pd.read_csv(datasetname)

y = df[df.columns[:1]].values.ravel()
df1 = df.drop(df.columns[:1], axis=1)

features = MultiSelect(title="Features", options=df.columns[1:].tolist())
activation = Select(title="Activation:",
                    value="relu",
                    options=["relu", "identity", "logistic", "tanh"])
solver = Select(title="Solver:",
                value="adam",
                options=["adam", "sgd", "lbfgs"])
learning_rate = Select(title="Learning Rate:",
                       value="constant",
                       options=["constant", "invscaling", "adaptive"])
shuffle = Select(title="Shuffle:", value="True", options=["True", "False"])
verbose = Select(title="Verbose:", value="False", options=["True", "False"])
warm_start = Select(title="Warm_start:",
                    value="False",
                    options=["True", "False"])
early_stopping = Select(title="Early Stopping:",
                        value="False",
                        options=["True", "False"])
            source=source,
            color=dict(field='region', transform=color_mapper),
            legend='region')

# Set the legend.location attribute of the plot to 'top_right'
plot.legend.location = 'top_right'

# Make a slider object: slider
slider = Slider(start=1970, end=2010, step=1, value=1970, title='Year')

# Attach the callback to the 'value' property of slider
slider.on_change('value', update_plot)

# Create a dropdown Select widget for the x data: x_select
x_select = Select(options=['fertility', 'life', 'child_mortality', 'gdp'],
                  value='fertility',
                  title='x-axis data')

# Create a dropdown Select widget for the y data: y_select
y_select = Select(options=['fertility', 'life', 'child_mortality', 'gdp'],
                  value='life',
                  title='y-axis data')

# Create a HoverTool: hover
hover = HoverTool(tooltips=[('Country', '@country')])

# Add the HoverTool to the plot
plot.add_tools(hover)

# Make a row layout of widgetbox(slider) and plot and add it to the current document
layout = row(widgetbox(slider, x_select, y_select), plot)
def plot():

    # FIGURES AND X-AXIS
    fig1 = Figure(title = 'Dive Profile',  plot_width = WIDTH, plot_height = HEIGHT, tools = TOOLS)
    fig2 = Figure(title = 'Dive Controls', plot_width = WIDTH, plot_height = HEIGHT, tools = TOOLS, x_range=fig1.x_range)
    fig3 = Figure(title = 'Attitude',      plot_width = WIDTH, plot_height = HEIGHT, tools = TOOLS, x_range=fig1.x_range)
    figs = gridplot([[fig1],[fig2],[fig3]])

    # Formatting x-axis
    timeticks = DatetimeTickFormatter(formats=dict(seconds =["%b%d %H:%M:%S"],
                                                   minutes =["%b%d %H:%M"],
                                                   hourmin =["%b%d %H:%M"],
                                                   hours =["%b%d %H:%M"],
                                                   days  =["%b%d %H:%M"],
                                                   months=["%b%d %H:%M"],
                                                   years =["%b%d %H:%M %Y"]))
    fig1.xaxis.formatter = timeticks
    fig2.xaxis.formatter = timeticks
    fig3.xaxis.formatter = timeticks

    # removing gridlines
    fig1.xgrid.grid_line_color = None
    fig1.ygrid.grid_line_color = None
    fig2.xgrid.grid_line_color = None
    fig2.ygrid.grid_line_color = None
    fig3.xgrid.grid_line_color = None
    fig3.ygrid.grid_line_color = None

    # INPUT WIDGETS
    collection_list = CONN[DB].collection_names(include_system_collections=False)
    gliders = sorted([platformID for platformID in collection_list if len(platformID)>2])
    gliders = Select(title = 'PlatformID', value = gliders[0], options = gliders)
    prev_glider = Button(label = '<')
    next_glider = Button(label = '>')
    glider_controlbox = HBox(children = [gliders, prev_glider, next_glider], height=80)

    chunkations = Select(title = 'Chunkation', value = 'segment', options = ['segment', '24hr', '30days', '-ALL-'])
    chunk_indicator = TextInput(title = 'index', value = '0')
    prev_chunk = Button(label = '<')
    next_chunk = Button(label = '>')
    chunk_ID   = PreText(height=80)
    chunk_controlbox = HBox(chunkations,
                            HBox(chunk_indicator, width=25),
                            prev_chunk, next_chunk,
                            chunk_ID,
                            height = 80)

    control_box = HBox(glider_controlbox,
                        chunk_controlbox)

    # DATA VARS
    deadby_date = ''
    depth    = ColumnDataSource(dict(x=[],y=[]))
    vert_vel = ColumnDataSource(dict(x=[],y=[]))

    mbpump   = ColumnDataSource(dict(x=[],y=[]))
    battpos  = ColumnDataSource(dict(x=[],y=[]))
    pitch    = ColumnDataSource(dict(x=[],y=[]))

    mfin      = ColumnDataSource(dict(x=[],y=[]))
    cfin      = ColumnDataSource(dict(x=[],y=[]))
    mroll     = ColumnDataSource(dict(x=[],y=[]))
    mheading = ColumnDataSource(dict(x=[],y=[]))
    cheading = ColumnDataSource(dict(x=[],y=[]))

    # AXIS setup
    colors = COLORS[:]

    fig1.y_range.flipped = True
    fig1.yaxis.axis_label = 'm_depth (m)'
    fig1.extra_y_ranges = {'vert_vel': Range1d(start=-50, end=50),
                           'dummy':    Range1d(start=0, end=100)}
    fig1.add_layout(place = 'right',
                    obj = LinearAxis(y_range_name = 'vert_vel',
                                     axis_label   = 'vertical velocity (cm/s)'))
    fig1.add_layout(place = 'left',
                    obj = LinearAxis(y_range_name = 'dummy',
                                     axis_label   = ' '))
    fig1.yaxis[1].visible = False
    fig1.yaxis[1].axis_line_alpha = 0
    fig1.yaxis[1].major_label_text_alpha = 0
    fig1.yaxis[1].major_tick_line_alpha = 0
    fig1.yaxis[1].minor_tick_line_alpha = 0


    fig2.yaxis.axis_label = 'pitch (deg)'
    fig2.y_range.start, fig2.y_range.end = -40,40
    fig2.extra_y_ranges = {'battpos': Range1d(start=-1, end = 1),
                           'bpump':   Range1d(start=-275, end=275)}
    fig2.add_layout(place = 'right',
                    obj = LinearAxis(y_range_name = 'battpos',
                                     axis_label = 'battpos (in)'))
    fig2.add_layout(place = 'left',
                    obj = LinearAxis(y_range_name = 'bpump',
                                     axis_label   = 'bpump (cc)'))
    fig2.yaxis[1].visible = False # necessary for spacing. later gets set to true


    fig3.yaxis.axis_label = 'fin/roll (deg)'
    fig3.y_range.start, fig3.y_range.end = -30, 30
    fig3.extra_y_ranges = {'heading': Range1d(start=0, end=360), #TODO dynamic avg centering
                           'dummy':   Range1d(start=0, end=100)}
    fig3.add_layout(place = 'right',
                    obj = LinearAxis(y_range_name = 'heading',
                                     axis_label   = 'headings (deg)'))
    fig3.add_layout(place = 'left',
                    obj = LinearAxis(y_range_name = 'dummy',
                                     axis_label   = ' '))
    fig3.yaxis[1].visible = False
    fig3.yaxis[1].axis_line_alpha = 0
    fig3.yaxis[1].major_label_text_alpha = 0
    fig3.yaxis[1].major_tick_line_alpha = 0
    fig3.yaxis[1].minor_tick_line_alpha = 0

    # PLOT OBJECTS
    fig1.line(  'x', 'y', source = depth,    legend = 'm_depth',     color = 'red')
    fig1.circle('x', 'y', source = depth,    legend = 'm_depth',     color = 'red')
    fig1.line(  'x', 'y', source = vert_vel, legend = 'vert_vel',    color = 'green',     y_range_name = 'vert_vel')
    fig1.circle('x', 'y', source = vert_vel, legend = 'vert_vel',    color = 'green',     y_range_name = 'vert_vel')
    fig1.renderers.append(Span(location = 0, dimension = 'width',    y_range_name = 'vert_vel',
                               line_color= 'green', line_dash='dashed', line_width=1))

    fig2.line(  'x', 'y', source = pitch,   legend = "m_pitch",    color = 'indigo')
    fig2.circle('x', 'y', source = pitch,   legend = "m_pitch",    color = 'indigo')
    fig2.line(  'x', 'y', source = battpos, legend = 'm_battpos',  color = 'magenta',   y_range_name = 'battpos')
    fig2.circle('x', 'y', source = battpos, legend = 'm_battpos',  color = 'magenta',   y_range_name = 'battpos')
    fig2.line(  'x', 'y', source = mbpump,  legend = "m_'bpump'",  color = 'blue',      y_range_name = 'bpump')
    fig2.circle('x', 'y', source = mbpump,  legend = "m_'bpump'",  color = 'blue',      y_range_name = 'bpump')
    fig2.renderers.append(Span(location = 0, dimension = 'width',
                               line_color= 'black', line_dash='dashed', line_width=1))
    fig3.line(  'x', 'y', source = mfin,       legend = 'm_fin',     color = 'cyan')
    fig3.circle('x', 'y', source = mfin,       legend = 'm_fin',     color = 'cyan')
    fig3.line(  'x', 'y', source = cfin,       legend = 'c_fin',     color = 'orange')
    fig3.circle('x', 'y', source = cfin,       legend = 'c_fin',     color = 'orange')
    fig3.line(  'x', 'y', source = mroll,      legend = 'm_roll',    color = 'magenta')
    fig3.circle('x', 'y', source = mroll,      legend = 'm_roll',    color = 'magenta')
    fig3.line(  'x', 'y', source = mheading,   legend = 'm_heading', color = 'blue',    y_range_name = 'heading')
    fig3.circle('x', 'y', source = mheading,   legend = 'm_heading', color = 'blue',    y_range_name = 'heading')
    fig3.line(  'x', 'y', source = cheading,   legend = 'c_heading', color = 'indigo',  y_range_name = 'heading')
    fig3.circle('x', 'y', source = cheading,   legend = 'c_heading', color = 'indigo',  y_range_name = 'heading')
    fig3.renderers.append(Span(location = 0, dimension = 'width',    y_range_name = 'default',
                               line_color= 'black', line_dash='dashed', line_width=1))

    # CALLBACK FUNCS
    def update_data(attrib,old,new):
        g = gliders.value
        chnk = chunkations.value
        chindex = abs(int(chunk_indicator.value))

        depth.data    = dict(x=[],y=[])
        vert_vel.data = dict(x=[],y=[])
        mbpump.data   = dict(x=[],y=[])
        battpos.data  = dict(x=[],y=[])
        pitch.data    = dict(x=[],y=[])

        mfin.data     = dict(x=[],y=[])
        cfin.data     = dict(x=[],y=[])
        mroll.data    = dict(x=[],y=[])
        mheading.data = dict(x=[],y=[])
        cheading.data = dict(x=[],y=[])


        depth.data,startend   = load_sensor(g, 'm_depth', chnk, chindex)

        if chnk == 'segment':
            xbd = startend[2]
            chunk_ID.text = '{} {} \n{} ({}) \nSTART: {} \nEND:   {}'.format(g, xbd['mission'],
                                                                             xbd['onboard_filename'], xbd['the8x3_filename'],
                                                                             e2ts(xbd['start']), e2ts(xbd['end']))
            if len(set(depth.data['x']))<=1 and attrib == 'chunk':
                if old > new:
                    next_chunk.clicks += 1
                else:
                    prev_chunk.clicks += 1
                return
            elif len(set(depth.data['x']))<=1 and chunk_indicator.value == 0:
                chunk_indicator.value = 1

        elif chnk in ['24hr', '30days']:
            chunk_ID.text = '{} \nSTART: {} \nEND:   {}'.format(g, e2ts(startend[0]), e2ts(startend[1]))
        elif chnk == '-ALL-':
            chunk_ID.text = '{} \nSTART: {} \nEND:   {}'.format(g,e2ts(depth.data['x'][0] /1000),
                                                                  e2ts(depth.data['x'][-1]/1000))


        vert_vel.data  = calc_vert_vel(depth.data)

        mbpump.data,_     = load_sensor(g, 'm_de_oil_vol', chnk, chindex)
        if len(mbpump.data['x']) > 1:
            #for yax in fig2.select('mbpump'):
            #    yax.legend = 'm_de_oil_vol'
            pass
        else:
            mbpump.data,_     = load_sensor(g, 'm_ballast_pumped', chnk, chindex)
            #for yax in fig2.select('mbpump'):
            #    yax.legend = 'm_ballast_pumped'
        battpos.data,_ = load_sensor(g, 'm_battpos',    chnk, chindex)
        pitch.data,_   = load_sensor(g, 'm_pitch',      chnk, chindex)
        pitch.data['y'] = [math.degrees(y) for y in pitch.data['y']]

        mfin.data,_     = load_sensor(g, 'm_fin',     chnk, chindex)
        cfin.data,_     = load_sensor(g, 'c_fin',     chnk, chindex)
        mroll.data,_    = load_sensor(g, 'm_roll',    chnk, chindex)
        mheading.data,_ = load_sensor(g, 'm_heading', chnk, chindex)
        cheading.data,_ = load_sensor(g, 'c_heading', chnk, chindex)
        mfin.data['y']     = [math.degrees(y) for y in mfin.data['y']]
        cfin.data['y']     = [math.degrees(y) for y in cfin.data['y']]
        mheading.data['y'] = [math.degrees(y) for y in mheading.data['y']]
        cheading.data['y'] = [math.degrees(y) for y in cheading.data['y']]
        mroll.data['y']    = [math.degrees(y) for y in mroll.data['y']]

        fig1.yaxis[1].visible = True
        fig2.yaxis[1].visible = True
        fig3.yaxis[1].visible = True


    #GLIDER SELECTS
    def glider_buttons(increment):
        ops = gliders.options
        new_index = ops.index(gliders.value) + increment
        if new_index >= len(ops):
            new_index = 0
        elif new_index < 0:
            new_index = len(ops)-1
        gliders.value = ops[new_index]
        chunkation_update(None, None, None) #reset chunk indicator and clicks
    def next_glider_func():
        glider_buttons(1)
    def prev_glider_func():
        glider_buttons(-1)
    def update_glider(attrib,old,new):
        chunk_indicator.value = '0'
        #update_data(None,None,None)


    gliders.on_change('value', update_glider)
    next_glider.on_click(next_glider_func)
    prev_glider.on_click(prev_glider_func)


        #CHUNK SELECTS
    def chunkation_update(attrib,old,new):
        chunk_indicator.value = '0'
        prev_chunk.clicks = 0
        next_chunk.clicks = 0
        update_data(None,None,None)
        if new == '-ALL-':
            chunk_indicator.value = '-'

    def chunk_func():
        chunkdiff = prev_chunk.clicks - next_chunk.clicks
        if chunkdiff < 0:
            prev_chunk.clicks = 0
            next_chunk.clicks = 0
            chunkdiff = 0
        print (chunkdiff)
        chunk_indicator.value = str(chunkdiff)

    def chunk_indicator_update(attrib,old,new):
        try:
            if abs(int(old)-int(new))>1: #manual update, triggers new non-manual indicator update, ie else clause below
                prev_chunk.clicks = int(new)
                next_chunk.clicks = 0
            else:
                update_data('chunk',int(old),int(new))
            print("UPDATE", old, new)
        except Exception as e:
            print(type(e),e, old, new)

    chunkations.on_change('value', chunkation_update)
    chunk_indicator.on_change('value', chunk_indicator_update)
    next_chunk.on_click(chunk_func)
    prev_chunk.on_click(chunk_func)

    update_data(None,None,None)

    return vplot(control_box, figs)
Example #32
0
tab1_nfreq_square, = tab1_freq_square.shape
tab1_ntim_square, = tab1_tim_square.shape
tim_map = ((np.tile(tab1_tim_square, tab1_nfreq_square).reshape(tab1_nfreq_square,
    tab1_ntim_square) / 3600. / 24. + 2400000.5)) * 86400.
freq_map = np.tile(tab1_freq_square, tab1_ntim_square).reshape(tab1_ntim_square, tab1_nfreq_square).swapaxes(0, 1)
xx = tim_map.flatten()
yy = freq_map.flatten()
tab1_dspecDF_square = pd.DataFrame({'time': xx - xx[0], 'freq': yy})
tab1_SRC_dspec_square = ColumnDataSource(tab1_dspecDF_square)
'''make the plot lasso selectable'''
tab1_render_square = tab1_p_dspec.square('time', 'freq', source=tab1_SRC_dspec_square, fill_color=None, fill_alpha=0.0,
    line_color=None, line_alpha=0.0, selection_fill_color='red', selection_fill_alpha=0.2, nonselection_fill_alpha=0.0,
    selection_line_alpha=0.0, nonselection_line_alpha=0.0)

## ----------------baseline & polarization selection------------------------
tab1_Select_bl = Select(title="Baseline:", value=tab1_bl[0], options=tab1_bl, width=150)
tab1_Select_pol = Select(title="Polarization:", value="I", options=["RR", "LL", "I", "V"], width=150)
tab1_Select_colormap = Select(title="Colormap:", value="linear", options=["linear", "log"], width=150)


def tab1_update_dspec(attrname, old, new):
    global tab1_spec, tab1_dtim, tab1_freq, tab1_bl
    select_pol = tab1_Select_pol.value
    select_bl = tab1_Select_bl.value
    bl_index = tab1_bl.index(select_bl)
    if select_pol == 'RR':
        spec_plt = tab1_spec[0, bl_index, :, :]
    elif select_pol == 'LL':
        spec_plt = tab1_spec[1, bl_index, :, :]
    elif select_pol == 'I':
        spec_plt = (tab1_spec[0, bl_index, :, :] + tab1_spec[1, bl_index, :, :]) / 2.
    if ct == 'United States':
        bg = ['United States of America']
        new_savvy_dict[bg[0]] = new_savvy_dict.pop(ct)

    if ct == bg[0]:  # this is dumb I don't actually add any
        new_savvy_dict[bg[0]] = new_savvy_dict.pop(
            ct)  # replace the medium data key with the new country key
    else:
        if ct != 'United States':
            new_savvy_dict.pop(ct)

# ---------------- made it to here on new savvy dict

from bokeh.models.widgets import Select
select = Select(title="Metric:",
                value="Fear Level",
                options=["Fear Level", "Tech Savviness"],
                width=300)

ndf = pd.concat([df['entity'], df['code']], axis=1)
ndf.drop_duplicates()

# add a country code to medium data dict
codes_list = []
year_list = []
dat_list = []
pop_list = []
entitiesL = list(new_data_dict.keys())
for v in range(len(new_data_dict.values())):
    if entitiesL[v] == 'United States of America':
        tmp = 'United States'
    else:
Example #34
0
    elif t1 == '16:20':  # bathroom window open
        t1 = '140.0'
    t1 = float(t1)

    data['tmp'] = df[df['time'] == t1]['temperature'].values
    data['hum'] = df[df['time'] == t1]['humidity'].values

    data.sort_values(['vol'], inplace=True)

    return data


# set up widgets

stats = PreText(text='', width=500)
ticker1 = Select(value='15:15', options=nix('13:00', DEFAULT_TICKERS))
ticker2 = Select(value='15:15', options=nix('13:00', DEFAULT_TICKERS))

# set up plots

source = ColumnDataSource(data=dict(vol=[], tmp=[], hum=[]))
source_static = ColumnDataSource(data=dict(vol=[], tmp=[], hum=[]))
tools = 'pan,wheel_zoom,xbox_select,reset'
corr = figure(plot_width=600,
              plot_height=600,
              tools='pan,wheel_zoom,box_select,reset')
corr.scatter(x='tmp', y='hum', size=8, source=source)
labels = LabelSet(x='tmp',
                  y='hum',
                  text='room',
                  level='glyph',
Example #35
0
    def _getPlotPanel(self):
        """@brief Add tab that shows plot data updates."""

        self._figTable.append([])
        self._voltsSource = ColumnDataSource({'x': [], 'y': []})
        self._ampsSource = ColumnDataSource({'x': [], 'y': []})
        self._wattsSource = ColumnDataSource({'x': [], 'y': []})
        fig = figure(toolbar_location='above',
                     x_axis_type="datetime",
                     x_axis_location="below")
        fig.line(source=self._voltsSource,
                 line_color="blue",
                 legend_label="Volts")
        fig.line(source=self._ampsSource,
                 line_color="green",
                 legend_label="Amps")
        fig.line(source=self._wattsSource,
                 line_color="red",
                 legend_label="Watts")
        fig.legend.location = 'top_left'
        self._figTable[-1].append(fig)
        self._grid = gridplot(children=self._figTable,
                              sizing_mode='scale_both',
                              toolbar_location='right')

        self.selectSerialPort = Select(title="Serial Port:")
        self.selectSerialPort.options = glob.glob('/dev/ttyU*')

        self.outputVoltageSpinner = Spinner(title="Output Voltage (Volts)",
                                            low=0,
                                            high=40,
                                            step=0.5,
                                            value=self._pconfig.getAttr(
                                                PSUGUI.VOLTS))
        self.currentLimitSpinner = Spinner(title="Currnet Limit (Amps)",
                                           low=0,
                                           high=10,
                                           step=0.25,
                                           value=self._pconfig.getAttr(
                                               PSUGUI.AMPS))
        self.plotHistorySpinner = Spinner(title="Plot History (Seconds)",
                                          low=1,
                                          high=10000,
                                          step=1,
                                          value=self._pconfig.getAttr(
                                              PSUGUI.PLOT_SECONDS))

        self._setButton = Button(label="Set")
        self._setButton.on_click(self._setHandler)
        self._setButton.disabled = True

        self._onButton = Button(label="On")
        self._onButton.on_click(self._psuOnHandler)

        shutdownButtonWrapper = ShutdownButtonWrapper(self._quit)
        controlPanel = column([
            self.selectSerialPort, self._onButton, self.outputVoltageSpinner,
            self.currentLimitSpinner, self._setButton, self.plotHistorySpinner,
            shutdownButtonWrapper.getWidget()
        ])

        self._opTableWrapper = ReadOnlyTableWrapper(("volts", "amps", "watts"),
                                                    heightPolicy="fixed",
                                                    height=65,
                                                    showLastRows=0)

        plotPanel = column([self._grid, self._opTableWrapper.getWidget()])
        panel2 = row([controlPanel, plotPanel])
        plotPanel = column([panel2, self.statusBarWrapper.getWidget()])
        return plotPanel
	location = select_location.value
	new_df = loc_group.get_group(location)
	new_hist_df = loc_group.get_group(location).groupby(['FullName']).count()
	new_hist_df.sort_values('location',ascending=0,inplace=True)
	stop_ind = min(new_hist_df.shape[0],7)
	new_hist_df = new_hist_df[0:stop_ind]
	new_hist_df['y'] = np.arange(0,stop_ind)[::-1]
	new_hist_df['full_name']=new_hist_df.index.tolist()
	new_source = ColumnDataSource(new_df)
	new_hist_source = ColumnDataSource(new_hist_df)
	circle_source.data = new_source.data
	hist_source.data = new_hist_source.data
	# p2.y_range = FactorRange(factors=list(new_hist_df['full_name']))

# Creating dropdown tool
select_location = Select(title='Select Location :', value=location_list[0], options=location_list)
select_location.on_change('value',update_by_location)

# Creating Hover Tool for p
p.add_tools(HoverTool(tooltips = [
	('First Name', '@FirstName')
	,('Last Name', '@LastName')
	,('Expense', '@price')
]
	,renderers =[p.select('circ')[0]]
))

# Creating Hover Tool for p2
p2.add_tools(HoverTool(tooltips = [
	('Full Name', '@full_name')
]
    def __init__(self, model, resolution=50, doc=None):
        """
        Initialize parameters.

        Parameters
        ----------
        model : MetaModelComponent
            Reference to meta model component
        resolution : int
            Value used to calculate the size of contour plot meshgrid
        doc : Document
            The bokeh document to build.
        """
        self.prob = Problem()
        self.resolution = resolution
        logging.getLogger("bokeh").setLevel(logging.ERROR)

        # If the surrogate model coming in is structured
        if isinstance(model, MetaModelUnStructuredComp):
            self.is_structured_meta_model = False

            # Create list of input names, check if it has more than one input, then create list
            # of outputs
            self.input_names = [name[0] for name in model._surrogate_input_names]
            if len(self.input_names) < 2:
                raise ValueError('Must have more than one input value')
            self.output_names = [name[0] for name in model._surrogate_output_names]

            # Create reference for untructured component
            self.meta_model = MetaModelUnStructuredComp(
                default_surrogate=model.options['default_surrogate'])

        # If the surrogate model coming in is unstructured
        elif isinstance(model, MetaModelStructuredComp):
            self.is_structured_meta_model = True

            self.input_names = [name for name in model._var_rel_names['input']]

            if len(self.input_names) < 2:
                raise ValueError('Must have more than one input value')

            self.output_names = [name for name in model._var_rel_names['output']]

            self.meta_model = MetaModelStructuredComp(
                distributed=model.options['distributed'],
                extrapolate=model.options['extrapolate'],
                method=model.options['method'],
                training_data_gradients=model.options['training_data_gradients'],
                vec_size=1)

        # Pair input list names with their respective data
        self.training_inputs = {}

        self._setup_empty_prob_comp(model)

        # Setup dropdown menus for x/y inputs and the output value
        self.x_input_select = Select(title="X Input:", value=[x for x in self.input_names][0],
                                     options=[x for x in self.input_names])
        self.x_input_select.on_change('value', self._x_input_update)

        self.y_input_select = Select(title="Y Input:", value=[x for x in self.input_names][1],
                                     options=[x for x in self.input_names])
        self.y_input_select.on_change('value', self._y_input_update)

        self.output_select = Select(title="Output:", value=[x for x in self.output_names][0],
                                    options=[x for x in self.output_names])
        self.output_select.on_change('value', self._output_value_update)

        # Create sliders for each input
        self.slider_dict = {}
        self.predict_inputs = {}
        for title, values in self.training_inputs.items():
            slider_data = np.linspace(min(values), max(values), self.resolution)
            self.predict_inputs[title] = slider_data
            # Calculates the distance between slider ticks
            slider_step = slider_data[1] - slider_data[0]
            slider_object = Slider(start=min(values), end=max(values), value=min(values),
                                   step=slider_step, title=str(title))
            self.slider_dict[title] = slider_object

        self._slider_attrs()

        # Length of inputs and outputs
        self.num_inputs = len(self.input_names)
        self.num_outputs = len(self.output_names)

        # Precalculate the problem bounds.
        limits = np.array([[min(value), max(value)] for value in self.training_inputs.values()])
        self.limit_range = limits[:, 1] - limits[:, 0]

        # Positional indicies
        self.x_index = 0
        self.y_index = 1
        self.output_variable = self.output_names.index(self.output_select.value)

        # Data sources are filled with initial values
        # Slider Column Data Source
        self.slider_source = ColumnDataSource(data=self.predict_inputs)

        # Contour plot Column Data Source
        self.contour_plot_source = ColumnDataSource(data=dict(
            z=np.random.rand(self.resolution, self.resolution)))
        self.contour_training_data_source = ColumnDataSource(
            data=dict(x=np.repeat(0, self.resolution), y=np.repeat(0, self.resolution)))

        # Bottom plot Column Data Source
        self.bottom_plot_source = ColumnDataSource(data=dict(
            x=np.repeat(0, self.resolution), y=np.repeat(0, self.resolution)))
        self.bottom_plot_scatter_source = ColumnDataSource(data=dict(
            bot_slice_x=np.repeat(0, self.resolution), bot_slice_y=np.repeat(0, self.resolution)))

        # Right plot Column Data Source
        self.right_plot_source = ColumnDataSource(data=dict(
            x=np.repeat(0, self.resolution), y=np.repeat(0, self.resolution)))
        self.right_plot_scatter_source = ColumnDataSource(data=dict(
            right_slice_x=np.repeat(0, self.resolution),
            right_slice_y=np.repeat(0, self.resolution)))

        # Text input to change the distance of reach when searching for nearest data points
        self.scatter_distance = TextInput(value="0.1", title="Scatter Distance")
        self.scatter_distance.on_change('value', self._scatter_input)
        self.dist_range = float(self.scatter_distance.value)

        # Grouping all of the sliders and dropdowns into one column
        sliders = [value for value in self.slider_dict.values()]
        sliders.extend(
            [self.x_input_select, self.y_input_select, self.output_select, self.scatter_distance])
        self.sliders_and_selects = row(
            column(*sliders))

        # Layout creation
        self.doc_layout = row(self._contour_data(), self._right_plot(), self.sliders_and_selects)
        self.doc_layout2 = row(self._bottom_plot())

        if doc is None:
            doc = curdoc()

        doc.add_root(self.doc_layout)
        doc.add_root(self.doc_layout2)
        doc.title = 'Meta Model Visualization'
    "surya": "AIzaSyAU2gGkynk36LibmjTwLKOKMHVTRKIM87k",
    "graham": "AIzaSyBRcJ-Oj88gvz0LWNaCKg42K0K9SQIFpfs"
}
gmaps = googlemaps.Client(key=google_api_keys["surya"])
with open('static/zip_coords.json') as data_file:
    zip_coords_json = json.load(data_file)

large_palette = sns_to_bokeh_palette("GnBu", 20)
medium_palette = sns_to_bokeh_palette("GnBu", 6)
small_palette = sns_to_bokeh_palette("GnBu", 2)

address = TextInput(title="Address:", value="Times Square")
month = Select(title="Month:",
               value="January",
               options=[
                   "January", "February", "March", "April", "May", "June",
                   "July", "August", "September", "October", "November",
                   "December"
               ])
update = Button(label="Update", button_type="success")

rides_df, full_address = search_address(address.value, 50)
freq_dict = calc_zipcode_frequencies(zip_coords_json, rides_df)
d_choropleth, d_patches = make_choropleth_plot(zip_coords_json, freq_dict,
                                               "dropoff_frequency",
                                               large_palette)
p_choropleth, p_patches = make_choropleth_plot(zip_coords_json, freq_dict,
                                               "pickup_frequency",
                                               large_palette)
type_stacked_bar = make_stacked_bar_chart("day", 'type', rides_df,
                                          small_palette)
Example #39
0
def spectral_tab(ts):
    # Make line plot for raw and detrended data.
    def make_lineplot_q1(source):
        ts_list = source.column_names
        ts_list.remove('index')
        ts_list.remove('time')

        ttp = [("Time", "$x"), ("Value", "$y")]

        plot_q1 = figure(plot_height=400,
                         plot_width=400,
                         tooltips=ttp,
                         title="Time Series",
                         tools="hover, pan, zoom_in, zoom_out, reset, save")
        for i, name in enumerate(ts_list):
            plot_q1.line('time',
                         name,
                         source=source,
                         line_width=3,
                         line_color=ts_colors[i],
                         legend_label=name)

        plot_q1.legend.location = "top_left"
        plot_q1.legend.click_policy = "hide"

        return plot_q1

    # Make line and circle plot for power spectrum.
    def make_lineplot_q2(source):

        ttp = [("Frequency", "$x"), ("Power", "$y")]

        plot_q2 = figure(plot_height=400,
                         plot_width=400,
                         tooltips=ttp,
                         title="Power Spectrum",
                         tools="hover, pan, zoom_in, zoom_out, reset, save")
        plot_q2.line('frequency',
                     'power',
                     source=source,
                     line_width=3,
                     line_color=ts_colors[10])
        plot_q2.circle('frequency',
                       'power',
                       source=source,
                       fill_color="white",
                       size=8)

        return plot_q2

    # Make time series plot for fourier components.
    def make_lineplot_q3(source):
        ts_list = source.column_names
        ts_list.remove('index')
        ts_list.remove('times')

        ttp = [("Time", "$x"), ("Value", "$y")]

        plot_q3 = figure(plot_height=400,
                         plot_width=400,
                         tooltips=ttp,
                         title="Top 5 Fourier Components",
                         tools="hover, pan, zoom_in, zoom_out, reset, save")
        for i, name in enumerate(ts_list):
            plot_q3.line('times',
                         name,
                         source=source,
                         line_width=3,
                         line_color=ts_colors[i],
                         legend_label=name)

        plot_q3.legend.location = "top_left"
        plot_q3.legend.click_policy = "hide"

        return plot_q3

    # Make time series plot for fourier components.
    def make_lineplot_q4(source):
        ts_list = source.column_names
        ts_list.remove('index')
        ts_list.remove('time')

        ttp = [("Time", "$x"), ("Value", "$y")]

        plot_q4 = figure(plot_height=400,
                         plot_width=400,
                         tooltips=ttp,
                         title="Fourier Residuals",
                         tools="hover, pan, zoom_in, zoom_out, reset, save")
        for i, name in enumerate(ts_list):
            plot_q4.line('time',
                         name,
                         source=source,
                         line_width=3,
                         line_color=ts_colors[i],
                         legend_label=name)

        plot_q4.legend.location = "top_left"
        plot_q4.legend.click_policy = "hide"

        return plot_q4

    # Make Summary Table of top 5 fourier components.
    def make_summarytable(source):
        columns = [
            TableColumn(field="frequency", title="Frequency"),
            TableColumn(field="amplitude", title="Amplitude"),
            TableColumn(field="power", title="Power")
        ]
        summary_table = DataTable(source=source,
                                  columns=columns,
                                  width=400,
                                  height=200)
        return summary_table

    # Make dataset function.
    def make_dataset(ts, col, N):
        ts_data = ts[['time', col]]
        ts_data.columns = ['time', 'raw_data']
        if N == 0:
            ts_data['detrended'] = ts_data['raw_data']
            return ts_data
        else:
            ts_data.columns = ['time', 'raw_data']
            ts_detrended = remove_trend(ts_data, N)
            ts_data['detrended'] = ts_detrended.iloc[:, 1]
            return ts_data

    ##############################################################
    # Set up callbacks

    def update_data(attrname, old, new):
        # Update data with selected timeseries and detrend with order N polynomial.
        new_data = make_dataset(ts, ts_select.value, order_select.value)

        update_dataset(new_data=new_data)
        update_powerspectrum(new_data=new_data)
        update_fourier1(new_data=new_data)
        update_fourier2(new_data=new_data)
        update_summarytable(new_data=new_data)

    def update_dataset(new_data):
        # Store updated data in CDS format.
        new_source_q1 = ColumnDataSource(data=new_data)
        # Update CDS to plot_q1.
        source_q1.data.update(new_source_q1.data)

    def update_powerspectrum(new_data):
        # Compute power spectrum.
        # If timeseries has not been detrended (i.e. size == 2), use raw data in power spectrum.
        if len(new_data.columns) == 2:
            pspec_data = fourier_to_freq_spectrum(new_data.iloc[:, 1],
                                                  new_data['time'])
        else:
            pspec_data = fourier_to_freq_spectrum(new_data.iloc[:, 2],
                                                  new_data['time'])
        # Store update data in CDS format.
        new_source_q2 = ColumnDataSource(data=pspec_data)
        # Update CDS to plot_q2
        source_q2.data.update(new_source_q2.data)
        print(source_q2.data)

    def update_fourier1(new_data):
        # Compute fourier components.
        if len(new_data.columns) == 2:
            alpha0, coef = dfs(new_data.iloc[:, 1])
            top_components_for_approx, _, _ = calc_residuals(alpha0,
                                                             coef,
                                                             new_data.iloc[:,
                                                                           1],
                                                             new_data['time'],
                                                             components=5)
        else:
            alpha0, coef = dfs(new_data.iloc[:, 2])
            top_components_for_approx, _, _ = calc_residuals(alpha0,
                                                             coef,
                                                             new_data.iloc[:,
                                                                           2],
                                                             new_data['time'],
                                                             components=5)

        new_source_q3 = ColumnDataSource(data=top_components_for_approx)
        source_q3.data.update(new_source_q3.data)
        print(source_q3.data)

    def update_fourier2(new_data):
        if len(new_data.columns) == 2:
            alpha0, coef = dfs(new_data.iloc[:, 1])
            _, _, residual_df = calc_residuals(
                alpha0,
                coef,
                new_data.iloc[:, 1],
                new_data['time'],
                components=component_select.value)
        else:
            alpha0, coef = dfs(new_data.iloc[:, 2])
            _, _, residual_df = calc_residuals(
                alpha0,
                coef,
                new_data.iloc[:, 2],
                new_data['time'],
                components=component_select.value)

        new_source_q4 = ColumnDataSource(data=residual_df)
        source_q4.data.update(new_source_q4.data)
        print(source_q4.data)

    def update_summarytable(new_data):
        if len(new_data.columns) == 2:
            alpha0, coef = dfs(new_data.iloc[:, 1])
            _, summary_table, _ = calc_residuals(alpha0,
                                                 coef,
                                                 new_data.iloc[:, 1],
                                                 new_data['time'],
                                                 components=5)
        else:
            alpha0, coef = dfs(new_data.iloc[:, 2])
            _, summary_table, _ = calc_residuals(alpha0,
                                                 coef,
                                                 new_data.iloc[:, 2],
                                                 new_data['time'],
                                                 components=5)

        new_source_summarytable = ColumnDataSource(data=summary_table)
        source_summarytable.data.update(new_source_summarytable.data)
        print(source_summarytable.data)

    # Set up widgets.
    # Select time series for Spectral Analysis.
    ts_available = ts.columns.tolist()
    ts_available.remove('time')
    ts_select = Select(value=ts_available[0],
                       title='Time Series',
                       options=ts_available)
    ts_select.on_change('value', update_data)
    # Select order of polynomial for removing trend.
    order_select = Slider(start=0,
                          end=10,
                          step=1,
                          value=0,
                          title='Detrending Polynomial Order')
    order_select.on_change('value', update_data)
    # Select no. components for spectral analysis.
    component_select = Slider(start=0,
                              end=20,
                              step=1,
                              value=5,
                              title='No. Fourier Components')
    component_select.on_change('value', update_data)

    ##############################################################
    # Initial state and plotting.

    # Ensuring ts dataframe has odd no. elements.
    if (len(ts) % 2) == 0:
        # Remove last row when even no. elements.
        ts.drop(ts.tail(1).index, inplace=True)
    else:
        pass

    # Make initial dataset with first time series column by default.
    initial_data = make_dataset(ts, ts_available[0], 0)
    source_q1 = ColumnDataSource(data=initial_data)
    # Compute initial power spectrum for default time series.
    initial_pspec = fourier_to_freq_spectrum(initial_data.iloc[:, 1],
                                             initial_data['time'])
    source_q2 = ColumnDataSource(data=initial_pspec)
    # Compute initial fourier components for default time series.
    alpha0, coef = dfs(initial_data.iloc[:, 1])
    top_components_for_approx, summary_table, residual_df = calc_residuals(
        alpha0,
        coef,
        initial_data.iloc[:, 1],
        initial_data['time'],
        components=5)

    source_q3 = ColumnDataSource(data=top_components_for_approx)
    source_q4 = ColumnDataSource(data=residual_df)

    source_summarytable = ColumnDataSource(data=summary_table)

    plot_q1 = make_lineplot_q1(source_q1)
    plot_q2 = make_lineplot_q2(source_q2)
    plot_q3 = make_lineplot_q3(source_q3)
    plot_q4 = make_lineplot_q4(source_q4)
    summary_table = make_summarytable(source_summarytable)

    # Set up layouts and add to document.
    # Put controls in a single element.
    controls = WidgetBox(ts_select, order_select, component_select)

    # Create a row layout
    layout = row(
        controls,
        gridplot([[plot_q1, plot_q2], [plot_q3, plot_q4],
                  [summary_table, None]]))

    # Make a tab with the layout.
    tab = Panel(child=layout, title='Spectral Analysis')
    return tab
Example #40
0
def index():
    # narr_erc_all = narr_erc.query.limit(5).all() # This returns a list of objects. Pass that list of objects to your template using jinga.
    # narr_erc_lat = narr_erc.query.filter_by(lat='39.2549').first()
    # narr_erc_date = narr_erc.query.filter(func.date(narr_erc.date) <= '1979-01-02').all()
    # df = pd.read_sql(session.query(narr_erc).filter(func.date(narr_erc.date) <= '1979-01-02').statement, session.bind)
    # df = pd.read_sql(session.query(narr_erc).filter(func.date(narr_erc.date) <= '1979-01-02').statement, session.bind)
    #db.session.add(narr_erc_lat_lon)
    #db.session.commit()

    # fetchall() is one way to get data from a cursor after a query
    # results = cur.fetchall()

    conn = connect_to_db()

    # -------------------------------------------
    # # QUERY: TIME SERIES OF H500, ERC AT ONE LOCATION
    # # Reading data into a list object 'results' directly from postgres fire_weather_db:
    # cur = conn.cursor()
    # sql =  'select id, lat, lon, date, h500, erc from narr_erc \
    # 		where lat = 39.2549 and lon = 236.314 \
    # 		order by id'
    # df = pd.read_sql(sql, conn)
    # cur.close()
    # conn.close()
    # source = ColumnDataSource(df)
    # -------------------------------------------
    # # PLOTTING H500 TIME SERIES
    # p = figure(
    # 		x_axis_type = 'datetime',
    # 		plot_width = 800,
    # 		plot_height = 600,
    # 		# y_range = h500_list,
    #         title = 'H500 Time Series',
    #         x_axis_label = 'Date',
    #         y_axis_label = 'Geopotential height, gpm',
    #         tools = 'pan,zoom_in,zoom_out,save,reset',
    #         )
    #
    # p.line(
    #     source = source,
    #     x = 'date',
    # 	y = 'h500',
    # 	line_color = 'green',
    # 	legend = 'H500',
    # 	line_width = 2
    # 	)
    # -------------------------------------------
    # # PLOTTING ERC TIME SERIES
    # p = figure(
    # 		x_axis_type = 'datetime',
    # 		plot_width = 800,
    # 		plot_height = 600,
    # 		# y_range = h500_list,
    #         title = 'ERC Time Series',
    #         x_axis_label = 'Date',
    #         y_axis_label = 'ERC, AU',
    #         tools = 'pan,zoom_in,zoom_out,save,reset',
    #         )
    #
    # p.line(
    #     source = source,
    #     x = 'date',
    # 	y = 'erc',
    # 	line_color = 'red',
    # 	legend = 'ERC',
    # 	line_width=2
    # 	)
    # -------------------------------------------
    # SQL QUERY: H500 CONTOUR SINGLE DATE
    # Reading data into a list object 'results' directly from postgres fire_weather_db:
    cur = conn.cursor()
    sql = "select id, lat, lon, date, h500, h500_grad_x, pmsl, pmsl_grad_x, pmsl_grad_y, erc from narr_erc \
			where cast(date as date) = '1979-05-15' \
			order by id"

    df = pd.read_sql(sql, conn)
    cur.close()
    conn.close()
    source = ColumnDataSource(df)
    # -------------------------------------------
    # # PLOTTING NARR GRID
    # x = df['lon']
    # y = df['lat']

    # p = figure(
    # 		plot_width = 800,
    # 		plot_height = 600,
    #         title = 'NARR Grid',
    #         x_axis_label = 'Lon',
    #         y_axis_label = 'Lat',
    #         tools = 'pan,zoom_in,zoom_out,save,reset',
    #         )

    # p.circle(x, y, size=2, color="black", alpha=0.5)
    # -------------------------------------------
    # PLOTTING H500 CONTOUR
    var = 'pmsl_grad_x'  # e.g. 'h500', 'h500_grad_x', 'erc'
    var_title = 'PMSL - X Gradient'  # e.g. 'H500', 'H500 - X Gradient', 'ERC'

    lon = df['lon'].drop_duplicates('first').to_numpy()
    lat = df['lat'].drop_duplicates('first').to_numpy()
    lonlon, latlat = np.meshgrid(lon, lat)
    mesh_shape = np.shape(lonlon)

    # Change -32767 to 0:
    if var == 'erc':
        criteria = df[df['erc'] == -32767].index
        df['erc'].loc[criteria] = 0

    d = df[var].to_numpy().reshape(mesh_shape)
    var_list = df[var].values.tolist()
    var_min = min(var_list)
    var_max = max(var_list)

    lon_min = np.min(lon)
    lon_max = np.max(lon)
    dw = lon_max - lon_min
    lat_min = np.min(lat)
    lat_max = np.max(lat)
    dh = lat_max - lat_min

    p = figure(
        #toolbar_location="left",
        title=var_title,
        plot_width=580,
        plot_height=600,
        tooltips=[("lon", "$lon"), ("lat", "$lat"), ("value", "@image")],
        x_range=(lon_min, lon_max),
        y_range=(lat_min, lat_max),
        x_axis_label='Longitude, deg',
        y_axis_label='Latitude, deg')

    if var == 'h500_grad_x' or 'h500_grad_y' or 'pmsl_grad_x' or 'pmsl_grad_y':
        # Color maps that make 0 values clear
        color_mapper = LinearColorMapper(palette=cividis(256),
                                         low=var_min,
                                         high=var_max)
    else:
        color_mapper = LinearColorMapper(palette="Inferno256",
                                         low=var_min,
                                         high=var_max)
        # Decent color map: "Spectra11", "Viridis256"

    # Giving a vector of image data for image parameter (contour plot)
    p.image(image=[d],
            x=lon_min,
            y=lat_min,
            dw=dw,
            dh=dh,
            color_mapper=color_mapper)
    # p.x_range.range_padding = p.y_range.range_padding = 0

    color_bar = ColorBar(
        color_mapper=color_mapper,
        ticker=BasicTicker(),
        label_standoff=12,
        border_line_color=None,
        location=(0, 0),
    )

    p.add_layout(color_bar, 'right')

    # get state boundaries from state map data imported from Bokeh
    state_lats = [states[code]["lats"] for code in states]
    state_lons = [states[code]["lons"] for code in states]
    # add 360 to adjust lons to NARR grid
    state_lons = np.array([np.array(sublist) for sublist in state_lons])
    state_lons += 360

    p.patches(state_lons,
              state_lats,
              fill_alpha=0.0,
              line_color="black",
              line_width=2,
              line_alpha=0.3)

    select = Select(title="Weather Variable:",
                    value="H500",
                    options=[
                        "H500", "H500 X Gradient", "H500 Y Gradient", "PMSL",
                        "PMSL X Gradient", "PMSL Y Gradient",
                        "Energy Release Component"
                    ])
    # slider = Slider(start=DateTime(1979,1,2), end=DateTime(1979,12,31), value=DateTime(1979,1,2), step=1, title="Date")
    slider = Slider(start=1, end=365, step=10, title="Date")

    # def callback(attr, old, new):
    # 	points = slider.value
    # 	data_points.data = {'x': random(points), 'y': random(points)}

    # slider.on_change('value', callback)

    widget_layout = widgetbox(slider, select)
    layout = row(slider, p)

    curdoc().add_root(widget_layout)

    # To run on bokeh server:
    # bokeh serve --show fwp_app.py

    # # Limit the view to the min and max of the building data
    # p.x_range = DataRange1d(lon_min, lon_max)
    # p.y_range = DataRange1d(lat_min, lat_max)
    # p.xaxis.visible = False
    # p.yaxis.visible = False
    p.xgrid.grid_line_color = None
    p.ygrid.grid_line_color = None

    # show(p)

    # output_file("image.html", title="image.py example")

    # show(p)  # open a browser

    script, div = components(p)

    # The data below is passed to add_user_fwp.html to run when localhost:5000/ is opened.
    # return render_template('add_user_fwp.html', narr_erc_all=narr_erc_all, narr_erc_lat=narr_erc_lat, narr_erc_date=narr_erc_date, script=script, div=div)
    return render_template('fwp_bokeh_render.html',
                           script=script,
                           div=div,
                           widget_layout=widget_layout)
Example #41
0
    def create_widget(self, dim, holomap=None, editable=False):
        """"
        Given a Dimension creates bokeh widgets to select along that
        dimension. For numeric data a slider widget is created which
        may be either discrete, if a holomap is supplied or the
        Dimension.values are set, or a continuous widget for
        DynamicMaps. If the slider is discrete the returned mapping
        defines a mapping between values and labels making it possible
        sync the two slider and label widgets. For non-numeric data
        a simple dropdown selection widget is generated.
        """
        label, mapping = None, None
        if holomap is None:
            if dim.values:
                if dim.default is None:
                    default = dim.values[0]
                elif dim.default not in dim.values:
                    raise ValueError("%s dimension default %r is not in dimension values: %s"
                                     % (dim, dim.default, dim.values))
                else:
                    default = dim.default
                value = dim.values.index(default)

                if all(isnumeric(v) for v in dim.values):
                    values = sorted(dim.values)
                    labels = [unicode(dim.pprint_value(v)) for v in values]
                    if editable:
                        label = AutocompleteInput(value=labels[value], completions=labels,
                                                  title=dim.pprint_label)
                    else:
                        label = Div(text='<b>%s</b>' % dim.pprint_value_string(labels[value]))
                    widget = Slider(value=value, start=0, end=len(dim.values)-1, title=None, step=1)
                    mapping = list(enumerate(zip(values, labels)))
                else:
                    values = [(v, dim.pprint_value(v)) for v in dim.values]
                    widget = Select(title=dim.pprint_label, value=values[value][0],
                                    options=values)
            else:
                start = dim.soft_range[0] if dim.soft_range[0] else dim.range[0]
                end = dim.soft_range[1] if dim.soft_range[1] else dim.range[1]
                dim_range = end - start
                int_type = isinstance(dim.type, type) and issubclass(dim.type, int)
                if dim.step is not None:
                    step = dim.step
                elif isinstance(dim_range, int) or int_type:
                    step = 1
                else:
                    step = 10**((round(math.log10(dim_range))-3))

                if dim.default is None:
                    default = start
                elif (dim.default < start or dim.default > end):
                    raise ValueError("%s dimension default %r is not in the provided range: %s"
                                     % (dim, dim.default, (start, end)))
                else:
                    default = dim.default

                if editable:
                    label = TextInput(value=str(default), title=dim.pprint_label)
                else:
                    label = Div(text='<b>%s</b>' % dim.pprint_value_string(default))
                widget = Slider(value=default, start=start,
                                end=end, step=step, title=None)
        else:
            values = (dim.values if dim.values else
                      list(unique_array(holomap.dimension_values(dim.name))))
            if dim.default is None:
                default = values[0]
            elif dim.default not in values:
                raise ValueError("%s dimension default %r is not in dimension values: %s"
                                 % (dim, dim.default, values))
            else:
                default = dim.default
            if isinstance(values[0], np.datetime64) or isnumeric(values[0]):
                values = sorted(values)
                labels = [dim.pprint_value(v) for v in values]
                value = values.index(default)
                if editable:
                    label = AutocompleteInput(value=labels[value], completions=labels,
                                              title=dim.pprint_label)
                else:
                    label = Div(text='<b>%s</b>' % (dim.pprint_value_string(labels[value])))
                widget = Slider(value=value, start=0, end=len(values)-1, title=None, step=1)
            else:
                labels = [dim.pprint_value(v) for v in values]
                widget = Select(title=dim.pprint_label, value=default,
                                options=list(zip(values, labels)))
            mapping = list(enumerate(zip(values, labels)))
        return widget, label, mapping
Example #42
0

# TODO: Checkboxes to include what we want <--
# TODO: make legend its own figure
# TODO: Hover Tool Tips
# TODO: Update documentation & cleanup
# TODO: Control & Calibrator Tools (date range slider?)
# TODO: Live plotting & long term performance evaluation plots

# Get List of Dates for dropdown menu
masterdf = save_r1masterfile(True)
masterdf = masterdf[masterdf.index > IGNORE_BEFORE]
date_list = masterdf.index.format()

# Create Controls
cycle = Select(title='Cycle Date', value=date_list[-1],
               options=date_list)
probes = CheckboxGroup(labels=PROBE_LABELS.keys(),
                       active=DEFAULT_PROBES,
                       disabled=False)
measure = CheckboxGroup(labels=MEASURE_LABELS.keys(),
                        active=DEFAULT_MEASURED)


def get_to_plot(what_to_plot, probe):
    """
    Loops through checked boxes and returns names of columns requested to plot
    :param what_to_plot: list of ints, taken from checkboxgroup.active
    :param probe: boolean, true to look at probe data false for measured.
    :return: List of strs, names of columns in dataframe
    """
    to_plot = []
# Set up the striptool
striptool = Striptool(output_variables_to_display, controller, "test")
striptool.build_plot()

# set up global pv
current_striptool_pv = striptool.live_variable

# set up selection
def striptool_select_callback(attr, old, new):
    global current_striptool_pv
    current_striptool_pv = new


striptool_select = Select(
    title="Variable to plot:",
    value=current_striptool_pv,
    options=list(striptool.pv_monitors.keys()),
)

striptool_select.on_change("value", striptool_select_callback)

# striptool data update callback
def striptool_update_callback():
    """
    Calls striptool update with the current global process variable.
    """
    global current_striptool_pv
    striptool.update(live_variable = current_striptool_pv)


# add table
Example #44
0
    <td><b>Votes:</b></td>
    <td>{3:.0f}</td>
  </tr>
  <tr>
    <td><b>Overall ranking:</b></td>
    <td>{4:.0f}</td>
  </tr>
  <tr>
    <td><b>Generation ranking:</b></td>
    <td>{5:.0f}</td>
  </tr>
</table>
""".format(initial_number, initial_name, initial_generation, initial_votes, initial_ranking_overall, initial_ranking_generation), width=POKEMON_PANEL_WIDTH, height=int(PLOT_HEIGHT*.6))

# Create Select.
select = Select(title="Pokemon:", value=df['name'].tolist()[0], options=df['name'].tolist())

# Create the "Overall" plot.
source_overall = ColumnDataSource(df_ranked[['name', 'votes', 'generation', 'generation_color', 'ranking_overall', 'ranking_generation', 'sprite_source']])
pokemon_names = source_overall.data['name']
pokemon_votes = source_overall.data['votes']

# Notice that initializing the figure with y_range=pokemon_names 
# doesn't allow the option to bound the plot.
p_overall = figure(y_range=FactorRange(factors=pokemon_names, bounds=(0, len(pokemon_names))), 
                   x_axis_label='Votes', plot_height=PLOT_HEIGHT, tools=tools)
r_overall = p_overall.hbar(y='name', left=0, right='votes', height=1, color='generation_color', source=source_overall)
p_overall.x_range = Range1d(0, max(pokemon_votes)*1.05, bounds=(0, max(pokemon_votes)*1.05))
p_overall.ygrid.grid_line_color = None
y_coord = len(df_ranked) - initial_ranking_overall + 0.5
arrow_overall = Arrow(end=NormalHead(line_color='red', fill_color='red', line_width=0, size=10, line_alpha=0.75, fill_alpha=0.75), 
   Nitelikleri seçiniz:
""")
set_new_dataset("lens")
radio_button_labels = ["gini", "gainRatio"]
tree_mode_labels = ["Basit", "Detaylı"]
arrow_list = {"current": [], "previous": []}
current_label = "gini"
selected_root = ""
attribute_checkbox = CheckboxGroup(labels=[attr for attr in list(Instance().attr_list)
                                           if attr != Instance().attr_list[-1]],
                                   active=[i for i, attr in enumerate(list(Instance().attr_list))])
apply_changes_button = Button(label="Değişiklikleri uygula", button_type="success")
decision_button = Toggle(label="Sonuç göster", button_type="warning")
arrow_button = Toggle(label="Karar değerlerini göster", button_type="warning")
root_select = Select(title="Kök niteliği seçiniz:",
                     options=['Hiçbiri'] + [attr for attr in list(Instance().attr_list)[:-1]],
                     value="Hiçbiri")
method_select = Select(title="Metodu seçiniz:", options=radio_button_labels, value="gini")
tree_select = Select(title="Ağacın görünümünü seçiniz:", options=tree_mode_labels, value="Basit")
dataset_select = Select(title="Veri kümesini seç:", value="lens", options=["lens", "car"])
dataset_slider = Slider(start=0, end=50, value=0, step=1, title="Test verisi oranı")
rect_width = 2
rect_height = 0.5
circle_radius = 5
TOOLTIPS = [
    ("Metod Değeri", "@{nonLeafNodes_stat}"),
    ("Örnek Sayısı", "@{instances}"),
    ("Sonuç", "@{decision}")
]

""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
Example #46
0
def bokeh_plot(import_df):
    import pandas as pd
    import numpy as np
    from bokeh.plotting import figure, show
    from bokeh.layouts import layout, widgetbox, row, column, gridplot
    from bokeh.models import ColumnDataSource, HoverTool, BoxZoomTool, ResetTool, PanTool, CustomJS, PrintfTickFormatter, WheelZoomTool, SaveTool, LassoSelectTool, NumeralTickFormatter
    from bokeh.models.widgets import Slider, Select, TextInput, Div, Tabs, Panel, DataTable, DateFormatter, TableColumn, PreText, NumberFormatter, RangeSlider
    from bokeh.io import curdoc
    from functools import lru_cache
    from bokeh.transform import dodge
    from os.path import dirname, join
    from bokeh.core.properties import value

    #load plotting data here
    @lru_cache()
    def load_data():
        df = import_df
        df.dropna(how='all', axis=0)
        #Northest=['3229','3277','3276','3230','3259','All_Stores_NE']
        df.location_reference_id = df.location_reference_id.astype(str)
        #df['region'] = ['Northeast' if x in Northest else 'Midwest' for x in df['location_reference_id']]
        df['date'] = pd.to_datetime(df['date'])
        df[[
            'BOH_gt_Shelf_Capacity', 'OTL_gt_Shelf_Capacity',
            'Ideal_BOH_gt_Shelf_Capacity', 'BOH_lt_Ideal', 'BOH_eq_Ideal',
            'BOH_gt_Ideal', 'Demand_Fulfilled', 'Fill_Rate', 'Backroom_OH',
            'Total_OH', 'Prop_OH_in_Backroom', 'Never_Q98_gt_POG',
            'Never_Ideal_BOH_gt_POG', 'Sometimes_OTL_Casepack_1_gt_POG',
            'Always_OTL_Casepack_1_le_POG', 'Non_POG'
        ]] = df[[
            'BOH > Shelf Capacity', 'OTL > Shelf Capacity',
            'Ideal BOH > Shelf Capacity', 'BOH < Ideal', 'BOH = Ideal',
            'BOH > Ideal', 'Demand Fulfilled', 'Fill Rate', 'Backroom_OH',
            'Total OH', 'Prop OH in Backroom', 'Never: Q98 > POG',
            'Never: Ideal BOH > POG', 'Sometimes: OTL+Casepack-1 > POG',
            'Always: OTL+Casepack-1 <= POG', 'Non-POG'
        ]]
        df['date_bar'] = df['date']
        df['date_bar'] = df['date_bar'].astype(str)
        return df

    #Filter data source for "All" stores OR data agrregation on DC level
    df_agg = load_data().groupby(['location_reference_id'],
                                 as_index=False).sum()
    source1 = ColumnDataSource(data=df_agg)
    sdate = min(load_data()['date'])
    edate = max(load_data()['date'])
    nodes = len(list(load_data().location_reference_id.unique()))
    days = len(list(load_data().date.unique()))
    policy = "Prod"

    #list of dates for vbar charts
    x_range_list = list(load_data().date_bar.unique())
    #direct access to number of location_reference_idand region
    all_locations1 = list(load_data().location_reference_id.unique())
    #agg_value=['All']
    #all location_reference_idfrom csv file along with an option for agg data "All"
    #all_locations=all_locations1+agg_value
    #all_regions = ['Northeast', 'Midwest']
    all_regions = list(load_data().region.unique())

    desc = Div(text="All locations", width=230)
    pre = Div(text="_", width=230)
    location = Select(title="Location",
                      options=all_locations1,
                      value="All_Stores_NE")
    region = Select(title="Region", options=all_regions, value="NE")

    text_input = TextInput(value="default", title="Search Location:")
    #full data set from load_data(df=df_import)
    source = ColumnDataSource(data=load_data())
    original_source = ColumnDataSource(data=load_data())

    #plotting starts........... here are total 8 graphs for each Metric.

    #Back room on hand
    hover = HoverTool(
        tooltips=[("Location", "@location_reference_id"), (
            "Date", "@date_bar"), ("Backroom_OH", "@Backroom_OH{0,0.00}")])
    TOOLS = [
        hover,
        BoxZoomTool(),
        LassoSelectTool(),
        WheelZoomTool(),
        PanTool(),
        ResetTool(),
        SaveTool()
    ]
    p = figure(x_range=x_range_list,
               plot_width=1000,
               plot_height=525,
               title="Backroom On hand by store",
               tools=TOOLS,
               toolbar_location='above',
               x_axis_label="Date",
               y_axis_label="Backroom OH")
    p.background_fill_color = "#e6e9ed"
    p.background_fill_alpha = 0.5
    p.vbar(x=dodge('date_bar', -0.25, range=p.x_range),
           top='Backroom_OH',
           hover_alpha=0.5,
           hover_line_color='black',
           width=0.8,
           source=source,
           color="#718dbf")
    p.xaxis.major_label_orientation = 1
    p.legend.border_line_width = 3
    p.legend.border_line_color = None
    p.legend.border_line_alpha = 0.5
    p.title.text_color = "olive"

    #inbound outbound
    hover_m = HoverTool(
        tooltips=[("Location", "@location_reference_id"), (
            "Date", "@date_bar"), (
                "Inbound",
                "@Inbound{0,0.00}"), ("Outbound", "@Outbound{0,0.00}")])
    TOOLS_m = [
        hover_m,
        BoxZoomTool(),
        LassoSelectTool(),
        WheelZoomTool(),
        PanTool(),
        ResetTool(),
        SaveTool()
    ]
    m = figure(plot_height=525,
               plot_width=1000,
               x_range=x_range_list,
               title="Inbound/Outbound by store",
               tools=TOOLS_m,
               toolbar_location='above',
               x_axis_label="Date",
               y_axis_label="Units")
    m.background_fill_color = "#e6e9ed"
    m.background_fill_alpha = 0.5
    m.vbar(x=dodge('date_bar', -0.25, range=m.x_range),
           top='Inbound',
           hover_alpha=0.5,
           hover_line_color='black',
           width=0.4,
           source=source,
           color="#718dbf",
           legend=value("Inbound"))
    m.vbar(x=dodge('date_bar', 0.25, range=m.x_range),
           top='Outbound',
           hover_alpha=0.5,
           hover_line_color='black',
           width=0.4,
           source=source,
           color="#e84d60",
           legend=value("Outbound"))
    m.xaxis.major_label_orientation = 1
    m.legend.border_line_width = 3
    m.legend.border_line_color = None
    m.legend.border_line_alpha = 0.5
    m.title.text_color = "olive"

    #Stockout
    hover_s = HoverTool(
        tooltips=[("Location", "@location_reference_id"), (
            "Date", "@date_bar"), (
                "BOH_OOS",
                "@BOH_OOS{0,0.000}"), ("EOH_OOS", "@EOH_OOS{0,0.000}")])
    TOOLS_s = [
        hover_s,
        BoxZoomTool(),
        LassoSelectTool(),
        WheelZoomTool(),
        PanTool(),
        ResetTool(),
        SaveTool()
    ]
    s = figure(plot_height=525,
               plot_width=1000,
               title="Stockouts by store",
               x_axis_type="datetime",
               toolbar_location='above',
               tools=TOOLS_s,
               x_axis_label="Date",
               y_axis_label="Prop Stockout")
    s.background_fill_color = "#e6e9ed"
    s.background_fill_alpha = 0.5
    s.circle(x='date',
             y='EOH_OOS',
             source=source,
             fill_color=None,
             line_color="#4375c6")
    s.line(x='date',
           y='EOH_OOS',
           source=source,
           hover_alpha=0.5,
           hover_line_color='black',
           line_width=2,
           line_color='navy',
           legend=value("EOH OOS"))
    s.circle(x='date',
             y='BOH_OOS',
             source=source,
             fill_color=None,
             line_color="#4375c6")
    s.line(x='date',
           y='BOH_OOS',
           source=source,
           hover_alpha=0.5,
           hover_line_color='black',
           line_width=2,
           line_color='red',
           legend=value("BOH OOS"))
    s.legend.border_line_width = 3
    s.legend.border_line_color = None
    s.legend.border_line_alpha = 0.5
    s.title.text_color = "olive"

    #Fill rate
    hover_t = HoverTool(
        tooltips=[("Location", "@location_reference_id"), (
            "Date", "@date_bar"), ("Fill Rate", "@Fill_Rate{0,0.00}")])
    TOOLS_t = [
        hover_t,
        BoxZoomTool(),
        LassoSelectTool(),
        WheelZoomTool(),
        PanTool(),
        ResetTool(),
        SaveTool()
    ]
    t = figure(plot_height=525,
               x_range=x_range_list,
               plot_width=1000,
               title="Fill rates by store",
               tools=TOOLS_t,
               toolbar_location='above',
               x_axis_label="Date",
               y_axis_label="Fill rate")
    t.background_fill_color = "#e6e9ed"
    t.background_fill_alpha = 0.5
    t.vbar(x=dodge('date_bar', -0.25, range=t.x_range),
           top='Fill Rate',
           hover_alpha=0.5,
           hover_line_color='black',
           width=0.8,
           source=source,
           color="#718dbf")
    t.xaxis.major_label_orientation = 1
    t.legend.border_line_width = 3
    t.legend.border_line_color = None
    t.legend.border_line_alpha = 0.5
    t.title.text_color = "olive"

    # % Backroom spillover
    hover_w = HoverTool(
        tooltips=[("Location", "@location_reference_id"), ("Date",
                                                           "@date_bar"),
                  ("Prop OH in Backroom", "@Prop_OH_in_Backroom{0,0.00}")])
    TOOLS_w = [
        hover_w,
        BoxZoomTool(),
        LassoSelectTool(),
        WheelZoomTool(),
        PanTool(),
        ResetTool(),
        SaveTool()
    ]
    w = figure(plot_height=525,
               plot_width=1000,
               title="Prop OH in Backroom by store",
               x_axis_type="datetime",
               tools=TOOLS_w,
               toolbar_location='above',
               x_axis_label="Date",
               y_axis_label=" % Backroom spillover")
    w.background_fill_color = "#e6e9ed"
    w.background_fill_alpha = 0.5
    w.circle(x='date',
             y='Prop OH in Backroom',
             source=source,
             fill_color=None,
             line_color="#4375c6")
    w.line(x='date',
           y='Prop OH in Backroom',
           source=source,
           hover_alpha=0.5,
           hover_line_color='black',
           line_width=2,
           line_color='navy')
    w.title.text_font_style = "bold"
    w.title.text_color = "olive"
    w.legend.click_policy = "hide"
    w.yaxis[0].formatter = NumeralTickFormatter(format="0.0%")

    #BOH vs Ideal
    hover_f = HoverTool(
        tooltips=[("Location", "@location_reference_id"), (
            "Date",
            "@date_bar"), ('BOH < Ideal', "@BOH_lt_Ideal{0,0.00}"
                           ), ('BOH > Ideal', "@BOH_gt_Ideal{0,0.00}"
                               ), ('BOH = Ideal', "@BOH_eq_Ideal{0,0.00}")])
    TOOLS_f = [
        hover_f,
        BoxZoomTool(),
        LassoSelectTool(),
        WheelZoomTool(),
        PanTool(),
        ResetTool(),
        SaveTool()
    ]
    colors = ["#c9d9d3", "#718dbf", "#e84d60"]
    BOH_vs_ideal = ['BOH < Ideal', 'BOH > Ideal', 'BOH = Ideal']
    f = figure(x_range=x_range_list,
               plot_height=525,
               plot_width=1000,
               title="BOH vs Ideal by store",
               toolbar_location='above',
               x_axis_label="Date",
               y_axis_label="Prop",
               tools=TOOLS_f)
    f.vbar_stack(BOH_vs_ideal,
                 x='date_bar',
                 width=0.9,
                 color=colors,
                 source=source,
                 legend=[value(x) for x in BOH_vs_ideal],
                 name=BOH_vs_ideal)
    f.xaxis.major_label_orientation = 1
    f.legend.border_line_width = 3
    f.legend.border_line_color = None
    f.legend.border_line_alpha = 0.5
    f.title.text_color = "olive"

    #Pog Fit
    hover_g = HoverTool(
        tooltips=[("Location", "@location_reference_id"), (
            "Date",
            "@date_bar"), ('Never: Q98 > POG', "@Never_Q98_gt_POG{0,0.00}"),
                  ("Never: Ideal BOH > POG",
                   "@Never_Ideal_BOH_gt_POG{0,0.00}"),
                  ("Sometimes: OTL+Casepack-1 > POG",
                   "@Sometimes_OTL_Casepack_1_gt_POG{0,0.00}"),
                  ("Always: OTL+Casepack-1 <= POG",
                   "@Always_OTL_Casepack_1_le_POG{0,0.00}"
                   ), ("Non-POG'", "@Non_POG{0,0.00}")])
    TOOLS_g = [
        hover_g,
        BoxZoomTool(),
        LassoSelectTool(),
        WheelZoomTool(),
        PanTool(),
        ResetTool(),
        SaveTool()
    ]
    colors2 = ['#79D151', "#718dbf", '#29788E', '#fc8d59', '#d53e4f']
    pog_fit = [
        'Never: Q98 > POG', 'Never: Ideal BOH > POG',
        'Sometimes: OTL+Casepack-1 > POG', 'Always: OTL+Casepack-1 <= POG',
        'Non-POG'
    ]
    g = figure(x_range=x_range_list,
               plot_height=525,
               plot_width=1200,
               title="Pog Fit by store",
               toolbar_location='above',
               x_axis_label="Date",
               y_axis_label="Counts",
               tools=TOOLS_g)
    g.vbar_stack(pog_fit,
                 x='date_bar',
                 width=0.9,
                 color=colors2,
                 source=source,
                 legend=[value(x) for x in pog_fit],
                 name=pog_fit)
    g.xaxis.major_label_orientation = 1
    g.legend.border_line_width = 3
    g.legend.border_line_color = None
    g.legend.border_line_alpha = 0.5
    g.title.text_color = "olive"
    g.legend.location = "top_right"

    # BOH vs Pog
    colors3 = ["#c9d9d3", "#718dbf", "#e84d60"]
    shelf = [
        'BOH > Shelf Capacity', 'OTL > Shelf Capacity',
        'Ideal BOH > Shelf Capacity'
    ]
    hover_h = HoverTool(
        tooltips=[("Location", "@location_reference_id"), ("Date",
                                                           "@date_bar"),
                  ("OTL > Shelf Capacity", "@OTL_gt_Shelf_Capacity{0,0.00}"
                   ), ("BOH > Shelf Capacity",
                       "@BOH_gt_Shelf_Capacity{0,0.00}"),
                  ("Ideal BOH > Shelf Capacity",
                   "@Ideal_BOH_gt_Shelf_Capacity{0,0.00}")])
    TOOLS_h = [
        hover_h,
        BoxZoomTool(),
        LassoSelectTool(),
        WheelZoomTool(),
        PanTool(),
        ResetTool(),
        SaveTool()
    ]
    h = figure(plot_height=525,
               plot_width=1000,
               title="BOH vs Pog by store",
               x_axis_type="datetime",
               toolbar_location='above',
               tools=TOOLS_h,
               x_axis_label="Date",
               y_axis_label="Prop")
    h.background_fill_color = "#e6e9ed"
    h.background_fill_alpha = 0.5
    h.circle(x='date',
             y='BOH > Shelf Capacity',
             source=source,
             fill_color=None,
             line_color="#4375c6")
    h.line(x='date',
           y='BOH > Shelf Capacity',
           source=source,
           hover_alpha=0.5,
           hover_line_color='black',
           line_width=2,
           line_color='navy',
           legend=value("BOH > Shelf Capacity"))
    h.circle(x='date',
             y='OTL > Shelf Capacity',
             source=source,
             fill_color=None,
             line_color="#4375c6")
    h.line(x='date',
           y='OTL > Shelf Capacity',
           source=source,
           hover_alpha=0.5,
           hover_line_color='black',
           line_width=2,
           line_color="green",
           legend=value("OTL > Shelf Capacity"))
    h.circle(x='date',
             y='Ideal BOH > Shelf Capacity',
             source=source,
             fill_color=None,
             line_color="#4375c6")
    h.line(x='date',
           y='Ideal BOH > Shelf Capacity',
           source=source,
           hover_alpha=0.5,
           hover_line_color='black',
           line_width=2,
           line_color="#e84d60",
           legend=value("Ideal BOH > Shelf Capacity"))
    h.legend.border_line_width = 3
    h.legend.border_line_color = None
    h.legend.border_line_alpha = 0.5
    h.title.text_color = "olive"
    h.legend.click_policy = "mute"

    # Inventory
    hover_j = HoverTool(
        tooltips=[("Location", "@location_reference_id"), (
            "Date", "@date_bar"), ("DFE_Q98", "@DFE_Q98{0,0.00}"),
                  ("OTL",
                   "@OTL{0,0.00}"), ("EOH",
                                     "@EOH{0,0.00}"), ("BOH", "@BOH{0,0.00}")])
    TOOLS_j = [
        hover_j,
        BoxZoomTool(),
        LassoSelectTool(),
        WheelZoomTool(),
        PanTool(),
        ResetTool(),
        SaveTool()
    ]
    j = figure(plot_height=525,
               plot_width=1200,
               x_range=x_range_list,
               title="Inbound/Outbound by store",
               tools=TOOLS_j,
               toolbar_location='above',
               x_axis_label="Date",
               y_axis_label="Units")
    j.background_fill_color = "#e6e9ed"
    j.background_fill_alpha = 0.5
    j.vbar(x=dodge('date_bar', -0.40, range=j.x_range),
           top='DFE_Q98',
           hover_alpha=0.3,
           hover_line_color='black',
           width=0.2,
           source=source,
           color="#FBA40A",
           legend=value("DFE_Q98"))
    j.vbar(x=dodge('date_bar', -0.20, range=j.x_range),
           top='OTL',
           hover_alpha=0.3,
           hover_line_color='black',
           width=0.2,
           source=source,
           color="#4292c6",
           legend=value("OTL"))
    j.vbar(x=dodge('date_bar', 0.00, range=j.x_range),
           top='EOH',
           hover_alpha=0.3,
           hover_line_color='black',
           width=0.2,
           source=source,
           color='#a1dab4',
           legend=value("EOH"))
    j.vbar(x=dodge('date_bar', 0.20, range=j.x_range),
           top='BOH',
           hover_alpha=0.3,
           hover_line_color='black',
           width=0.2,
           source=source,
           color="#DC5039",
           legend=value("BOH"))
    j.xaxis.major_label_orientation = 1
    j.legend.border_line_width = 3
    j.legend.border_line_color = None
    j.legend.border_line_alpha = 0.5
    j.title.text_color = "olive"
    j.legend.location = "top_left"
    j.legend.click_policy = "mute"

    #desc.text = " <br >  <b> Region:</b> <i>  </i> <br /> "
    pre.text = " <b>Start date:</b>  <i>{}</i> <br />  <b>End date:</b> <i>{}</i> <br /> <b>Time period:</b> <i>{}</i> days <br />  <b> Total Number of Nodes:</b> <i>{}</i> <br /> <b>Policy</b> = <i>{}</i><br /> ".format(
        sdate, edate, days, nodes, policy)

    #fuction to update data on selection
    callback = CustomJS(args=dict(source=source,
                                  original_source=original_source,
                                  location_select_obj=location,
                                  region_select_obj=region,
                                  div=desc,
                                  text_input=text_input),
                        code="""
    var data = source.data;
    var original_data = original_source.data;
    var loc = location_select_obj.value;
    var reg = region_select_obj.value;
    var line = " <br />  <b> Region:</b>"+ reg + "<br />  <b>Location:</b> " +   loc;
    var text_input =text_input.value;
    div.text=line;
    for (var key in original_data) {
    data[key] = [];
    for (var i = 0; i < original_data['location_reference_id'].length; ++i) {
    if ((original_data['location_reference_id'][i] === loc) && (original_data['region'][i] === reg) ) {
    data[key].push(original_data[key][i]);
    }   }   }
    source.change.emit();
    """)

    #controls = [location, region]
    #for control in controls:
    #control.js_on_change("value", callback)
    #source.js_on_change("value", callback)
    desc.js_on_event('event', callback)
    location.js_on_change('value', callback)
    region.js_on_change('value', callback)
    text_input.js_on_change('value', callback)
    #inputs = widgetbox(*controls, sizing_mode="fixed")
    #inputs = widgetbox(*controls,width=220,height=500)
    inputs = widgetbox(location, region, desc, pre, width=220, height=500)
    # controls number of tabs
    tab1 = Panel(child=p, title='Backroom OH')
    tab2 = Panel(child=s, title='Stockouts')
    tab3 = Panel(child=f, title='BOH vs Ideal')
    tab4 = Panel(child=g, title='Pog Fit')
    tab5 = Panel(child=m, title='Inbound/Outbound')
    tab6 = Panel(child=h, title='BOH vs POG')
    tab7 = Panel(child=t, title='Fill Rate')
    tab8 = Panel(child=j, title='Inventory')
    tab9 = Panel(child=w, title='Prop OH in Backroom')

    #data table columns to summarize data
    columns = [
        TableColumn(field="location_reference_id", title="Location"),
        TableColumn(field="Backroom_OH",
                    title="Backroom_OH",
                    formatter=NumberFormatter(format="0,0")),
        TableColumn(field="Outbound",
                    title="Outbound",
                    formatter=NumberFormatter(format="0,0")),
        TableColumn(field="Inbound",
                    title="Inbound",
                    formatter=NumberFormatter(format="0,0")),
        TableColumn(field="OTL",
                    title="OTL",
                    formatter=NumberFormatter(format="0,0")),
        TableColumn(field="DFE_Q98",
                    title="DFE_Q98",
                    formatter=NumberFormatter(format="0,0")),
        TableColumn(field="BOH",
                    title="BOH",
                    formatter=NumberFormatter(format="0,0")),
        TableColumn(field="EOH",
                    title="EOH",
                    formatter=NumberFormatter(format="0,0")),
        TableColumn(field="BOH_OOS",
                    title="BOH_OOS",
                    formatter=NumberFormatter(format="0,0")),
        TableColumn(field="EOH_OOS",
                    title="EOH_OOS",
                    formatter=NumberFormatter(format="0,0"))
    ]
    data_table = DataTable(source=source1, columns=columns, width=1250)

    tab10 = Panel(child=data_table, title='Summary Table')
    view = Tabs(
        tabs=[tab1, tab2, tab5, tab8, tab6, tab3, tab7, tab4, tab9, tab10])

    layout_text = column(inputs)
    layout1 = row(layout_text, view)
    #laying out plot
    layout2 = layout(children=[[layout_text, view]],
                     sizing_mode='scale_height')
    #update plots
    return layout2
Example #47
0
def bokeh_summary_plot(df, savepath=None):
    """Summary plot"""

    from bokeh.plotting import figure
    from bokeh.layouts import column
    from bokeh.models import ColumnDataSource, Range1d, HoverTool, TapTool, CustomJS, OpenURL

    TOOLS = "pan,wheel_zoom,hover,tap,reset,save"

    colors = get_bokeh_colors()
    df = df.rename(columns={'level_0': 'predictor'})
    df['color'] = [colors[x] for x in df['predictor']]
    p = figure(title="Summary", tools=TOOLS, width=500, height=500)
    p.xaxis.axis_label = 'binder_density'
    p.yaxis.axis_label = 'binders'

    #make metric for point sizes
    #df['point_size'] = df.binder_density
    source = ColumnDataSource(data=df)

    p.circle(x='binder_density',
             y='binders',
             line_color='black',
             fill_color='color',
             fill_alpha=0.4,
             size=10,
             source=source,
             legend_group='predictor')
    hover = p.select(dict(type=HoverTool))
    hover.tooltips = OrderedDict([
        ("name", "@name"),
        ("length", "@length"),
        ("binders", "@binders"),
        ("binder_density", "@binder_density"),
        ("top_peptide", "@top_peptide"),
        ("max_score", "@max_score"),
    ])
    p.toolbar.logo = None
    if savepath != None:
        url = "http://*****:*****@name" % savepath
        taptool = p.select(type=TapTool)
        taptool.callback = OpenURL(url=url)

    callback = CustomJS(args=dict(source=source),
                        code="""
        var data = source.data;
        var f = cb_obj.value

        data['x'] = f
        source.trigger('change');
        source.change.emit();
    """)

    from bokeh.layouts import widgetbox
    from bokeh.models.widgets import Select
    menu = [(i, i) for i in df.columns]
    select = Select(title='X', value='A', options=list(df.columns), width=8)
    select.js_on_change('value', callback)

    #layout = column(p, select, sizing_mode='scale_width')
    return p
Example #48
0
# Darstellung des Säulendiagramm
bar.vbar(x='x', top='top', width=0.1, source=source_kat)

# Allgemeinen Plot erstellen
scatter = figure(plot_height=400, plot_width=400, title="Scatter-Plot",
                 x_axis_label='total_bill',
                 y_axis_label='tip')

source_scatter = ColumnDataSource(data=dict(x=tips.total_bill, y=tips.tip))

# Darstellung des Scatter Diagramms
scatter.scatter(x='x', y='y', source=source_scatter)

# WIDGTS
# Select Histogramm
select_hist = Select(title="Histogramm", value="total_bill",
                     options=list(tips.dtypes[tips.dtypes != 'category'].index))

select_cat = Select(title="Säulendiagramm", value="smoker",
                    options=list(tips.dtypes[tips.dtypes == 'category'].index))

# Select Scatter
select_x = Select(title="Scatter X", value="total_bill", options=['total_bill', 'size', 'tip'])
select_y = Select(title="Scatter Y", value="tip", options=['total_bill', 'size', 'tip'])

# Callbacks zum Aktualisieren der Visualisierungen
def update_data(attrname, old, new):
    """Update der Daten sowie der Beschriftungen"""
    # Scatter Diagramm
    scatter.xaxis.axis_label = select_x.value
    scatter.yaxis.axis_label = select_y.value
    x = select_x.value
Example #49
0
checkbox_group = CheckboxGroup(labels=["Option 1", "Option 2", "Option 3"],
                               active=[0, 1])

radio_group = RadioGroup(labels=["Option 1", "Option 2", "Option 3"], active=0)

checkbox_button_group = CheckboxButtonGroup(
    labels=["Option 1", "Option 2", "Option 3"], active=[0, 1])

radio_button_group = RadioButtonGroup(
    labels=["Option 1", "Option 2", "Option 3"], active=0)

text_input = TextInput(placeholder="Enter value ...")

autocomplete_input = AutocompleteInput()

select = Select(options=["Option 1", "Option 2", "Option 3"])

multi_select = MultiSelect(options=["Option %d" % (i + 1) for i in range(16)],
                           size=6)

slider = Slider(value=10, start=0, end=100)

range_slider = RangeSlider()

#date_range_slider = DateRangeSlider(value=(date(2016, 1, 1), date(2016, 12, 31)))

date_picker = DatePicker()

paragraph = Paragraph(text="some text")

div = Div(text="some <b>text</b>")
def get_data(t1, t2):
    df1 = load_ticker(t1)
    df2 = load_ticker(t2)
    data = pd.concat([df1, df2], axis=1)
    data = data.dropna()
    data['t1'] = data[t1]
    data['t2'] = data[t2]
    data['t1_returns'] = data[t1 + '_returns']
    data['t2_returns'] = data[t2 + '_returns']
    return data


# set up widgets

stats = PreText(text='', width=500)
ticker1 = Select(value='AAPL', options=nix('GOOG', DEFAULT_TICKERS))
ticker2 = Select(value='GOOG', options=nix('AAPL', DEFAULT_TICKERS))

# set up plots

source = ColumnDataSource(
    data=dict(date=[], t1=[], t2=[], t1_returns=[], t2_returns=[]))
source_static = ColumnDataSource(
    data=dict(date=[], t1=[], t2=[], t1_returns=[], t2_returns=[]))
tools = 'pan,wheel_zoom,xbox_select,reset'

corr = figure(plot_width=350,
              plot_height=350,
              tools='pan,wheel_zoom,box_select,reset')
corr.circle('t1_returns',
            't2_returns',
class MetaModelVisualization(object):
    """
    Top-level container for the Meta Model Visualization.

    Attributes
    ----------
    prob : Problem
        Name of variable corresponding to Problem Component
    meta_model : MetaModel
        Name of empty Meta Model Component object reference
    resolution : int
        Number used to calculate width and height of contour plot
    is_structured_meta_model : Bool
        Boolean used to signal whether the meta model is structured or unstructured
    slider_source : ColumnDataSource
        Data source containing dictionary of sliders
    contour_training_data_source : ColumnDataSource
        Data source containing dictionary of training data points
    bottom_plot_source : ColumnDataSource
        Data source containing data for the bottom subplot
    bottom_plot_scatter_source : ColumnDataSource
        Data source containing scatter point data for the bottom subplot
    right_plot_source : ColumnDataSource
        Data source containing data for the right subplot
    right_plot_scatter_source : ColumnDataSource
        Data source containing scatter point data for the right subplot
    contour_plot_source : ColumnDataSource
        Data source containing data for the contour plot
    input_names : list
        List of input data titles as strings
    output_names : list
        List of output data titles as strings
    training_inputs : dict
        Dictionary of input training data
    x_input_select : Select
        Bokeh Select object containing a list of inputs for the x axis
    y_input_select : Select
        Bokeh Select object containing a list of inputs for the y axis
    output_select : Select
        Bokeh Select object containing a list of inputs for the outputs
    x_input_slider : Slider
        Bokeh Slider object containing a list of input values for the x axis
    y_input_slider : Slider
        Bokeh Slider object containing a list of input values for the y axis
    slider_dict : dict
        Dictionary of slider names and their respective slider objects
    predict_inputs : dict
        Dictionary containing training data points to predict at.
    num_inputs : int
        Number of inputs
    num_outputs : int
        Number of outputs
    limit_range : array
        Array containing the range of each input
    scatter_distance : TextInput
        Text input for user to enter custom value to calculate distance of training points around
        slice line
    right_alphas : array
        Array of points containing alpha values for right plot
    bottom_alphas : array
        Array of points containing alpha values for bottom plot
    dist_range : float
        Value taken from scatter_distance used for calculating distance of training points around
        slice line
    x_index : int
        Value of x axis column
    y_index : int
        Value of y axis column
    output_variable : int
        Value of output axis column
    sliders_and_selects : layout
        Layout containing the sliders and select elements
    doc_layout : layout
        Contains first row of plots
    doc_layout2 : layout
        Contains second row of plots
    Z : array
        A 2D array containing contour plot data
    """

    def __init__(self, model, resolution=50, doc=None):
        """
        Initialize parameters.

        Parameters
        ----------
        model : MetaModelComponent
            Reference to meta model component
        resolution : int
            Value used to calculate the size of contour plot meshgrid
        doc : Document
            The bokeh document to build.
        """
        self.prob = Problem()
        self.resolution = resolution
        logging.getLogger("bokeh").setLevel(logging.ERROR)

        # If the surrogate model coming in is structured
        if isinstance(model, MetaModelUnStructuredComp):
            self.is_structured_meta_model = False

            # Create list of input names, check if it has more than one input, then create list
            # of outputs
            self.input_names = [name[0] for name in model._surrogate_input_names]
            if len(self.input_names) < 2:
                raise ValueError('Must have more than one input value')
            self.output_names = [name[0] for name in model._surrogate_output_names]

            # Create reference for untructured component
            self.meta_model = MetaModelUnStructuredComp(
                default_surrogate=model.options['default_surrogate'])

        # If the surrogate model coming in is unstructured
        elif isinstance(model, MetaModelStructuredComp):
            self.is_structured_meta_model = True

            self.input_names = [name for name in model._var_rel_names['input']]

            if len(self.input_names) < 2:
                raise ValueError('Must have more than one input value')

            self.output_names = [name for name in model._var_rel_names['output']]

            self.meta_model = MetaModelStructuredComp(
                distributed=model.options['distributed'],
                extrapolate=model.options['extrapolate'],
                method=model.options['method'],
                training_data_gradients=model.options['training_data_gradients'],
                vec_size=1)

        # Pair input list names with their respective data
        self.training_inputs = {}

        self._setup_empty_prob_comp(model)

        # Setup dropdown menus for x/y inputs and the output value
        self.x_input_select = Select(title="X Input:", value=[x for x in self.input_names][0],
                                     options=[x for x in self.input_names])
        self.x_input_select.on_change('value', self._x_input_update)

        self.y_input_select = Select(title="Y Input:", value=[x for x in self.input_names][1],
                                     options=[x for x in self.input_names])
        self.y_input_select.on_change('value', self._y_input_update)

        self.output_select = Select(title="Output:", value=[x for x in self.output_names][0],
                                    options=[x for x in self.output_names])
        self.output_select.on_change('value', self._output_value_update)

        # Create sliders for each input
        self.slider_dict = {}
        self.predict_inputs = {}
        for title, values in self.training_inputs.items():
            slider_data = np.linspace(min(values), max(values), self.resolution)
            self.predict_inputs[title] = slider_data
            # Calculates the distance between slider ticks
            slider_step = slider_data[1] - slider_data[0]
            slider_object = Slider(start=min(values), end=max(values), value=min(values),
                                   step=slider_step, title=str(title))
            self.slider_dict[title] = slider_object

        self._slider_attrs()

        # Length of inputs and outputs
        self.num_inputs = len(self.input_names)
        self.num_outputs = len(self.output_names)

        # Precalculate the problem bounds.
        limits = np.array([[min(value), max(value)] for value in self.training_inputs.values()])
        self.limit_range = limits[:, 1] - limits[:, 0]

        # Positional indicies
        self.x_index = 0
        self.y_index = 1
        self.output_variable = self.output_names.index(self.output_select.value)

        # Data sources are filled with initial values
        # Slider Column Data Source
        self.slider_source = ColumnDataSource(data=self.predict_inputs)

        # Contour plot Column Data Source
        self.contour_plot_source = ColumnDataSource(data=dict(
            z=np.random.rand(self.resolution, self.resolution)))
        self.contour_training_data_source = ColumnDataSource(
            data=dict(x=np.repeat(0, self.resolution), y=np.repeat(0, self.resolution)))

        # Bottom plot Column Data Source
        self.bottom_plot_source = ColumnDataSource(data=dict(
            x=np.repeat(0, self.resolution), y=np.repeat(0, self.resolution)))
        self.bottom_plot_scatter_source = ColumnDataSource(data=dict(
            bot_slice_x=np.repeat(0, self.resolution), bot_slice_y=np.repeat(0, self.resolution)))

        # Right plot Column Data Source
        self.right_plot_source = ColumnDataSource(data=dict(
            x=np.repeat(0, self.resolution), y=np.repeat(0, self.resolution)))
        self.right_plot_scatter_source = ColumnDataSource(data=dict(
            right_slice_x=np.repeat(0, self.resolution),
            right_slice_y=np.repeat(0, self.resolution)))

        # Text input to change the distance of reach when searching for nearest data points
        self.scatter_distance = TextInput(value="0.1", title="Scatter Distance")
        self.scatter_distance.on_change('value', self._scatter_input)
        self.dist_range = float(self.scatter_distance.value)

        # Grouping all of the sliders and dropdowns into one column
        sliders = [value for value in self.slider_dict.values()]
        sliders.extend(
            [self.x_input_select, self.y_input_select, self.output_select, self.scatter_distance])
        self.sliders_and_selects = row(
            column(*sliders))

        # Layout creation
        self.doc_layout = row(self._contour_data(), self._right_plot(), self.sliders_and_selects)
        self.doc_layout2 = row(self._bottom_plot())

        if doc is None:
            doc = curdoc()

        doc.add_root(self.doc_layout)
        doc.add_root(self.doc_layout2)
        doc.title = 'Meta Model Visualization'

    def _setup_empty_prob_comp(self, metamodel):
        """
        Take data from surrogate ref and pass it into new surrogate model with empty Problem model.

        Parameters
        ----------
        metamodel : MetaModelComponent
            Reference to meta model component

        """
        # Check for structured or unstructured
        if self.is_structured_meta_model:
            # Loop through the input names
            for idx, name in enumerate(self.input_names):
                # Check for no training data
                try:
                    # Append the input data/titles to a dictionary
                    self.training_inputs[name] = metamodel.inputs[idx]
                    # Also, append the data as an 'add_input' to the model reference
                    self.meta_model.add_input(name, 0.,
                                              training_data=metamodel.inputs[idx])
                except TypeError:
                    msg = "No training data present for one or more parameters"
                    raise TypeError(msg)

            # Add the outputs to the model reference
            for idx, name in enumerate(self.output_names):
                self.meta_model.add_output(
                    name, 0.,
                    training_data=metamodel.training_outputs[name])

        else:
            for name in self.input_names:
                try:
                    self.training_inputs[name] = {
                        title for title in metamodel.options['train:' + str(name)]}
                    self.meta_model.add_input(
                        name, 0.,
                        training_data=[
                            title for title in metamodel.options['train:' + str(name)]])
                except TypeError:
                    msg = "No training data present for one or more parameters"
                    raise TypeError(msg)

            for name in self.output_names:
                self.meta_model.add_output(
                    name, 0.,
                    training_data=[
                        title for title in metamodel.options['train:' + str(name)]])

        # Add the subsystem and setup
        self.prob.model.add_subsystem('interp', self.meta_model)
        self.prob.setup()

    def _slider_attrs(self):
        """
        Assign data to slider objects and callback functions.

        Parameters
        ----------
        None

        """
        for name, slider_object in self.slider_dict.items():
            # Checks if there is a callback previously assigned and then clears it
            if len(slider_object._callbacks) == 1:
                slider_object._callbacks.clear()

            # Check if the name matches the 'x input' title
            if name == self.x_input_select.value:
                # Set the object and add an event handler
                self.x_input_slider = slider_object
                self.x_input_slider.on_change('value', self._scatter_plots_update)

            # Check if the name matches the 'y input' title
            elif name == self.y_input_select.value:
                # Set the object and add an event handler
                self.y_input_slider = slider_object
                self.y_input_slider.on_change('value', self._scatter_plots_update)
            else:
                # If it is not an x or y input then just assign it the event handler
                slider_object.on_change('value', self._update)

    def _make_predictions(self, data):
        """
        Run the data parameter through the surrogate model which is given in prob.

        Parameters
        ----------
        data : dict
            Dictionary containing training points.

        Returns
        -------
        array
            np.stack of predicted points.
        """
        # Create dictionary with an empty list
        outputs = {name: [] for name in self.output_names}

        # Parse dict into shape [n**2, number of inputs] list
        inputs = np.empty([self.resolution**2, self.num_inputs])
        for idx, values in enumerate(data.values()):
            inputs[:, idx] = values.flatten()

        # Check for structured or unstructured
        if self.is_structured_meta_model:
            # Assign each row of the data coming in to a tuple. Loop through the tuple, and append
            # the name of the input and value.
            for idx, tup in enumerate(inputs):
                for name, val in zip(data.keys(), tup):
                    self.prob[self.meta_model.name + '.' + name] = val
                self.prob.run_model()
                # Append the predicted value(s)
                for title in self.output_names:
                    outputs[title].append(
                        np.array(self.prob[self.meta_model.name + '.' + title]))

        else:
            for idx, tup in enumerate(inputs):
                for name, val in zip(data.keys(), tup):
                    self.prob[self.meta_model.name + '.' + name] = val
                self.prob.run_model()
                for title in self.output_names:
                    outputs[title].append(
                        float(self.prob[self.meta_model.name + '.' + title]))

        return stack_outputs(outputs)

    def _contour_data_calcs(self):
        """
        Parse input data into a dictionary to be predicted at.

        Parameters
        ----------
        None

        Returns
        -------
        dict
            Dictionary of training data to be predicted at.
        """
        # Create initial data array of training points
        resolution = self.resolution
        x_data = np.zeros((resolution, resolution, self.num_inputs))

        self._slider_attrs()

        # Broadcast the inputs to every row of x_data array
        x_data[:, :, :] = np.array(self.input_point_list)

        # Find the x/y input titles and match their index positions
        for idx, (title, values) in enumerate(self.slider_source.data.items()):
            if title == self.x_input_select.value:
                self.xlins_mesh = values
                x_index_position = idx
            if title == self.y_input_select.value:
                self.ylins_mesh = values
                y_index_position = idx

        # Make meshgrid from the x/y inputs to be plotted
        X, Y = np.meshgrid(self.xlins_mesh, self.ylins_mesh)
        # Move the x/y inputs to their respective positions in x_data
        x_data[:, :, x_index_position] = X
        x_data[:, :, y_index_position] = Y

        pred_dict = {}
        for idx, title in enumerate(self.slider_source.data):
            pred_dict.update({title: x_data[:, :, idx]})

        return pred_dict

    def _contour_data(self):
        """
        Create a contour plot.

        Parameters
        ----------
        None

        Returns
        -------
        Bokeh Image Plot
        """
        resolution = self.resolution
        # Output data array initialization
        y_data = np.zeros((resolution, resolution, self.num_outputs))
        self.input_point_list = [point.value for point in self.slider_dict.values()]

        # Pass the dict to make predictions and then reshape the output to
        # (resolution, resolution, number of outputs)
        y_data[:, :, :] = self._make_predictions(self._contour_data_calcs()).reshape(
            (resolution, resolution, self.num_outputs))
        # Use the output variable to pull the correct column of data from the predicted
        # data (y_data)
        self.Z = y_data[:, :, self.output_variable]
        # Reshape it to be 2D
        self.Z = self.Z.reshape(resolution, resolution)

        # Update the data source with new data
        self.contour_plot_source.data = dict(z=[self.Z])

        # Min to max of training data
        self.contour_x_range = xlins = self.xlins_mesh
        self.contour_y_range = ylins = self.ylins_mesh

        # Color bar formatting
        color_mapper = LinearColorMapper(
            palette="Viridis11", low=np.amin(self.Z), high=np.amax(self.Z))
        color_bar = ColorBar(color_mapper=color_mapper, ticker=BasicTicker(), label_standoff=12,
                             location=(0, 0))

        # Contour Plot
        self.contour_plot = contour_plot = figure(
            match_aspect=False,
            tooltips=[(self.x_input_select.value, "$x"), (self.y_input_select.value, "$y"),
                      (self.output_select.value, "@z")], tools='')
        contour_plot.x_range.range_padding = 0
        contour_plot.y_range.range_padding = 0
        contour_plot.plot_width = 600
        contour_plot.plot_height = 500
        contour_plot.xaxis.axis_label = self.x_input_select.value
        contour_plot.yaxis.axis_label = self.y_input_select.value
        contour_plot.min_border_left = 0
        contour_plot.add_layout(color_bar, 'right')
        contour_plot.x_range = Range1d(min(xlins), max(xlins))
        contour_plot.y_range = Range1d(min(ylins), max(ylins))
        contour_plot.image(image='z', source=self.contour_plot_source, x=min(xlins), y=min(ylins),
                           dh=(max(ylins) - min(ylins)), dw=(max(xlins) - min(xlins)),
                           palette="Viridis11")

        # Adding training data points overlay to contour plot
        if self.is_structured_meta_model:
            data = self._structured_training_points()
        else:
            data = self._unstructured_training_points()

        if len(data):
            # Add training data points overlay to contour plot
            data = np.array(data)
            if self.is_structured_meta_model:
                self.contour_training_data_source.data = dict(x=data[:, 0], y=data[:, 1],
                                                              z=self.meta_model.training_outputs[
                                                              self.output_select.value].flatten())
            else:
                self.contour_training_data_source.data = dict(x=data[:, 0], y=data[:, 1],
                                                              z=self.meta_model._training_output[
                                                              self.output_select.value])

            training_data_renderer = self.contour_plot.circle(
                x='x', y='y', source=self.contour_training_data_source,
                size=5, color='white', alpha=0.50)

            self.contour_plot.add_tools(HoverTool(renderers=[training_data_renderer], tooltips=[
                (self.x_input_select.value + " (train)", '@x'),
                (self.y_input_select.value + " (train)", '@y'),
                (self.output_select.value + " (train)", '@z'), ]))

        return self.contour_plot

    def _right_plot(self):
        """
        Create the right side subplot to view the projected slice.

        Parameters
        ----------
        None

        Returns
        -------
        Bokeh figure
        """
        # List of the current positions of the sliders
        self.input_point_list = [point.value for point in self.slider_dict.values()]

        # Find the title of the y input and match it with the data
        y_idx = self.y_input_select.value
        y_data = self.predict_inputs[y_idx]
        # Find the position of the x_input slider
        x_value = self.x_input_slider.value

        # Rounds the x_data to match the predict_inputs value
        subplot_value_index = np.where(
            np.around(self.predict_inputs[self.x_input_select.value], 5) ==
            np.around(x_value, 5))[0]

        # Make slice in Z data at the point calculated before and add it to the data source
        z_data = self.Z[:, subplot_value_index].flatten()

        x = z_data
        y = self.slider_source.data[y_idx]

        # Update the data source with new data
        self.right_plot_source.data = dict(x=x, y=y)

        # Create and format figure
        self.right_plot_fig = right_plot_fig = figure(
            plot_width=250, plot_height=500,
            title="{} vs {}".format(y_idx, self.output_select.value), tools="pan")
        right_plot_fig.xaxis.axis_label = self.output_select.value
        right_plot_fig.yaxis.axis_label = y_idx
        right_plot_fig.xaxis.major_label_orientation = math.pi / 9
        right_plot_fig.line(x='x', y='y', source=self.right_plot_source)
        right_plot_fig.x_range.range_padding = 0.1
        right_plot_fig.y_range.range_padding = 0.02

        # Determine distance and alpha opacity of training points
        if self.is_structured_meta_model:
            data = self._structured_training_points(compute_distance=True, source='right')
        else:
            data = self._unstructured_training_points(compute_distance=True, source='right')

        self.right_alphas = 1.0 - data[:, 2] / self.dist_range

        # Training data scatter plot
        scatter_renderer = right_plot_fig.scatter(x=data[:, 3], y=data[:, 1], line_color=None,
                                                  fill_color='#000000',
                                                  fill_alpha=self.right_alphas.tolist())

        right_plot_fig.add_tools(HoverTool(renderers=[scatter_renderer], tooltips=[
            (self.output_select.value + " (train)", '@x'),
            (y_idx + " (train)", '@y'),
        ]))
        right_plot_fig.scatter(x=data[:, 3], y=data[:, 1], line_color=None, fill_color='#000000',
                               fill_alpha=self.right_alphas.tolist())

        span_width = self.dist_range * (max(y_data) - min(y_data))

        # Set the right_plot data source to new values
        self.right_plot_scatter_source.data = dict(
            right_slice_x=np.repeat(x_value, self.resolution), right_slice_y=y_data,
            left_dashed=[i - span_width for i in np.repeat(x_value, self.resolution)],
            right_dashed=[i + span_width for i in np.repeat(x_value, self.resolution)])

        self.contour_plot.line(
            'right_slice_x', 'right_slice_y', source=self.right_plot_scatter_source,
            color='black', line_width=2)
        self.contour_plot.line(
            'left_dashed', 'right_slice_y', line_dash='dashed',
            source=self.right_plot_scatter_source, color='black', line_width=2)
        self.contour_plot.line(
            'right_dashed', 'right_slice_y', line_dash='dashed',
            source=self.right_plot_scatter_source, color='black', line_width=2)

        return self.right_plot_fig

    def _bottom_plot(self):
        """
        Create the bottom subplot to view the projected slice.

        Parameters
        ----------
        None

        Returns
        -------
        Bokeh figure
        """
        # List of the current positions of the sliders
        self.input_point_list = [point.value for point in self.slider_dict.values()]

        # Find the title of the x input and match it with the data
        x_idx = self.x_input_select.value
        x_data = self.predict_inputs[x_idx]
        # Find the position of the y_input slider
        y_value = self.y_input_slider.value

        # Rounds the y_data to match the predict_inputs value
        subplot_value_index = np.where(
            np.around(self.predict_inputs[self.y_input_select.value], 5) ==
            np.around(y_value, 5))[0]

        # Make slice in Z data at the point calculated before and add it to the data source
        z_data = self.Z[subplot_value_index, :].flatten()

        x = self.slider_source.data[x_idx]
        y = z_data

        # Update the data source with new data
        self.bottom_plot_source.data = dict(x=x, y=y)

        # Create and format figure
        self.bottom_plot_fig = bottom_plot_fig = figure(
            plot_width=550, plot_height=250,
            title="{} vs {}".format(x_idx, self.output_select.value), tools="")
        bottom_plot_fig.xaxis.axis_label = x_idx
        bottom_plot_fig.yaxis.axis_label = self.output_select.value
        bottom_plot_fig.line(x='x', y='y', source=self.bottom_plot_source)
        bottom_plot_fig.x_range.range_padding = 0.02
        bottom_plot_fig.y_range.range_padding = 0.1

        # Determine distance and alpha opacity of training points
        if self.is_structured_meta_model:
            data = self._structured_training_points(compute_distance=True)
        else:
            data = self._unstructured_training_points(compute_distance=True)

        self.bottom_alphas = 1.0 - data[:, 2] / self.dist_range

        # Training data scatter plot
        scatter_renderer = bottom_plot_fig.scatter(x=data[:, 0], y=data[:, 3], line_color=None,
                                                   fill_color='#000000',
                                                   fill_alpha=self.bottom_alphas.tolist())

        bottom_plot_fig.add_tools(HoverTool(renderers=[scatter_renderer], tooltips=[
            (x_idx + " (train)", '@x'),
            (self.output_select.value + " (train)", '@y'),
        ]))

        span_width = self.dist_range * (max(x_data) - min(x_data))

        # Set the right_plot data source to new values
        self.bottom_plot_scatter_source.data = dict(
            bot_slice_x=x_data, bot_slice_y=np.repeat(y_value, self.resolution),
            upper_dashed=[i + span_width for i in np.repeat(y_value, self.resolution)],
            lower_dashed=[i - span_width for i in np.repeat(y_value, self.resolution)])

        self.contour_plot.line(
            'bot_slice_x', 'bot_slice_y', source=self.bottom_plot_scatter_source, color='black',
            line_width=2)
        self.contour_plot.line(
            'bot_slice_x', 'upper_dashed', line_dash='dashed',
            source=self.bottom_plot_scatter_source, color='black', line_width=2)
        self.contour_plot.line(
            'bot_slice_x', 'lower_dashed', line_dash='dashed',
            source=self.bottom_plot_scatter_source, color='black', line_width=2)

        return self.bottom_plot_fig

    def _unstructured_training_points(self, compute_distance=False, source='bottom'):
        """
        Calculate the training points and returns and array containing the position and alpha.

        Parameters
        ----------
        compute_distance : bool
            If true, compute the distance of training points from surrogate line.
        source : str
            Which subplot the method is being called from.

        Returns
        -------
        array
            The array of training points and their alpha opacity with respect to the surrogate line
        """
        # Input training data and output training data
        x_training = self.meta_model._training_input
        training_output = np.squeeze(stack_outputs(self.meta_model._training_output), axis=1)

        # Index of input/output variables
        x_index = self.x_input_select.options.index(self.x_input_select.value)
        y_index = self.y_input_select.options.index(self.y_input_select.value)
        output_variable = self.output_names.index(self.output_select.value)

        # Vertically stack the x/y inputs and then transpose them
        infos = np.vstack((x_training[:, x_index], x_training[:, y_index])).transpose()
        if not compute_distance:
            return infos

        points = x_training.copy()

        # Normalize so each dimension spans [0, 1]
        points = np.divide(points, self.limit_range)
        dist_limit = np.linalg.norm(self.dist_range * self.limit_range)
        scaled_x0 = np.divide(self.input_point_list, self.limit_range)

        # Query the nearest neighbors tree for the closest points to the scaled x0 array
        # Nearest points to x slice
        if x_training.shape[1] < 3:

            tree = cKDTree(points)
            # Query the nearest neighbors tree for the closest points to the scaled x0 array
            dists, idxs = tree.query(
                scaled_x0, k=len(x_training), distance_upper_bound=self.dist_range)

            # kdtree query always returns requested k even if there are not enough valid points
            idx_finite = np.where(np.isfinite(dists))
            dists = dists[idx_finite]
            idxs = idxs[idx_finite]

        else:
            dists, idxs = self._multidimension_input(scaled_x0, points, source=source)

        # data contains:
        # [x_value, y_value, ND-distance, func_value]

        data = np.zeros((len(idxs), 4))
        for dist_index, j in enumerate(idxs):
            data[dist_index, 0:2] = infos[j, :]
            data[dist_index, 2] = dists[dist_index]
            data[dist_index, 3] = training_output[j, output_variable]

        return data

    def _structured_training_points(self, compute_distance=False, source='bottom'):
        """
        Calculate the training points and return an array containing the position and alpha.

        Parameters
        ----------
        compute_distance : bool
            If true, compute the distance of training points from surrogate line.
        source : str
            Which subplot the method is being called from.

        Returns
        -------
        array
            The array of training points and their alpha opacity with respect to the surrogate line
        """
        # Create tuple of the input parameters
        input_dimensions = tuple(self.meta_model.inputs)

        # Input training data and output training data
        x_training = np.array([z for z in product(*input_dimensions)])
        training_output = self.meta_model.training_outputs[self.output_select.value].flatten()

        # Index of input/output variables
        x_index = self.x_input_select.options.index(self.x_input_select.value)
        y_index = self.y_input_select.options.index(self.y_input_select.value)

        # Vertically stack the x/y inputs and then transpose them
        infos = np.vstack((x_training[:, x_index], x_training[:, y_index])).transpose()
        if not compute_distance:
            return infos

        points = x_training.copy()

        # Normalize so each dimension spans [0, 1]
        points = np.divide(points, self.limit_range)
        self.dist_limit = np.linalg.norm(self.dist_range * self.limit_range)
        scaled_x0 = np.divide(self.input_point_list, self.limit_range)
        # Query the nearest neighbors tree for the closest points to the scaled x0 array
        # Nearest points to x slice

        if x_training.shape[1] < 3:
            x_tree, x_idx = self._two_dimension_input(scaled_x0, points, source=source)
        else:
            x_tree, x_idx = self._multidimension_input(scaled_x0, points, source=source)

        # format for 'data'
        # [x_value, y_value, ND-distance_(x or y), func_value]

        n = len(x_tree)
        data = np.zeros((n, 4))
        for dist_index, j in enumerate(x_idx):
            data[dist_index, 0:2] = infos[j, :]
            data[dist_index, 2] = x_tree[dist_index]
            data[dist_index, 3] = training_output[j]

        return data

    def _two_dimension_input(self, scaled_points, training_points, source='bottom'):
        """
        Calculate the distance of training points to the surrogate line.

        Parameters
        ----------
        scaled_points : array
            Array of normalized slider positions.
        training_points : array
            Array of input training data.
        source : str
            Which subplot the method is being called from.

        Returns
        -------
        idxs : array
            Index of closest points that are within the dist range.
        x_tree : array
            One dimentional array of points that are within the dist range.
        """
        # Column of the input
        if source == 'right':
            col_idx = self.y_input_select.options.index(self.y_input_select.value)
        else:
            col_idx = self.x_input_select.options.index(self.x_input_select.value)

        # Delete the axis of input from source to predicted 1D distance
        x = np.delete(scaled_points, col_idx, axis=0)
        x_training_points = np.delete(training_points, col_idx, axis=1).flatten()

        # Tree of point distances
        x_tree = np.abs(x - x_training_points)

        # Only return points that are within our distance-viewing paramter.
        idx = np.where(x_tree <= self.dist_range)
        x_tree = x_tree[idx]
        return x_tree, idx[0]

    def _multidimension_input(self, scaled_points, training_points, source='bottom'):
        """
        Calculate the distance of training points to the surrogate line.

        Parameters
        ----------
        scaled_points : array
            Array of normalized slider positions.
        training_points : array
            Array of input training data.
        source : str
            Which subplot the method is being called from.

        Returns
        -------
        idxs : array
            Index of closest points that are within the dist range.
        x_tree : array
            Array of points that are within the dist range.
        """
        # Column of the input
        if source == 'right':
            col_idx = self.y_input_select.options.index(self.y_input_select.value)

        else:
            col_idx = self.x_input_select.options.index(self.x_input_select.value)

        # Delete the axis of input from source to predicted distance
        x = np.delete(scaled_points, col_idx, axis=0)
        x_training_points = np.delete(training_points, col_idx, axis=1)

        # Tree of point distances
        x_tree = cKDTree(x_training_points)

        # Query the nearest neighbors tree for the closest points to the scaled array
        dists, idx = x_tree.query(x, k=len(x_training_points),
                                  distance_upper_bound=self.dist_range)

        # kdtree query always returns requested k even if there are not enough valid points
        idx_finite = np.where(np.isfinite(dists))
        dists_finite = dists[idx_finite]
        idx = idx[idx_finite]
        return dists_finite, idx

    # Event handler functions
    def _update_all_plots(self):
        self.doc_layout.children[0] = self._contour_data()
        self.doc_layout.children[1] = self._right_plot()
        self.doc_layout2.children[0] = self._bottom_plot()

    def _update_subplots(self):
        self.doc_layout.children[1] = self._right_plot()
        self.doc_layout2.children[0] = self._bottom_plot()

    def _update(self, attr, old, new):
        self._update_all_plots()

    def _scatter_plots_update(self, attr, old, new):
        self._update_subplots()

    def _scatter_input(self, attr, old, new):
        # Text input update function of dist range value
        self.dist_range = float(new)
        self._update_all_plots()

    def _x_input_update(self, attr, old, new):
        # Checks that x and y inputs are not equal to each other
        if new == self.y_input_select.value:
            raise ValueError("Inputs should not equal each other")
        else:
            self.x_input_select.value = new
            self._update_all_plots()

    def _y_input_update(self, attr, old, new):
        # Checks that x and y inputs are not equal to each other
        if new == self.x_input_select.value:
            raise ValueError("Inputs should not equal each other")
        else:
            self.y_input_select.value = new
            self._update_all_plots()

    def _output_value_update(self, attr, old, new):
        self.output_variable = self.output_names.index(new)
        self._update_all_plots()
Example #52
0
class Market():
    ###########################################################################
    # PLOT WIDGET
    ###########################################################################
    # +----------------------------+
    # | +-----------+ +----------+ |
    # | | start_btn | | end_btn  | |
    # | +-----------+ +----------+ |
    # +----------------------------+
    # |                            |
    # |          plot              |
    # |                            |
    # +----------------------------+
    ###########################################################################

    def __init__(self,
                 start=(date.today() - relativedelta(years=3)),
                 end=date.today()):
        self.start = str(start)
        self.end = str(end)
        self.sp500 = core.market.SP500('dataset/tickers.h5')
        symbols = self.sp500.store['info']['symbol'].values.tolist()
        # log.info("{}".format(symbols))
        # Select tick button
        title = "Company tick"
        self.select_tick = Select(title=title,
                                  value=symbols[0],
                                  options=symbols)
        # Inputs buttons
        self.start_date = TextInput(value=self.start, title='start')
        self.end_date = TextInput(value=self.end, title='end')
        # layout
        self.plot_layout = self.candle_plot(symbols[0])

        self.start_date.on_change('value', self.on_start_date_change)
        self.end_date.on_change('value', self.on_end_date_change)
        self.select_tick.on_change('value', self.on_tick_selection_change)
        self.layout = layout(
            [[self.select_tick, self.start_date, self.end_date],
             [self.plot_layout]])

    def candle_plot(self, ticker, index_name='date'):
        self.df = self.sp500.get_ticker_stocks(ticker, self.start, self.end)
        self.df = plot.normalize_name(self.df)
        self.df = self.df.set_index(index_name)
        index = self.df.index.get_level_values(index_name)
        stock_data = {index_name: index}

        for val in self.df.columns.values:
            stock_data[val] = self.df[val]
        # log.info(stock_data)

        source = ColumnDataSource(data=dict(stock_data))
        hover = HoverTool(tooltips=[('date', '@date{%F}'),
                                    ('adj close', '$@adj_close{%0.2f}'),
                                    ('adj open', '$@adj_open{%0.2f}'),
                                    ('volume', '@volume{0.00 a}'),
                                    ('open', '@open{%0.2f}'),
                                    ('close', '@close{%0.2f}')],
                          formatters={
                              'date': 'datetime',
                              'adj_close': 'printf',
                              'adj_open': 'printf',
                              'open': 'printf',
                              'close': 'printf'
                          },
                          mode='vline')
        inc = self.df['close'] > self.df['open']
        dec = self.df['open'] > self.df['close']
        w = 12 * 60 * 60 * 1000  # half day in ms
        p = figure(x_axis_type="datetime",
                   plot_width=1600,
                   title=ticker,
                   tools="xwheel_zoom, xpan, reset, save",
                   active_drag="xpan")

        p.add_tools(hover)
        p.toolbar.logo = None
        p.grid.grid_line_alpha = 0.3
        p.xaxis.major_label_orientation = pi / 4
        p.xaxis.axis_label = 'Date'
        p.yaxis.axis_label = 'Price'

        p.line(index_name, 'adj_close', color='#A6CEE3', source=source)
        p.line(index_name, 'adj_open', color='#FB9A99', source=source)
        p.segment(index_name,
                  'high',
                  index_name,
                  'low',
                  color="white",
                  source=source)
        p.vbar(index[inc],
               w,
               self.df['open'][inc],
               self.df['close'][inc],
               fill_color="#D5E1DD",
               line_color="white")
        p.vbar(index[dec],
               w,
               self.df['open'][dec],
               self.df['close'][dec],
               fill_color="#F2583E",
               line_color="white")
        p.legend.location = "top_left"
        p.background_fill_color = "black"
        columns = [
            TableColumn(field="date", title="date", formatter=DateFormatter())
        ]
        for key in stock_data.keys():
            if key != 'date':
                columns.append(TableColumn(field=key, title=key))

        # Layout
        return column(p, DataTable(source=source, columns=columns, width=1600))

    # Callbacks
    def on_tick_selection_change(self, attr, old, new):
        log.debug('VALUE: old {} | new {}'.format(old, new))
        self.layout.children[1] = self.candle_plot(new)

    def on_start_date_change(self, attr, old, new):
        log.debug('VALUE: old {} | new {}'.format(old, new))
        self.start = new
        self.layout.children[1] = self.candle_plot(self.select_tick.value)

    def on_end_date_change(self, attr, old, new):
        log.debug('VALUE: old {} | new {}'.format(old, new))
        self.end = new
        self.layout.children[1] = self.candle_plot(self.select_tick.value)
Example #53
0
def Mosaic_Plot(clone_df,
                png=None,
                title="",
                top_clones=5000,
                count_col="Clustered",
                vgene_col="VGene",
                jgene_col="JGene",
                isotype_col="Isotype",
                vshm_col="V_SHM",
                jshm_col="J_SHM",
                vgene_colors=vgene_colors,
                vfamily_colors=vfamily_colors,
                jgene_colors=jgene_colors,
                isotype_colors=isotype_colors,
                line_width=0.3,
                figsize=(600, 600),
                hover_tooltip=True):
    figure_params = {
        "plot_width": figsize[0],
        "plot_height": figsize[1],
        #"sizing_mode": "scale_both",
        "x_range": Range1d(-0.1, 1.1, bounds=(-1.0, 2.0)),
        "y_range": Range1d(-0.1, 1.1, bounds=(-1.0, 2.0)),
        #"outline_line_alpha": 0.0,
        "title": title,
        "tools": "pan, wheel_zoom, box_zoom, save, reset, help",
        "active_scroll": "wheel_zoom",
        "toolbar_location": "right"
    }

    plot = figure(**figure_params)
    plot.grid.visible = False
    plot.axis.visible = False

    hover_tooltips = [("Clone ID", "@CloneID")]

    info_cols = [count_col]
    if vgene_col is not None:
        info_cols.append(vgene_col)
        hover_tooltips.append(("V Gene", "@" + vgene_col))
    if jgene_col is not None:
        info_cols.append(jgene_col)
        hover_tooltips.append(("J Gene", "@" + jgene_col))
    if isotype_col is not None:
        info_cols.append(isotype_col)
        hover_tooltips.append(("Isotype", "@" + isotype_col))
    if vshm_col is not None:
        info_cols.append(vshm_col)
        hover_tooltips.append(("V Gene SHM", "@" + vshm_col + "{(0.00%)}"))
    if jshm_col is not None:
        info_cols.append(jshm_col)
        hover_tooltips.append(("J Gene SHM", "@" + jshm_col + "{(0.00%)}"))

    if hover_tooltip:
        hover_tool = HoverTool(point_policy="snap_to_data",
                               tooltips=hover_tooltips)
        plot.add_tools(hover_tool)

    mosaic_df = clone_df[info_cols]
    mosaic_df = mosaic_df.sort_values([count_col], ascending=[False])

    if top_clones:
        mosaic_df = mosaic_df.head(top_clones)

    total_area = float(mosaic_df[count_col].sum())
    mosaic_df["Clone_Frequencies"] = mosaic_df[count_col].astype(
        float) / total_area

    hover_tooltips.append(("Clone Frequency", "@Clone_Frequencies{(0.00%)}"))

    mosaic_rects = squarify(mosaic_df["Clone_Frequencies"].tolist(), 0.0, 0.0,
                            1.0, 1.0)
    #Add half width/height to x/y position for center points
    mosaic_df["x"] = [rect["x"] + rect["dx"] / 2.0 for rect in mosaic_rects]
    mosaic_df["y"] = [rect["y"] + rect["dy"] / 2.0 for rect in mosaic_rects]
    mosaic_df["width"] = [rect["dx"] for rect in mosaic_rects]
    mosaic_df["height"] = [rect["dy"] for rect in mosaic_rects]

    #By default there is no legend text, since colors are alternating and non-informative
    mosaic_df["legend"] = ""
    mosaic_df["Empty_Legend"] = ""

    alternating_colors = [
        RGB(102, 194, 165),
        RGB(252, 141, 98),
        RGB(141, 160, 203)
    ]
    alt2_color_cycle = cycle(alternating_colors[0:2])
    alt3_color_cycle = cycle(alternating_colors)
    mosaic_df["alternating2_colors"] = [
        next(alt2_color_cycle) for _ in mosaic_rects
    ]
    mosaic_df["alternating3_colors"] = [
        next(alt3_color_cycle) for _ in mosaic_rects
    ]
    #Default color scheme is alternating 3 colors
    mosaic_df["fill_color"] = mosaic_df["alternating3_colors"]

    #Set up various mosaic coloring options and associated legends
    color_select_options = ["Alternating (2)", "Alternating (3)"]
    if vgene_col in mosaic_df.columns:
        mosaic_df["vgene_colors"] = mosaic_df[vgene_col].map(vgene_colors)
        vfamilies = mosaic_df[vgene_col].str.split("-").str[0]
        mosaic_df["vfamily_colors"] = vfamilies.map(vfamily_colors)
        color_select_options.append("V Gene")
        color_select_options.append("V Family")
        mosaic_df["VGene_Legend"] = mosaic_df[vgene_col]
        mosaic_df["VFamily_Legend"] = mosaic_df[vgene_col].str.split(
            "-").str[0]
    if jgene_col in mosaic_df.columns:
        mosaic_df["jgene_colors"] = mosaic_df[jgene_col].map(jgene_colors)
        color_select_options.append("J Gene")
        mosaic_df["JGene_Legend"] = mosaic_df[jgene_col]
    if isotype_col in mosaic_df.columns:
        mosaic_df["isotype_colors"] = mosaic_df[isotype_col].map(
            isotype_colors)
        color_select_options.append("Isotype")
        mosaic_df["Isotype_Legend"] = mosaic_df[isotype_col]

    #Using viridis as a quantitative heatmap color scheme for SHM values
    #The SHM values are binned into 180 groups; viridis in >180 bins uses some values twice, which pandas.cut can't use
    shm_viridis = list(viridis(180))
    colorbar_tick_formatter = NumeralTickFormatter(format="0.00%")

    if vshm_col in mosaic_df.columns:
        vshm_min = mosaic_df[vshm_col].min()
        vshm_max = mosaic_df[vshm_col].max()
        #Use pandas.cut to bin the V gene SHM values into the heatmap colors
        mosaic_df["vshm_colors"] = pandas.cut(mosaic_df[vshm_col],
                                              bins=180,
                                              labels=shm_viridis)
        color_select_options.append("V Gene SHM")

        vshm_color_mapper = LinearColorMapper(palette=shm_viridis,
                                              low=vshm_min,
                                              high=vshm_max)
        vshm_ticks = FixedTicker(ticks=numpy.linspace(vshm_min, vshm_max, 8))
        vshm_colorbar = ColorBar(color_mapper=vshm_color_mapper,
                                 location=(0, 0),
                                 name="vshm_colorbar",
                                 label_standoff=12,
                                 formatter=colorbar_tick_formatter,
                                 ticker=vshm_ticks)
        plot.add_layout(vshm_colorbar, "right")

    if jshm_col in mosaic_df.columns:
        jshm_min = mosaic_df[jshm_col].min()
        jshm_max = mosaic_df[jshm_col].max()
        #Use pandas.cut to bin the J gene SHM values into the heatmap colors
        mosaic_df["jshm_colors"] = pandas.cut(mosaic_df[jshm_col],
                                              bins=180,
                                              labels=shm_viridis)
        color_select_options.append("J Gene SHM")

        jshm_color_mapper = LinearColorMapper(palette=shm_viridis,
                                              low=jshm_min,
                                              high=jshm_max)
        jshm_ticks = FixedTicker(ticks=numpy.linspace(jshm_min, jshm_max, 8))
        jshm_colorbar = ColorBar(color_mapper=jshm_color_mapper,
                                 location=(0, 0),
                                 name="jshm_colorbar",
                                 label_standoff=12,
                                 formatter=colorbar_tick_formatter,
                                 ticker=jshm_ticks)
        plot.add_layout(jshm_colorbar, "right")

    mosaic_source = ColumnDataSource(mosaic_df)

    plot.rect(x="x",
              y="y",
              width="width",
              height="height",
              fill_color="fill_color",
              legend="legend",
              line_color="black",
              line_width=line_width,
              source=mosaic_source)

    #By default, the plot legend and ColorBar should be turned off (since the color is repeating and uninformative)
    plot.legend[0].visible = False
    vshm_colorbar = plot.select("vshm_colorbar")[0]
    jshm_colorbar = plot.select("jshm_colorbar")[0]
    vshm_colorbar.visible = False
    jshm_colorbar.visible = False

    if png is not None:
        export_png(plot, png)

    change_args = {
        "source": mosaic_source,
        "legend_obj": plot.legend[0],
        "vshm_colorbar_obj": vshm_colorbar,
        "jshm_colorbar_obj": jshm_colorbar
    }
    change_rect_color = CustomJS(args=change_args,
                                 code="""
		var selection = cb_obj.value.toLowerCase();
		var new_color_array;
		var new_legend_array;

		if(selection.indexOf("v gene shm") !== -1) {
			new_color_array = source.data["vshm_colors"];
			new_legend_array = source.data["Empty_Legend"];
			legend_obj.visible = false;
			vshm_colorbar_obj.visible = true;
			jshm_colorbar_obj.visible = false;
		} else if(selection.indexOf("j gene shm") !== -1) {
			new_color_array = source.data["jshm_colors"];
			new_legend_array = source.data["Empty_Legend"];
			legend_obj.visible = false;
			vshm_colorbar_obj.visible = false;
			jshm_colorbar_obj.visible = true;
		} else if(selection.indexOf("v gene") !== -1) {
			new_color_array = source.data["vgene_colors"];
			new_legend_array = source.data["VGene_Legend"];
			legend_obj.visible = true;
			vshm_colorbar_obj.visible = false;
			jshm_colorbar_obj.visible = false;
		} else if(selection.indexOf("v family") !== -1) {
			new_color_array = source.data["vfamily_colors"];
			new_legend_array = source.data["VFamily_Legend"];
			legend_obj.visible = true;
			vshm_colorbar_obj.visible = false;
			jshm_colorbar_obj.visible = false;
		} else if(selection.indexOf("j gene") !== -1) {
			new_color_array = source.data["jgene_colors"];
			new_legend_array = source.data["JGene_Legend"];
			legend_obj.visible = true;
			vshm_colorbar_obj.visible = false;
			jshm_colorbar_obj.visible = false;
		} else if(selection.indexOf("isotype") !== -1) {
			new_color_array = source.data["isotype_colors"];
			new_legend_array = source.data["Isotype_Legend"];
			legend_obj.visible = true;
			vshm_colorbar_obj.visible = false;
			jshm_colorbar_obj.visible = false;
		} else if(selection.indexOf("2") !== -1) {
			new_color_array = source.data["alternating2_colors"];
			new_legend_array = source.data["Empty_Legend"];
			legend_obj.visible = false;
			vshm_colorbar_obj.visible = false;
			jshm_colorbar_obj.visible = false;
		} else {
			new_color_array = source.data["alternating3_colors"];
			new_legend_array = source.data["Empty_Legend"];
			legend_obj.visible = false;
			vshm_colorbar_obj.visible = false;
			jshm_colorbar_obj.visible = false;
		}

		var fill_color = source.data["fill_color"];
		var legend = source.data["legend"];
		for(idx = 0; idx < fill_color.length; idx++) {
			fill_color[idx] = new_color_array[idx];
			legend[idx] = new_legend_array[idx];
		}
		source.change.emit();
	""")

    patch_coloring_select = Select(title="Color by:",
                                   options=color_select_options,
                                   value="Alternating (3)",
                                   callback=change_rect_color)

    plot_layout = column(patch_coloring_select, plot)

    return plot_layout
Example #54
0
    message += '<br>The image will be taken between %02d:%02d and %02d:%02d local time on December %dth'%(t0.hour, t0.minute, t1.hour, t1.minute, t1.day)
    message += '<br>We hope you\'ll join us in waving to Kepler!'
    messages.append([message])

print('Saving Results')
cities['message'] = messages

results = ColumnDataSource(cities.set_index('name').to_dict()['message'])

args = dict(results=results)
update = CustomJS(args=args, code="""
   par.text = results.data[select.value][0];
""")

p = Div(text=results.data['New York, USA'][0], width=400, height=100)
select = Select(title='Nearest City:', value='New York, USA', options=sorted(cities['name'].values), callback=update)
update.args['par'] = p
update.args['select'] = select
layout = column([select, p])
script, div = components(layout)

name1 = 'web_app.script'
name2 = 'web_app.div'

print('Saving results as components: %s and %s'%(name1, name2))
with open(name1, 'w') as f:
    f.write(script)
    f.write('\n')
    
with open(name2, 'w') as f:
    f.write(div)
Example #55
0
def main():
    df = pd.read_csv("nlp_entities.csv")
    per_df = pd.read_csv("Person.csv")
    pla_df = pd.read_csv("Place.csv")
    org_df = pd.read_csv("Org.csv")

    entities = ["Person", "Place", "Org"]
    relations = [["Person_Org","Person_Place","Person_Person"],["Place_Person","Place_Org","Place_Place"],["Org_Person","Org_Place","Org_Org"]]
    dfs = [per_df, pla_df,org_df]

    button_group = RadioButtonGroup(labels=entities, active=0)
    slider = Slider(title="by Index", value=0, start=0, end=len(per_df.index)-1, step=1)
    text = TextInput(title="by Name:", value='')
    select1 = Select(title="y axis:", value="Person", options=["Person", "Place", "Org"])

    files = per_df.iloc[0]["Documents"]
    d = []
    y_n = []
    headlines = []
    datestr = []
    if files == "None":
        files = []
    else:
        files = ast.literal_eval(files)
        for f in files:
            v_d = df.loc[df["filename"] == f]["date"].values
            datestr.append(v_d[0])
            d.append(datetime.strptime(v_d[0],"%m/%d/%Y"))
            v_p = df.loc[df["filename"] == f]["Person"].values
            y_n.append(len(ast.literal_eval(v_p[0])))
            v_h = df.loc[df["filename"] == f]["headlines"].values
            headlines.append(v_h[0])
    dates = np.array(d)
    n = np.array(y_n)
    headlines = np.array(headlines)
    name = per_df.iloc[0]["Person"]

    # create the timeline plot for the searched entity
    s_source = ColumnDataSource(data=dict(x = dates, y = n, f = files, h =headlines, d = datestr))
    TOOLS = "box_select,pan,box_zoom,reset"
    f1 = figure(tools=TOOLS, plot_width=600, plot_height=450, title="Timeline for '" + name + "'",
                x_axis_type='datetime', x_axis_label='Time', y_range=[-50,250],
                y_axis_label='number in total', output_backend="webgl")
    c1 = f1.circle('x', 'y', source=s_source, size=10, color="red", alpha=0.5)
    hover1 = HoverTool(
        tooltips=[
            ("document: ", "@f"),
            ("date", "@d"),
            ("headline: ", "@h")
        ]
    )
    f1.add_tools(hover1)
    f1.x_range = Range1d(datetime.strptime('01/01/2002',"%m/%d/%Y"),datetime.strptime('12/31/2004',"%m/%d/%Y"))

    def update_y(attr,old,new):
        y = select1.value
        new_y = []
        for f in s_source.data["f"]:
            v = df.loc[df["filename"] == f][y].values
            new_y.append(len(ast.literal_eval(v[0])))
        new_y = np.array(new_y)
        s_source.data["y"] = new_y
        return

    select1.on_change("value",update_y)

    # create interactive network graph for timeline plot
    s1 = ColumnDataSource(data=dict(xs=[], ys=[]))
    s2 = ColumnDataSource(data=dict(vx=[], vy=[], labels=[], color=[]))
    n1 = figure(plot_width=500, plot_height=500, x_axis_type=None, y_axis_type=None,
                outline_line_color=None, tools="pan,box_zoom,reset,save",title="Related Entities of Selected Files",
                output_backend="webgl")
    n1.multi_line('xs', 'ys', line_color="blue", source=s1, alpha=0.3)
    c2 = n1.circle('vx', 'vy', size=20, line_color="black", fill_color='color', source=s2, alpha=0.5)
    n1.text('vx', 'vy', text='labels', text_color="black", text_font_size="10px", text_align="center",
            text_baseline="middle", source=s2)

    # update network graph when the files are selected
    def update_network1(attr, old, new):
        inds = new['1d']['indices']
        nodes = []
        edges = []
        t_t_edges = []
        selected = []
        if inds == []:
            s1.data = dict(xs=[], ys=[])
            s2.data = dict(vx=[], vy=[], labels=[], color=[])
            return
        for i in inds:
            f = s_source.data["f"][i]
            v = df.loc[df["filename"] == f]["all_nodes"].values
            n = ast.literal_eval(v[0])
            selected.append(f)
            nodes = list(set(nodes).union(n))
            e = ast.literal_eval(df.loc[df["filename"] == f]["all_edges"].values[0])
            edges = list(set(edges).union(e))
            t_t_e = ast.literal_eval(df.loc[df["filename"] == f]["file_neighbors_edge"].values[0])
            t_t_edges = list(set(t_t_edges).union(t_t_e))
        t_t = list(itertools.combinations(selected, 2))
        for t in t_t:
            if (t in t_t_edges) or ((t[1],t[0])in t_t_edges):
                edges.append(t)
        new_dict = create_graph(nodes, edges, selected)
        s1.data = new_dict["s1"]
        s2.data = new_dict["s2"]
        return

    c1.data_source.on_change("selected", update_network1)

    # create person-place network graph
    v1 = per_df.at[0, "Person_Place"]
    edges_1 = ast.literal_eval(v1)
    nodes_1 = [name]
    for e in edges_1:
        nodes_1.append(e[1])

    g1 = create_graph(nodes_1,edges_1,[name])
    s3 = ColumnDataSource(data=g1["s1"])
    s4 = ColumnDataSource(data=g1["s2"])
    n2 = figure(plot_width=400, plot_height=400, x_axis_type=None, y_axis_type=None,
                outline_line_color=None, tools="pan,box_zoom,reset,save", title="Person_Place Relationships for Person: " + name,
                output_backend="webgl")
    n2.multi_line('xs', 'ys', line_color="blue", source=s3, alpha=0.3)
    c3 = n2.circle('vx', 'vy', size=20, line_color="black", fill_color='color', source=s4, alpha=0.5)
    n2.text('vx', 'vy', text='labels', text_color="black", text_font_size="8px", text_align="center",
            text_baseline="middle", source=s4)

    # create person-org network graph
    v2 = per_df.at[0, "Person_Org"]
    edges_2 = ast.literal_eval(v2)
    nodes_2 = [name]
    for e in edges_2:
        nodes_2.append(e[1])

    g2 = create_graph(nodes_2, edges_2, [name])
    s5 = ColumnDataSource(data=g2["s1"])
    s6 = ColumnDataSource(data=g2["s2"])
    n3 = figure(plot_width=400, plot_height=400, x_axis_type=None, y_axis_type=None,
                outline_line_color=None, tools="pan,box_zoom,reset,save", title="Person_Org Relationships for Person: " + name,
                output_backend="webgl")
    n3.multi_line('xs', 'ys', line_color="blue", source=s5, alpha=0.3)
    c4 = n3.circle('vx', 'vy', size=20, line_color="black", fill_color='color', source=s6, alpha=0.5)
    n3.text('vx', 'vy', text='labels', text_color="black", text_font_size="8px", text_align="center",
            text_baseline="middle", source=s6)

    # create person-org network graph
    v3 = per_df.at[0, "Person_Person"]
    edges_3 = ast.literal_eval(v3)
    nodes_3 = [name]
    for e in edges_3:
        nodes_3.append(e[1])

    g3 = create_graph(nodes_3, edges_3, [name])
    s7 = ColumnDataSource(data=g3["s1"])
    s8 = ColumnDataSource(data=g3["s2"])
    n4 = figure(plot_width=400, plot_height=400, x_axis_type=None, y_axis_type=None,
                outline_line_color=None, tools="pan,box_zoom,reset,save",
                title="Person_Person Relationships for Person: " + name,
                output_backend="webgl")
    n4.multi_line('xs', 'ys', line_color="blue", source=s7, alpha=0.3)
    c5 = n4.circle('vx', 'vy', size=20, line_color="black", fill_color='color', source=s8, alpha=0.5)
    n4.text('vx', 'vy', text='labels', text_color="black", text_font_size="8px", text_align="center",
            text_baseline="middle", source=s8)


    #update visualizations when button group changes
    def button_group_update(attr, old, new):
        b = button_group.active
        entity = entities[b]
        d = dfs[b]
        t = text.value
        #change slider
        slider.end = len(d.index) - 1
        if (slider.value>slider.end):
            slider.value = slider.end

        if t == '':
            slider_update(attr, old, new)
        else:
            text_update(attr, old, new)

    button_group.on_change("active", button_group_update)

    def slider_update(attr,old,new):
        text.value = ''

        b = button_group.active
        entity = entities[b]
        d = dfs[b]
        s = slider.value

        # clear the visualizations
        sources = [[s1, s2], [s3, s4], [s5, s6], [s7, s8]]
        networks = [n1, n2, n3, n4]
        s_source.data = dict(x=[], y=[], f=[], h=[], d=[])
        for i in range(4):
            sources[i][0].data = dict(xs=[], ys=[])
            sources[i][1].data = dict(vx=[], vy=[], labels=[], color=[])

        name = d.iloc[s][entity]

        # update cooccurence relationships
        for i in range(3):
            v = d.at[s, relations[b][i]]
            edges = ast.literal_eval(v)
            nodes = [name]
            for e in edges:
                nodes.append(e[1])
            g = create_graph(nodes, edges, [name])
            sources[i + 1][0].data = g["s1"]
            sources[i + 1][1].data = g["s2"]
            networks[i + 1].title.text = relations[b][i] + " Relationships for " + entity + ": " + name

        #update timeline plot
        files = d.iloc[s]["Documents"]
        dates = []
        y_n = []
        headlines = []
        datestr = []
        select = select1.value
        if files == "None":
            files = []
            f1.title.text = "No files found for '" + name + "'"
        else:
            files = ast.literal_eval(files)
            for f in files:
                v_d = df.loc[df["filename"] == f]["date"].values
                datestr.append(v_d[0])
                dates.append(datetime.strptime(v_d[0], "%m/%d/%Y"))
                v_p = df.loc[df["filename"] == f][select].values
                y_n.append(len(ast.literal_eval(v_p[0])))
                v_h = df.loc[df["filename"] == f]["headlines"].values
                headlines.append(v_h[0])
        dates = np.array(dates)
        n = np.array(y_n)
        headlines = np.array(headlines)
        s_source.data = dict(x=dates, y=n, f=files, h=headlines, d=datestr)
        f1.title.text = "Timeline for '" + name + "'"
        return

    slider.on_change("value", slider_update)

    def text_update(attr,old,new):
        b = button_group.active
        entity = entities[b]
        print(entity)
        d = dfs[b]
        t = text.value
        slider.value = 0

        # clear the visualizations
        sources = [[s1, s2], [s3, s4], [s5, s6], [s7, s8]]
        networks = [n1, n2, n3, n4]
        s_source.data = dict(x=[], y=[], f=[], h=[], d=[])
        for i in range(4):
            sources[i][0].data = dict(xs=[], ys=[])
            sources[i][1].data = dict(vx=[], vy=[], labels=[], color=[])

        name = t
        if t in np.array(d[entity]):
            s = d[d[entity] == t].index.tolist()[0]
        else:
            f1.title.text = "No such " + entity + " in the datasets"
            for x in networks:
                x.title.text = "No such " + entity + " in the datasets"
            return

        # update cooccurence relationships
        for i in range(3):
            v = d.at[s, relations[b][i]]
            edges = ast.literal_eval(v)
            nodes = [name]
            for e in edges:
                nodes.append(e[1])
            g = create_graph(nodes, edges, [name])
            sources[i + 1][0].data = g["s1"]
            sources[i + 1][1].data = g["s2"]
            networks[i + 1].title.text = relations[b][i] + " Relationships for " + entity + ": " + name

        # update timeline plot
        files = d.iloc[s]["Documents"]
        dates = []
        y_n = []
        headlines = []
        datestr = []
        select = select1.value
        if files == "None":
            files = []
            f1.title.text = "No files found for '" + name + "'"
        else:
            files = ast.literal_eval(files)
            for f in files:
                v_d = df.loc[df["filename"] == f]["date"].values
                datestr.append(v_d[0])
                dates.append(datetime.strptime(v_d[0], "%m/%d/%Y"))
                v_p = df.loc[df["filename"] == f][select].values
                y_n.append(len(ast.literal_eval(v_p[0])))
                v_h = df.loc[df["filename"] == f]["headlines"].values
                headlines.append(v_h[0])
        dates = np.array(dates)
        n = np.array(y_n)
        headlines = np.array(headlines)
        s_source.data = dict(x=dates, y=n, f=files, h=headlines, d=datestr)
        f1.title.text = "Timeline for '" + name + "'"
        return

    text.on_change("value",text_update)

    widgets = widgetbox(button_group,slider,text)
    layout = column(widgets,row(n2,n3,n4),select1,row(f1,n1))

    curdoc().add_root(layout)
    show(layout)
Example #56
0
 def prepare(self):
     #Creating Sessions data set
     self.daily_sessions = self.data.groupby('start_date').agg({'start_date':'count'}).rename(columns = {'start_date':'Sessions'})
     self.daily_sessions = self.daily_sessions.reset_index()
     self.daily_sessions['start_date'] = self.daily_sessions['start_date'].apply(lambda x:datetime.strptime(x, "%m/%d/%Y"))
     self.daily_sessions['Year'] = self.daily_sessions['start_date'].apply(lambda x:x.year)
     self.daily_sessions['Month'] = self.daily_sessions['start_date'].apply(lambda x:x.month)
     self.daily_sessions['Day'] = self.daily_sessions['start_date'].apply(lambda x:x.day)
     self.daily_sessions['Month_Abb'] = self.daily_sessions['Month'].apply(lambda x: calendar.month_abbr[x])
     self.daily_sessions['Month_Abb'] = str(self.daily_sessions['Month_Abb'])
     self.daily_sessions = self.daily_sessions.sort_values(by = ['Year', 'Month', 'Day'])
     #print(self.daily_sessions.head(10))
     
     #Creating Session Duration data set
     self.avg_time = self.data[['start_date', 'start_time', 'end_time']]
     self.avg_time['Delta'] = self.avg_time['end_time'] - self.avg_time['start_time']
     self.avg_time['Delta'] = self.avg_time['Delta'].apply(lambda x:x.seconds)
     self.avg_time['Day'] = self.avg_time['start_time'].apply(lambda x:x.day)
     self.avg_time['Year'] = self.avg_time['start_time'].apply(lambda x:x.year)
     self.avg_time['Month'] = self.avg_time['start_time'].apply(lambda x:x.month)
     self.avg_time = self.avg_time.groupby(['start_date', 'Day', 'Month', 'Year']).mean().rename(columns = {'Delta':'Avg_Time'})
     self.avg_time['Avg_Time'] = round(self.avg_time['Avg_Time'])
     self.avg_time = self.avg_time.reset_index()
     self.avg_time = self.avg_time.sort_values(by = ['Year', 'Month', 'Day'])
     #print(self.avg_time.head(10))
     
     #Creating Users data set
     self.users = self.data.groupby(['start_date', 'device_id']).count().reset_index()
     self.users = self.users.groupby(['start_date', 'device_id']).device_id.count()
     self.users = pd.DataFrame(self.users).rename(columns = {'device_id': 'Users'}).reset_index()
     self.users_final = self.users.groupby('start_date').sum().reset_index()
     #print(self.users_final.head(10))
     
     #Creating Final Data set for CDS
     self.daily_sessions = self.daily_sessions[['start_date', 'Year', 'Month', 'Day', 'Sessions']]
     self.avg_time = self.avg_time[['Year', 'Month', 'Day', 'Avg_Time']]
     self.data_final = self.avg_time
     self.data_final['Sessions'] = self.daily_sessions['Sessions']
     self.data_final['Date'] = self.daily_sessions['start_date']
     self.data_final['Users'] = self.users_final['Users']
     self.data_final = self.data_final.rename(columns = {'Avg_Time':'Session Duration'})
     #print(self.data_final.head(10))
     #print(self.data_final.info())
     
     ##Creating events data set for possibly a pie chart
     self.events = self.data.groupby(by = ['start_date', 'events_type']).agg({'events_type':'count'}).rename(
         columns = {'events_type': 'Sessions'}
     )
     self.events = self.events.reset_index()
     self.events['start_date'] = self.events['start_date'].apply(lambda x:datetime.strptime(x, "%m/%d/%Y"))
     self.events.rename(columns = {'start_date':'Date'}, inplace = True)
     self.events['Year'] = self.events['Date'].apply(lambda x:x.year)
     self.events['Month'] = self.events['Date'].apply(lambda x:x.month)
     self.events['Day'] = self.events['Date'].apply(lambda x:x.day)
     #print(self.events.info())
     
     
     ##Top Holograms
     self.holograms = self.data.groupby(by = ['start_date', 'hologram_loaded']).agg({'hologram_loaded':'count'}).rename(
         columns = {'hologram_loaded': 'Count'}
     )
     self.holograms = self.holograms.reset_index()
     self.holograms['start_date'] = self.holograms['start_date'].apply(lambda x:datetime.strptime(x, "%m/%d/%Y"))
     self.holograms.rename(columns = {'start_date':'Date'}, inplace = True)
     self.holograms['Year'] = self.holograms['Date'].apply(lambda x:x.year)
     self.holograms['Month'] = self.holograms['Date'].apply(lambda x:x.month)
     self.holograms['Day'] = self.holograms['Date'].apply(lambda x:x.day)
     #print(self.holograms)
     
     
     #Adding Widgets
     self.options = Select(title="", options=["Last 7 days", "Last 30 days", "Last 90 days", "Custom.."], value="Custom..")
     self.radio_button_group = RadioButtonGroup(labels=["Users", "Sessions", "Session Duration"], active=1)
     self.date_from = DatePicker(title="From", min_date=DT.date(2017,8,29), max_date=DT.date(2018,8,29), value=DT.date(2018,1,1))
     self.date_to = DatePicker(title="To", min_date=DT.date(2017,8,29), max_date=DT.date(2018,8,29), value=DT.date(2018,2,1))
     self.hover1 = HoverTool(
     tooltips=[("Date", "@Date{%a, %d %B}"),
               ("Value", "@y")],
     formatters={
     "@Date" : "datetime"},
     mode = "vline"
     )
     self.hover3 = HoverTool(
     tooltips=[("Hologram", "@hologram_loaded"),
               ("Count", "@Count")],
     mode = 'vline'
     )
     self.source = ColumnDataSource(data=dict(x = [], y = [], Year=[], Month=[], Day=[], Date=[]))
     self.source_events = ColumnDataSource(data=dict(events_type = [], Sessions = [], Date=[], angle = [], color = []))
     self.source_holograms = ColumnDataSource(data=dict(Rank = [], hologram_loaded = [], Count = [], color = []))
     
     #Creating Plot
     self.plot = figure(plot_width=748, plot_height=525, tools = 'wheel_zoom,box_zoom,reset,save', x_axis_type="datetime",
                       title = "How are your Users trending over time?")
                       #x_axis_type="datetime" logo = None,    
     self.plot.toolbar.logo = None
     self.plot.add_tools(self.hover1)
     self.plot.xgrid.visible = False
     self.plot.line(x = 'x', y = 'y', line_width = 3, source=self.source, color = "#2097BE")
     self.plot.circle(x = 'x', y = 'y', source = self.source, size=6, fill_color = "#2097BE", line_color = 'white')
     self.plot.xaxis.formatter=DatetimeTickFormatter(days=["%d %b"])
     #self.plot.xaxis.major_label_orientation = 'vertical'
     self.plot.xaxis.minor_tick_line_color = None
     self.plot_events = figure(plot_width=748, plot_height=525, tools = 'wheel_zoom,box_zoom,reset,save',
                               tooltips="@events_type: @Sessions", x_range=(-0.5, 1.0),
                               title = "Breakdown of App Events")
     self.plot_events.wedge(x=0, y=1, radius=0.4, start_angle=cumsum('angle', include_zero=True), end_angle=cumsum('angle'), 
                     line_color="white", fill_color="color", source=self.source_events, legend = "events_type")
     self.plot_events.toolbar.logo = None
     self.plot_events.axis.axis_label=None
     self.plot_events.axis.visible=False
     self.plot_events.grid.grid_line_color = None
     
     self.plot_holograms = figure(plot_width=748, plot_height=525, tools = 'wheel_zoom,box_zoom,reset,save',
                                  title = "What are the Top Data Points people are interacting with?")
     self.plot_holograms.toolbar.logo = None
     self.plot_holograms.add_tools(self.hover1)
     self.plot_holograms.xgrid.visible = False
     self.plot_holograms.add_tools(self.hover3)
     self.plot_holograms.xaxis.minor_tick_line_color = None
     self.plot_holograms.vbar(x="Rank", top="Count", width = 0.95, source = self.source_holograms, color = "color")
     return self.plot, self.plot_events, self.plot_holograms, self.options, self.radio_button_group, self.date_from, self.date_to
Example #57
0
from bokeh.plotting import figure

x=[3,4,6,12,10,1,5,6,3,8]
y=[7,1,3,4,1,6,10,4,10,3]
label=['Red', 'Orange', 'Red', 'Orange','Red', 'Orange','Red', 'Orange','Red', 'Orange',]

df=pd.DataFrame({'x':x,'y':y,'label':label})

source = ColumnDataSource(data=dict(x=df.x, y=df.y,label=df.label))

plot_figure = figure(title='Select',plot_height=450, plot_width=600,
              tools="save,reset", toolbar_location="below")

plot_figure.scatter('x', 'y', source=source, size=10,color='label')

select = Select(title="Filter plot by color:", value="All", options=["All", "Red", "Orange"])

def select_click(attr,old,new):
    active_select=select.value ##Getting radio button value

    # filter the dataframe with value in select
    if active_select!='All':
        selected_df=df[df['label']==active_select]
    else:
        selected_df=df.copy()

    source.data=dict(x=selected_df.x, y=selected_df.y,label=selected_df.label)


select.on_change('value',select_click)
Example #58
0
    ("MeSH Term", "@mesh_term"),
    ("Sample Size", "@sample_size"),
    ("Population", "@popu"),
    ("P Value", "@P"),
    ("BETA", "@beta"),
    ("SE", "@se"),
    ("PAINTOR PP", "@paintor"),
    ("CAVIARBF PP", "@caviarbf"),
    ("FINEMAP PP", "@finemap"),
]

population_map = pd.Series({1: "EUR", 2: "AFR", 3: "AMR", 4: "EAS", 5: "SAS"})

# define widgets
input_rsid = TextInput(title='rsID', value='rs6265')
input_fm_tool = Select(title='Tool', value='FINEMAP', options=fm_tools)

s1 = ColumnDataSource({
    'PP': [],
    'P': [],
    'color': [],
    'size': [],
    'mesh_term': []
})
p = figure(x_axis_label='-log10 (PP)',
           y_axis_label='-log10 (P)',
           plot_width=800,
           plot_height=400,
           tools=['pan', 'wheel_zoom', 'reset', 'hover'],
           active_scroll='wheel_zoom',
           toolbar_location=None)
Example #59
0
product_names.insert(0, "All")

# Get issue names
cur.execute(ISSUE_NAMES)
issue_names = sorted([x[0] for x in cur.fetchall()])
issue_names.insert(0, "All")

# Create data source for state totals
state_source = ColumnDataSource(data=dict())
zip_source = ColumnDataSource(data=dict(x=[], y=[]))
table_source = ColumnDataSource(data=dict(labels=[], data=[]))

### Step 2: Build the UI

# Build inputs
state_widget = Select(title="State", value="All", options=states)
issue_widget = Select(title="Issues", value="All", options=issue_names)
product_widget = Select(title="Products", value="All", options=product_names)
min_complaints_widget = Slider(title="Min # Complaints", value=0,
                               start=0, end=100, step=10)

# Helper Functions
def generate_where_clause(state=None, product=None,
                          issue=None, min_complaints=None):
    """
    Generate a where clause given a set of filters
    """
    where_inner = []
    where_outer = []

    if state and not state == "All":
Example #60
0
                values = quantities[q]['values']
            filter.active = [filter.tags.index(v) for v in values]


#inp_preset = Select(
#    title='Preset',
#    options=list(presets.keys()),
#    value=get_preset_label_from_url())
#inp_preset.on_change('value', load_preset)

# quantities
nq = len(quantities)

# quantity selectors
plot_options = [(q, quantities[q]['label']) for q in config.plot_quantities]
inp_x = Select(title='X', options=plot_options)
inp_y = Select(title='Y', options=plot_options)
#inp_clr = Select(title='Color', options=plot_options)
inp_clr = Select(title='Color',
                 options=plot_options +
                 [('adsorbaphore_label', 'Adsorbaphore')])


def on_filter_change(attr, old, new):  # pylint: disable=unused-argument
    """Change color of plot button to blue"""
    btn_plot.button_type = 'primary'


# range sliders
# pylint: disable=redefined-builtin
def get_slider(desc, range, default=None):