def test_Either(self) -> None: p = Either(Int, Float) with pytest.raises(ValueError) as e: p.validate("junk") assert matches( str(e.value), r"expected an element of either Int or Float, got 'junk'")
class PlotlyPlot(LayoutDOM): """ A bokeh model that wraps around a plotly plot and renders it inside a bokeh plot. """ __javascript_raw__ = [ JS_URLS['jQuery'], 'https://cdn.plot.ly/plotly-2.10.1.min.js' ] @classproperty def __javascript__(cls): return bundled_files(cls) @classproperty def __js_skip__(cls): return {'Plotly': cls.__javascript__[1:]} __js_require__ = { 'paths': { 'plotly': 'https://cdn.plot.ly/plotly-2.10.1.min' }, 'exports': { 'plotly': 'Plotly' } } data = List(Any) layout = Dict(String, Any) config = Dict(String, Any) data_sources = List(Instance(ColumnDataSource)) relayout = Nullable(Dict(String, Any)) restyle = Nullable(Dict(String, Any)) # Callback properties relayout_data = Dict(String, Any) restyle_data = List(Any) click_data = Either(Dict(String, Any), Null) hover_data = Either(Dict(String, Any), Null) clickannotation_data = Either(Dict(String, Any), Null) selected_data = Either(Dict(String, Any), Null) viewport = Either(Dict(String, Any), Null) viewport_update_policy = Enum("mouseup", "continuous", "throttle") viewport_update_throttle = Int() visibility = Bool(True) _render_count = Int()
class SingleSelect(InputWidget): ''' Single-select widget. ''' disabled_options = List(Any, default=[], help=""" List of options to disable. """) options = List(Either(String, Tuple(String, String)), help=""" Available selection options. Options may be provided either as a list of possible string values, or as a list of tuples, each of the form ``(value, label)``. In the latter case, the visible widget text for each value will be corresponding given label. """) value = String(help="Initial or selected value.") size = Int(default=4, help=""" The number of visible options in the dropdown list. (This uses the ``select`` HTML element's ``size`` attribute. Some browsers might not show less than 3 options.) """)
class CollisionModifier(HasProps): """Models an special type of operation that alters how glyphs interact. Used to handle the manipulation of glyphs for operations, such as stacking. The list of `CompositeGlyph`s can either be input into the `CollisionModifier` as keyword args, or added individually with the `add_glyph` method. """ comp_glyphs = List(Instance(CompositeGlyph), help="""A list of composite glyphs, to apply the modification to.""") name = String(help="""The name of the collision modifier.""") method_name = String( help="""The name of the method that will be utilized on the composite glyphs. This method must exist on all `comp_glyphs`.""") columns = Either(ColumnLabel, List(ColumnLabel), help="""Some collision modifiers might require column labels to apply the operation in relation to.""") def add_glyph(self, comp_glyph): self.comp_glyphs.append(comp_glyph) def apply(self, renderers=None): if len(self.comp_glyphs) == 0: self.comp_glyphs = renderers if len(self.comp_glyphs) > 0: # the first renderer's operation method is applied to the rest getattr(self.comp_glyphs[0], self.method_name)(self.comp_glyphs) else: raise AttributeError( '%s must be applied to available renderers, none found.' % self.__class__.__name__)
def test_Property_wrap() -> None: types = [ Bool(), Int(), Float(), Complex(), String(), Enum("Some", "a", "b"), Color(), Regex("^$"), Seq(Any), Tuple(Any, Any), Instance(_TestModel), Any(), Interval(Float, 0, 1), Either(Int, String), DashPattern(), Size(), Percent(), Angle(), MinMaxBounds(), ] for x in types: for y in (0, 1, 2.3, "foo", None, (), [], {}): r = x.wrap(y) assert r == y assert isinstance(r, type(y))
class IDOM(HTMLBox): importSourceUrl = String() event = Tuple(Any, Any) msg = Either(Dict(String, Any), Null)
class DeckGLPlot(HTMLBox): """A Bokeh model that wraps around a DeckGL plot and renders it inside a HTMLBox""" __css_raw__ = ["https://api.mapbox.com/mapbox-gl-js/v1.7.0/mapbox-gl.css"] @classproperty def __css__(cls): return bundled_files(cls, 'css') __javascript_raw__ = [ "https://cdn.jsdelivr.net/npm/[email protected]/dist.min.js", "https://cdn.jsdelivr.net/npm/@deck.gl/[email protected]/dist.min.js", "https://cdn.jsdelivr.net/npm/@loaders.gl/[email protected]/dist/dist.min.js", "https://cdn.jsdelivr.net/npm/@loaders.gl/[email protected]/dist/dist.min.js", "https://cdn.jsdelivr.net/npm/@loaders.gl/[email protected]/dist/dist.min.js", "https://api.mapbox.com/mapbox-gl-js/v1.7.0/mapbox-gl.js", ] @classproperty def __javascript__(cls): return bundled_files(cls) @classproperty def __js_skip__(cls): return { 'deck': cls.__javascript__[:-1], 'mapboxgl': cls.__javascript__[-1:] } __js_require__ = { 'paths': OrderedDict([ ("deck.gl", "https://cdn.jsdelivr.net/npm/@deck.gl/jupyter-widget@^8.1.2/dist/index"), ("mapbox-gl", 'https://cdn.jsdelivr.net/npm/[email protected]/dist/mapbox-gl.min'), ]), 'exports': {"deck.gl": "deck", "mapbox-gl": "mapboxgl"} } data = Dict(String, Any) data_sources = List(Instance(ColumnDataSource)) initialViewState = Dict(String, Any) layers = List(Dict(String, Any)) mapbox_api_key = String() tooltip = Either(Bool, Dict(Any, Any)) clickState = Dict(String, Any) hoverState = Dict(String, Any) viewState = Dict(String, Any) height = Override(default=400) width = Override(default=600)
class BinStats(Stat): """A set of statistical calculations for binning values. Bin counts using: https://en.wikipedia.org/wiki/Freedman%E2%80%93Diaconis_rule """ bins = Either(Int, Float, List(Float), default=None, help=""" If bins is an int, it defines the number of equal-width bins in the given range. If bins is a sequence, it defines the bin edges, including the rightmost edge, allowing for non-uniform bin widths. (default: None, use Freedman-Diaconis rule) """) bin_width = Float(default=None, help='Use Freedman-Diaconis rule if None.') q1 = Quantile(interval=0.25) q3 = Quantile(interval=0.75) labels = List(String) def __init__(self, values=None, column=None, **properties): properties['values'] = values properties['column'] = column or 'values' super(BinStats, self).__init__(**properties) def update(self): values = self.get_data() self.q1.set_data(values) self.q3.set_data(values) if self.bins is None: self.calc_num_bins(values) def calc_num_bins(self, values): """Calculate optimal number of bins using IQR. From: http://stats.stackexchange.com/questions/114490/optimal-bin-width-for-two-dimensional-histogram """ iqr = self.q3.value - self.q1.value if iqr == 0: self.bin_width = np.sqrt(values.size) else: self.bin_width = 2 * iqr * (len(values)**-(1. / 3.)) self.bins = int(np.ceil( (values.max() - values.min()) / self.bin_width)) if self.bins <= 1: self.bins = 3 def calculate(self): pass
class JSON(Markup): """ A bokeh model that renders JSON as tree. """ depth = Either(Int, Float, default=1, help="Depth to which the JSON tree is expanded.") hover_preview = Bool(default=False, help="Whether to show a hover preview for collapsed nodes.") theme = String(default='dark', help="Whether to expand all JSON nodes.")
class BootstrapSelect(InputWidget): __javascript__ = [ "https://cdn.jsdelivr.net/npm/[email protected]/dist/js/bootstrap-select.min.js", "https://cdn.jsdelivr.net/npm/[email protected]/dist/js/i18n/defaults-pl_PL.min.js" ] __css__ = [ "https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap-select.min.css" ] alt_title = String(default="") options = List(Tuple(String, Tuple(Either(Int, String), String))) value = List(Tuple(Either(Int, String), String)) actions_box = Bool(default=False) live_search = Bool(default=False) # show_subtext = Bool(default=False) select_all_at_start = Bool(default=False) count_selected_text = String(default='') none_selected_text = String(default='') selected_text_format = String(default='') none_results_text = String(default='')
class HighTable(TableWidget): ''' Two dimensional grid for visualisation and editing large amounts of data. ''' __implementation__ = "high_table.coffee" columns = List(Instance(TableColumn), help=""" The list of child column widgets. """) fit_columns = Bool(True, help=""" Whether columns should be fit to the available width. This results in no horizontal scrollbar showing up, but data can get unreadable if there is no enough space available. If set to ``True``, columns' width is understood as maximum width. """) sortable = Bool(True, help=""" Allows to sort table's contents. By default natural order is preserved. To sort a column, click on it's header. Clicking one more time changes sort direction. Use Ctrl + click to return to natural order. Use Shift + click to sort multiple columns simultaneously. """) reorderable = Bool(True, help=""" Allows the reordering of a tables's columns. To reorder a column, click and drag a table's header to the desired location in the table. The columns on either side will remain in their previous order. """) editable = Bool(False, help=""" Allows to edit table's contents. Needs cell editors to be configured on columns that are required to be editable. """) selectable = Either(Bool(True), Enum("checkbox"), help=""" Whether a table's rows can be selected or not. Using ``checkbox`` is equivalent to ``True``, but makes selection visible through a checkbox for each row, instead of highlighting rows. Multiple selection is allowed and can be achieved by either clicking multiple checkboxes (if enabled) or using Shift + click on rows. """) row_headers = Bool(True, help=""" Enable or disable row headers, i.e. the index column. """) scroll_to_selection = Bool(True, help=""" Whenever a selection is made on the data source, scroll the selected rows into the table's viewport if none of the selected rows are already in the viewport. """) height = Override(default=400)
class QuillInput(HTMLBox): """ WYSIWYG text editor based on Quill.js """ __css_raw__ = [ 'https://cdn.quilljs.com/1.3.6/quill.bubble.css', 'https://cdn.quilljs.com/1.3.6/quill.snow.css' ] __javascript_raw__ = [ 'https://cdn.quilljs.com/1.3.6/quill.js', ] @classproperty def __javascript__(cls): return bundled_files(cls) @classproperty def __css__(cls): return bundled_files(cls, 'css') @classproperty def __js_skip__(cls): return {'Quill': cls.__javascript__} __js_require__ = { 'paths': { 'Quill': 'https://cdn.quilljs.com/1.3.6/quill', }, 'exports': { 'Quill': 'Quill' } } mode = Enum("bubble", "toolbar", default='toolbar') placeholder = String() readonly = Bool(False) text = String() toolbar = Either(List(Any), Bool)
class DisabledSelect(InputWidget): ''' Single-select widget. ''' __js_implementation__ = 'disabled_select.ts' options = List(Either(String, Tuple(String, Bool)), help=""" Available selection options. Options may be provided either as a list of possible string values, or as a list of tuples, each of the form ``(value, disabled)``. """) value = String(default="", help=""" Initial or selected value. """) callback = Instance(Callback, help=""" A callback to run in the browser whenever the current Select dropdown value changes. """)
class PCPMultiSelect(InputWidget): ''' Multi-select widget. ''' searchbox = Bool(default=True) selectall = Bool(default=True) options = List(Either(String, Tuple(String, String)), help=""" Available selection options. Options may be provided either as a list of possible string values, or as a list of tuples, each of the form ``(value, label)``. In the latter case, the visible widget text for each value will be corresponding given label. """) value = List(String, help=""" Initial or selected values. """) theme = String(default="light")
def test_Either(self, detail) -> None: p = Either(Int, Float) with pytest.raises(ValueError) as e: p.validate("junk", detail) assert (str(e.value) == "") == (not detail)
class CustomMultiSelect(InputWidget): ''' Custom Multi-select widget. ''' __implementation__ = os.path.join("implementation_files", "multiselect.ts") __javascript__ = [ "https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js", "https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/4.5.3/js/bootstrap.bundle.min.js", "https://cdnjs.cloudflare.com/ajax/libs/bootstrap-multiselect/0.9.16/js/bootstrap-multiselect.min.js", "https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.2/js/all.min.js", ] __css__ = [ "https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/4.5.3/css/bootstrap.min.css", "https://cdnjs.cloudflare.com/ajax/libs/bootstrap-multiselect/0.9.16/css/bootstrap-multiselect.min.css", ] options = Either(Dict(String, List(Either(String, Tuple(String, String)))), List(Either(String, Tuple(String, String))), help=""" Available selection options. Options may be provided either as a list of possible string values, or as a list of tuples, each of the form ``(value, label)``. In the latter case, the visible widget text for each value will be corresponding given label. In order to group options, provide a dictionary where each key is the name of a group and its corresponding value is the group options. For example: {"Even": ["2", "4", "6"], "Odd": ["1", "3", "5"]}. Note! the option's value should be unique across all other options and not only the option's group). """) value = Nullable(List(Either(String, List(String))), help=""" Initial or selected values. Note! when the options are grouped the value is a list of tuples that follow the pattern: (<group>, <value>). """) include_select_all = Bool(default=False, help=""" Whether to include a "Select All" option or not. Note! in order to initialize the widget with the "Select All" option checked, set the "select_all" property to True. """) select_all = Bool(default=False, help=""" Whether all the options are selected or not. Note! this property is valid also when the "include_select_all" property is set to false. """) number_displayed = Int(default=1, help=""" Determines how many selected labels should be displayed on the toggle button. """) enable_filtering = Bool(default=False, help=""" Enable filtering options using a search box. """) enabled = Bool(default=True, help=""" Controls whether the widget is enabled (True) or disabled (False). Note! the "disabled" property is not supported in this widget. Use this property instead. """) non_selected_text = String(default="Select...", help=""" The text to display on the toggle button when none of the options are selected. """) is_opt_grouped = Bool(readonly=True, help=""" Indicates whether the widget contains grouped options or not. """) dropdown_closed = Bool(default=False, help=""" This property changes right before the "value" property changes. """) @classmethod def create(cls: Type[T], title: str) -> T: """This function creates a custom multi select filter with a given title. """ return cls( include_select_all=True, enable_filtering=True, options=[], value=[], title=title, sizing_mode='scale_width', margin=[10, 10, 10, 5], css_classes=['custom_select', 'custom'], )
class Chart(Plot): """ The main Chart class, the core of the ``Bokeh.charts`` interface. """ __view_model__ = "Plot" __subtype__ = "Chart" xlabel = String(None, help=""" A label for the x-axis. (default: None) """) ylabel = String(None, help=""" A label for the y-axis. (default: None) """) xscale = Either(Auto, Enum(Scale), help=""" What kind of scale to use for the x-axis. """) yscale = Either(Auto, Enum(Scale), help=""" What kind of scale to use for the y-axis. """) _defaults = defaults __deprecated_attributes__ = ('filename', 'server', 'notebook', 'width', 'height', 'xgrid', 'ygrid', 'legend' 'background_fill', 'border_fill', 'logo', 'tools', 'title_text_baseline', 'title_text_align', 'title_text_alpha', 'title_text_color', 'title_text_font_style', 'title_text_font_size', 'title_text_font', 'title_standoff') _xgrid = True _ygrid = True _legend = True @Plot.xgrid.setter def xgrid(self, value): warnings.warn( "Non-functional 'xgrid' setter has been removed; use 'xgrid' keyword argument to Chart instead" ) @Plot.ygrid.setter def ygrid(self, value): warnings.warn( "Non-functional 'ygrid' setter has been removed; use 'ygrid' keyword argument to Chart instead" ) @Plot.legend.setter def legend(self, value): warnings.warn( "Non-functional 'legend' setter has been removed; use 'legend' keyword argument to Chart instead" ) def __init__(self, *args, **kwargs): # pop tools as it is also a property that doesn't match the argument # supported types tools = kwargs.pop('tools', None) for name in ['xgrid', 'ygrid', 'legend']: if name in kwargs: kwargs["_" + name] = kwargs[name] del kwargs[name] if 'responsive' in kwargs and 'sizing_mode' in kwargs: raise ValueError( "Chart initialized with both 'responsive' and 'sizing_mode' supplied, supply only one" ) if 'responsive' in kwargs: kwargs['sizing_mode'] = _convert_responsive(kwargs['responsive']) del kwargs['responsive'] self._active_drag = kwargs.pop('active_drag', 'auto') self._active_inspect = kwargs.pop('active_inspect', 'auto') self._active_scroll = kwargs.pop('active_scroll', 'auto') self._active_tap = kwargs.pop('active_tap', 'auto') title_text = kwargs.pop("title", None) super(Chart, self).__init__(*args, **kwargs) self.title.text = title_text defaults.apply(self) if tools is not None: self._tools = tools # TODO (fpliger): we do this to still support deprecated document but # should go away when __deprecated_attributes__ is empty for k in self.__deprecated_attributes__: if k in kwargs: setattr(self, k, kwargs[k]) self._glyphs = [] self._built = False self._builders = [] self._renderer_map = [] self._ranges = defaultdict(list) self._labels = defaultdict(list) self._scales = defaultdict(list) self._tooltips = [] if hasattr(self, '_tools'): self.create_tools(self._tools, self._active_drag, self._active_inspect, self._active_scroll, self._active_tap) def add_renderers(self, builder, renderers): self.renderers += renderers self._renderer_map.extend({r._id: builder for r in renderers}) def add_builder(self, builder): self._builders.append(builder) builder.create(self) def add_ranges(self, dim, range): self._ranges[dim].append(range) def add_labels(self, dim, label): self._labels[dim].append(label) def add_scales(self, dim, scale): self._scales[dim].append(scale) def add_tooltips(self, tooltips): self._tooltips += tooltips def _get_labels(self, dim): if not getattr(self, dim + 'label') and len(self._labels[dim]) > 0: return self._labels[dim][0] else: return getattr(self, dim + 'label') def create_axes(self): self._xaxis = self.make_axis('x', "below", self._scales['x'][0], self._get_labels('x')) self._yaxis = self.make_axis('y', "left", self._scales['y'][0], self._get_labels('y')) def create_grids(self, xgrid=True, ygrid=True): if xgrid: self.make_grid(0, self._xaxis.ticker) if ygrid: self.make_grid(1, self._yaxis.ticker) def create_tools(self, tools, active_drag, active_inspect, active_scroll, active_tap): """Create tools if given tools=True input. Only adds tools if given boolean and does not already have tools added to self. """ if isinstance(tools, bool) and tools: tools = DEFAULT_TOOLS elif isinstance(tools, bool): # in case tools == False just exit return if len(self.toolbar.tools) == 0: # if no tools customization let's create the default tools tool_objs, tool_map = _process_tools_arg(self, tools) self.add_tools(*tool_objs) _process_active_tools(self.toolbar, tool_map, active_drag, active_inspect, active_scroll, active_tap) def start_plot(self): """Add the axis, grids and tools """ self.create_axes() self.create_grids(self._xgrid, self._ygrid) if self.toolbar.tools: self.create_tools(self._tools, self._active_drag, self._active_inspect, self._active_scroll, self._active_tap) if len(self._tooltips) > 0: self.add_tools(HoverTool(tooltips=self._tooltips)) def add_legend(self, chart_legends): """Add the legend to your plot, and the plot to a new Document. It also add the Document to a new Session in the case of server output. Args: legends(List(Tuple(String, List(GlyphRenderer)): A list of tuples that maps text labels to the legend to corresponding renderers that should draw sample representations for those labels. """ location = None if self._legend is True: location = "top_left" else: location = self._legend items = [] for legend in chart_legends: items.append( LegendItem(label=value(legend[0]), renderers=legend[1])) if location: legend = Legend(location=location, items=items) self.add_layout(legend) def make_axis(self, dim, location, scale, label): """Create linear, date or categorical axis depending on the location, scale and with the proper labels. Args: location(str): the space localization of the axis. It can be ``left``, ``right``, ``above`` or ``below``. scale (str): the scale on the axis. It can be ``linear``, ``datetime`` or ``categorical``. label (str): the label on the axis. Return: Axis: Axis instance """ # ToDo: revisit how to handle multiple ranges # set the last range to the chart's range if len(self._ranges[dim]) == 0: raise ValueError('Ranges must be added to derive axis type.') data_range = self._ranges[dim][-1] setattr(self, dim + '_range', data_range) if scale == "auto": if isinstance(data_range, FactorRange): scale = 'categorical' else: scale = 'linear' if scale == "linear": axis = LinearAxis(axis_label=label) elif scale == "datetime": axis = DatetimeAxis(axis_label=label) elif scale == "categorical": axis = CategoricalAxis(major_label_orientation=np.pi / 4, axis_label=label) else: axis = LinearAxis(axis_label=label) self.add_layout(axis, location) return axis def make_grid(self, dimension, ticker): """Create the grid just passing the axis and dimension. Args: dimension(int): the dimension of the axis, ie. xaxis=0, yaxis=1. ticker (obj): the axis.ticker object Return: Grid: A Grid instance """ grid = Grid(dimension=dimension, ticker=ticker) self.add_layout(grid) return grid annular_wedge = _glyph_function(glyphs.AnnularWedge) annulus = _glyph_function(glyphs.Annulus) arc = _glyph_function(glyphs.Arc) asterisk = _glyph_function(markers.Asterisk) bezier = _glyph_function(glyphs.Bezier) circle = _glyph_function(markers.Circle) circle_cross = _glyph_function(markers.CircleCross) circle_x = _glyph_function(markers.CircleX) cross = _glyph_function(markers.Cross) diamond = _glyph_function(markers.Diamond) diamond_cross = _glyph_function(markers.DiamondCross) ellipse = _glyph_function(glyphs.Ellipse) hbar = _glyph_function(glyphs.HBar) image = _glyph_function(glyphs.Image) image_rgba = _glyph_function(glyphs.ImageRGBA) image_url = _glyph_function(glyphs.ImageURL) inverted_triangle = _glyph_function(markers.InvertedTriangle) line = _glyph_function(glyphs.Line) multi_line = _glyph_function(glyphs.MultiLine) oval = _glyph_function(glyphs.Oval) patch = _glyph_function(glyphs.Patch) patches = _glyph_function(glyphs.Patches) quad = _glyph_function(glyphs.Quad) quadratic = _glyph_function(glyphs.Quadratic) ray = _glyph_function(glyphs.Ray) rect = _glyph_function(glyphs.Rect) segment = _glyph_function(glyphs.Segment) square = _glyph_function(markers.Square) square_cross = _glyph_function(markers.SquareCross) square_x = _glyph_function(markers.SquareX) text = _glyph_function(glyphs.Text) triangle = _glyph_function(markers.Triangle) vbar = _glyph_function(glyphs.VBar) wedge = _glyph_function(glyphs.Wedge) x = _glyph_function(markers.X)
class Dimension(HasProps): """Configures valid Chart column selections. A dimension is Chart property that is assigned one or more columns names or indices. Each column can match one or more column types, which are important to charts, because the type of column selection can greatly affect the behavior of generalized Charts. The Dimension also provides convenient utilities for accessing information about the current provided configuration at the global, non-grouped level. The dimension configuration does not require the data, but when the data is added using the `set_data` method, then validation can occur of the settings by using the `valid` and `invalid` types identified by the selection. """ name = String() alt_names = Either(String, List(String), default=None) columns = Either(ColumnLabel, List(ColumnLabel), default=None) valid = Either(PrimitiveProperty, List(PrimitiveProperty), default=None) invalid = Either(PrimitiveProperty, List(PrimitiveProperty), default=None) selection = Either(ColumnLabel, List(ColumnLabel), default=None) def __init__(self, name, **properties): properties['name'] = name super(Dimension, self).__init__(**properties) self._data = pd.DataFrame() self._chart_source = None def get_valid_types(self, col_data): """Returns all property types that are matched.""" valid_types = list(self.valid) matches = [] # validate each type on the provided column for valid_type in valid_types: prop = valid_type() # if valid, append to the output try: prop.validate(col_data) matches.append(valid_type) except ValueError: pass return matches @property def data(self): """The data selected for the Dimension. Returns pd.Series(1) if data is empty or no selection. """ if self._data.empty or self.selection is None: return pd.Series(1) else: # return special column type if available if self.selection in list(special_columns.keys()): return special_columns[self.selection](self._data) return self._data[self.selection] def __len__(self): return len(self.data.index) def set_data(self, data): """Set data property so that builders has access to configuration metadata. Args: data (`ChartDataSource`): the data source associated with the chart """ self.selection = data[self.name] self._chart_source = data self._data = data.df self.columns = list(self._data.columns.values) @property def min(self): """The minimum of one to many column selections.""" if isinstance(self.data, pd.Series): return self.data.min() else: return self.data.min(axis=1).min() @property def max(self): """The maximum of one to many column selections.""" if isinstance(self.data, pd.Series): return self.data.max() else: return self.data.max(axis=1).max() @property def dtype(self): if isinstance(self.data, pd.DataFrame): return self.data.dtypes[self.selection[0]] else: return self.data.dtype @property def computed(self): """Check the `ChartDataSource` to see if the selection is a derived column.""" if self._chart_source is None: return False else: return self._chart_source.is_computed(self.selection) @property def selected_title(self): """A title formatted representation of selected columns.""" return title_from_columns(self.selection)
class CategorialLegend(Annotation): ''' Render legend for a plot But can link to more renderers than used for display classs ''' __implementation__ = "CategorialLegend.ts" items = List(Instance(CategorialLegendItem), help=""" A list of :class:`~bokeh.model.annotations.LegendItem` instances to be rendered in the legend. This can be specified explicitly, for instance: .. code-block:: python legend = Legend(items=[ LegendItem(label="sin(x)" , renderers=[r0, r1]), LegendItem(label="2*sin(x)" , renderers=[r2]), LegendItem(label="3*sin(x)" , renderers=[r3, r4]) ]) But as a convenience, can also be given more compactly as a list of tuples: .. code-block:: python legend = Legend(items=[ ("sin(x)" , [r0, r1]), ("2*sin(x)" , [r2]), ("3*sin(x)" , [r3, r4]) ]) where each tuple is of the form: *(label, renderers)*. """).accepts( List(Tuple(List(String), Instance(GlyphRenderer))), lambda items: [ CategorialLegendItem(labels=item[0], render=item[1]) for item in items ]) ''' Render informational legends for a plot. ''' location = Either(Enum(LegendLocation), Tuple(Float, Float), default="top_right", help=""" The location where the legend should draw itself. It's either one of ``bokeh.core.enums.LegendLocation``'s enumerated values, or a ``(x, y)`` tuple indicating an absolute location absolute location in screen coordinates (pixels from the bottom-left corner). """) orientation = Enum(Orientation, default="vertical", help=""" Whether the legend entries should be placed vertically or horizontally when they are drawn. """) border_props = Include(LineProps, help=""" The %s for the legend border outline. """) border_line_color = Override(default="#e5e5e5") border_line_alpha = Override(default=0.5) background_props = Include(FillProps, help=""" The %s for the legend background style. """) inactive_props = Include(FillProps, help=""" The %s for the legend item style when inactive. These control an overlay on the item that can be used to obscure it when the corresponding glyph is inactive (e.g. by making it semi-transparent). """) click_policy = Enum(LegendClickPolicy, default="none", help=""" Defines what happens when a lengend's item is clicked. """) background_fill_color = Override(default="#ffffff") background_fill_alpha = Override(default=0.95) inactive_fill_color = Override(default="white") inactive_fill_alpha = Override(default=0.7) label_props = Include(TextProps, help=""" The %s for the legend labels. """) label_text_baseline = Override(default='middle') label_text_font_size = Override(default={'value': '10pt'}) label_standoff = Int(5, help=""" The distance (in pixels) to separate the label from its associated glyph. """) label_height = Int(20, help=""" The minimum height (in pixels) of the area that legend labels should occupy. """) label_width = Int(20, help=""" The minimum width (in pixels) of the area that legend labels should occupy. """) glyph_height = Int(20, help=""" The height (in pixels) that the rendered legend glyph should occupy. """) glyph_width = Int(20, help=""" The width (in pixels) that the rendered legend glyph should occupy. """) margin = Int(10, help=""" Amount of margin around the legend. """) padding = Int(10, help=""" Amount of padding around the contents of the legend. Only applicable when when border is visible, otherwise collapses to 0. """) spacing = Int(3, help=""" Amount of spacing (in pixels) between legend entries. """)
def test_Either(self): p = Either(Int, Float) with pytest.raises(ValueError) as e: p.validate("junk") assert not str(e).endswith("ValueError")
class Foo(Model): """ This is a Foo model. """ index = Either(Auto, Enum('abc', 'def', 'xzy'), help="doc for index") value = Tuple(Float, Float, help="doc for value")
class Interval(AggregateGlyph): """A rectangle representing aggregated values. The interval is a rect glyph where two of the parallel sides represent a summary of values. Each of the two sides is derived from a separate aggregation of the values provided to the interval. .. note:: A bar is a special case interval where one side is pinned and used to communicate a value relative to it. """ width = Float(default=0.8) start_agg = Either(Instance(Stat), Enum(*list(stats.keys())), default=Min(), help=""" The stat used to derive the starting point of the composite glyph.""") end_agg = Either(Instance(Stat), Enum(*list(stats.keys())), default=Max(), help=""" The stat used to derive the end point of the composite glyph.""") start = Float(default=0.0) end = Float() def __init__(self, label, values, **kwargs): kwargs['label'] = label kwargs['values'] = values super(Interval, self).__init__(**kwargs) self.setup() def get_start(self): """Get the value for the start of the glyph.""" if len(self.values.index) == 1: self.start_agg = None return self.values[0] elif isinstance(self.start_agg, str): self.start_agg = stats[self.start_agg]() self.start_agg.set_data(self.values) return self.start_agg.value def get_end(self): """Get the value for the end of the glyph.""" if isinstance(self.end_agg, str): self.end_agg = stats[self.end_agg]() self.end_agg.set_data(self.values) return self.end_agg.value def get_span(self): """The total range between the start and end.""" return self.end - self.start def build_source(self): # ToDo: Handle rotation self.start = self.get_start() self.end = self.get_end() self.span = self.get_span() width = [self.width] if self.dodge_shift is not None: x = [self.get_dodge_label()] else: x = [self.x_label] height = [self.span] y = [self.stack_shift + (self.span / 2.0) + self.start] color = [self.color] fill_alpha = [self.fill_alpha] line_color = [self.line_color] line_alpha = [self.line_alpha] label = [self.label] return dict(x=x, y=y, width=width, height=height, color=color, fill_alpha=fill_alpha, line_color=line_color, line_alpha=line_alpha, label=label) @property def x_max(self): """The maximum extent of the glyph in x. .. note:: Dodging the glyph can affect the value. """ return (self.dodge_shift or self.x_label_value) + (self.width / 2.0) @property def x_min(self): """The maximum extent of the glyph in y. .. note:: Dodging the glyph can affect the value. """ return (self.dodge_shift or self.x_label_value) - (self.width / 2.0) @property def y_max(self): """Maximum extent of all `Glyph`s. How much we are stacking + the height of the interval + the base of the interval .. note:: the start and end of the glyph can swap between being associated with the min and max when the glyph end represents a negative value. """ return max(self.bottom, self.top) @property def y_min(self): """The minimum extent of all `Glyph`s in y. .. note:: the start and end of the glyph can swap between being associated with the min and max when the glyph end represents a negative value. """ return min(self.bottom, self.top) @property def bottom(self): """The value associated with the start of the stacked glyph.""" return self.stack_shift + self.start @property def top(self): """The value associated with the end of the stacked glyph.""" return self.stack_shift + self.span + self.start def build_renderers(self): """Yields a `GlyphRenderer` associated with a `Rect` glyph.""" glyph = Rect(x='x', y='y', width='width', height='height', fill_color='color', fill_alpha='fill_alpha', line_color='line_color') yield GlyphRenderer(glyph=glyph)
class LuminoDock(HTMLBox): children = List(Either(Tuple(String, Instance(LayoutDOM)), Tuple(String, Instance(LayoutDOM), InsertMode), Tuple(String, Instance(LayoutDOM), InsertMode, Int)), default=[])
def test_Either(self, detail): p = Either(Int, Float) with pytest.raises(ValueError) as e: p.validate("junk", detail) assert str(e).endswith("ValueError") == (not detail)
class Builder(HasProps): """ A prototype class to inherit each new chart Builder type. It provides useful methods to be used by the inherited builder classes, in order to automate most of the charts creation tasks and leave the core customization to specialized builder classes. In that pattern inherited builders just need to provide the following methods: Required: * :meth:`~bokeh.charts.builder.Builder.yield_renderers`: yields the glyphs to be rendered into the plot. Here you should call the :meth:`~bokeh.charts.builder.Builder.add_glyph` method so that the builder can setup the legend for you. * :meth:`~bokeh.charts.builder.Builder.set_ranges`: setup the ranges for the glyphs. This is called after glyph creation, so you are able to inspect the comp_glyphs for their minimum and maximum values. See the :meth:`~bokeh.charts.builder.Builder.create` method for more information on when this is called and how the builder provides the ranges to the containing :class:`Chart` using the :meth:`Chart.add_ranges` method. Optional: * :meth:`~bokeh.charts.builder.Builder.setup`: provides an area where subclasses of builder can introspect properties, setup attributes, or change property values. This is called before :meth:`~bokeh.charts.builder.Builder.process_data`. * :meth:`~bokeh.charts.builder.Builder.process_data`: provides an area where subclasses of builder can manipulate the source data before renderers are created. """ # Optional Inputs x_range = Instance(Range) y_range = Instance(Range) xlabel = String() ylabel = String() xscale = String() yscale = String() palette = List(Color, help="""Optional input to override the default palette used by any color attribute. """) # Dimension Configuration """ The dimension labels that drive the position of the glyphs. Subclasses should implement this so that the Builder base class knows which dimensions it needs to operate on. An example for a builder working with cartesian x and y coordinates would be dimensions = ['x', 'y']. You should then instantiate the x and y dimensions as attributes of the subclass of builder using the :class:`Dimension <bokeh.charts.properties.Dimension>` class. One for x, as x = Dimension(...), and one as y = Dimension(...). """ dimensions = None # None because it MUST be overridden """ The dimension labels that must exist to produce the glyphs. This specifies what are the valid configurations for the chart, with the option of specifying the type of the columns. The :class:`~bokeh.charts.data_source.ChartDataSource` will inspect this property of your subclass of Builder and use this to fill in any required dimensions if no keyword arguments are used. """ req_dimensions = [] # Attribute Configuration attributes = Dict(String, Instance(AttrSpec), help=""" The attribute specs used to group data. This is a mapping between the role of the attribute spec (e.g. 'color') and the :class:`~bokeh.charts.attributes.AttrSpec` class (e.g., :class:`~bokeh.charts.attributes.ColorAttr`). The Builder will use this attributes property during runtime, which will consist of any attribute specs that are passed into the chart creation function (e.g., :class:`~bokeh.charts.Bar`), ones that are created for the user from simple input types (e.g. `Bar(..., color='red')` or `Bar(..., color=<column_name>)`), or lastly, the attribute spec found in the default_attributes configured for the subclass of :class:`~bokeh.charts.builder.Builder`. """) """ The default attribute specs used to group data. This is where the subclass of Builder should specify what the default attributes are that will yield attribute values to each group of data, and any specific configuration. For example, the :class:`ColorAttr` utilizes a default palette for assigning color based on groups of data. If the user doesn't assign a column of the data to the associated attribute spec, then the default attrspec is used, which will yield a constant color value for each group of data. This is by default the first color in the default palette, but can be customized by setting the default color in the ColorAttr. """ default_attributes = None # None because it MUST be overridden # Derived properties (created by Builder at runtime) attribute_columns = List(ColumnLabel, help=""" All columns used for specifying attributes for the Chart. The Builder will set this value on creation so that the subclasses can know the distinct set of columns that are being used to assign attributes. """) comp_glyphs = List(Instance(CompositeGlyph), help=""" A list of composite glyphs, where each represents a unique subset of data. The composite glyph is a helper class that encapsulates all low level :class:`~bokeh.models.glyphs.Glyph`, that represent a higher level group of data. For example, the :class:`BoxGlyph` is a single class that yields each :class:`GlyphRenderer` needed to produce a Box on a :class:`BoxPlot`. The single Box represents a full array of values that are aggregated, and is made up of multiple :class:`~bokeh.models.glyphs.Rect` and :class:`~bokeh.models.glyphs.Segment` glyphs. """) labels = List( String, help="""Represents the unique labels to be used for legends.""") """List of attributes to use for legends.""" label_attributes = [] """ Used to assign columns to dimensions when no selections have been provided. The default behavior is provided by the :class:`OrderedAssigner`, which assigns a single column to each dimension available in the `Builder`'s `dims` property. """ column_selector = OrderedAssigner comp_glyph_types = List(Instance(CompositeGlyph)) sort_dim = Dict(String, Bool, default={}) sort_legend = List(Tuple(String, Bool), help=""" List of tuples to use for sorting the legend, in order that they should be used for sorting. This sorting can be different than the sorting used for the rest of the chart. For example, you might want to sort only on the column assigned to the color attribute, or sort it descending. The order of each tuple is (Column, Ascending). """) legend_sort_field = String(help=""" Attribute that should be used to sort the legend, for example: color, dash, maker, etc. Valid values for this property depend on the type of chart. """) legend_sort_direction = Enum(SortDirection, help=""" Sort direction to apply to :attr:`~bokeh.charts.builder.Builder.sort_legend`. Valid values are: `ascending` or `descending`. """) source = Instance(ColumnDataSource) tooltips = Either(List(Tuple(String, String)), List(String), Bool, default=None, help=""" Tells the builder to add tooltips to the chart by either using the columns specified to the chart attributes (True), or by generating tooltips for each column specified (list(str)), or by explicit specification of the tooltips using the valid input for the `HoverTool` tooltips kwarg. """) __deprecated_attributes__ = ('sort_legend', ) def __init__(self, *args, **kws): """Common arguments to be used by all the inherited classes. Args: data (:ref:`userguide_charts_data_types`): source data for the chart legend (str, bool): the legend of your plot. The legend content is inferred from incoming input.It can be ``top_left``, ``top_right``, ``bottom_left``, ``bottom_right``. It is ``top_right`` is you set it as True. Attributes: source (obj): datasource object for your plot, initialized as a dummy None. x_range (obj): x-associated datarange object for you plot, initialized as a dummy None. y_range (obj): y-associated datarange object for you plot, initialized as a dummy None. groups (list): to be filled with the incoming groups of data. Useful for legend construction. data (dict): to be filled with the incoming data and be passed to the ChartDataSource for each Builder class. attr (list(AttrSpec)): to be filled with the new attributes created after loading the data dict. """ data = None if len(args) != 0 or len(kws) != 0: # chart dimensions can be literal dimensions or attributes attrs = list(self.default_attributes.keys()) dims = self.dimensions + attrs # pop the dimension inputs from kwargs data_args = {} for dim in dims: if dim in kws.keys(): data_args[dim] = kws[dim] # build chart data source from inputs, given the dimension configuration data_args['dims'] = tuple(dims) data_args['required_dims'] = tuple(self.req_dimensions) data_args['attrs'] = attrs data_args['column_assigner'] = self.column_selector data = ChartDataSource.from_data(*args, **data_args) # make sure that the builder dimensions have access to the chart data source for dim in self.dimensions: getattr(getattr(self, dim), 'set_data')(data) # handle input attrs and ensure attrs have access to data attributes = self._setup_attrs(data, kws) # remove inputs handled by dimensions and chart attributes for dim in dims: kws.pop(dim, None) else: attributes = dict() kws['attributes'] = attributes super(Builder, self).__init__(**kws) # collect unique columns used for attributes self.attribute_columns = collect_attribute_columns(**self.attributes) for k in self.__deprecated_attributes__: if k in kws: setattr(self, k, kws[k]) self._data = data self._legends = [] def _setup_attrs(self, data, kws): """Handle overridden attributes and initialize them with data. Makes sure that all attributes have access to the data source, which is used for mapping attributes to groups of data. Returns: None """ source = ColumnDataSource(data.df) attr_names = self.default_attributes.keys() custom_palette = kws.get('palette') attributes = dict() for attr_name in attr_names: attr = kws.pop(attr_name, None) # if given an attribute use it if isinstance(attr, AttrSpec): attributes[attr_name] = attr # if we are given columns, use those elif isinstance(attr, (str, list)): attributes[attr_name] = self.default_attributes[ attr_name]._clone() # override palette if available if isinstance(attributes[attr_name], ColorAttr): if custom_palette is not None: attributes[attr_name].iterable = custom_palette attributes[attr_name].setup(data=source, columns=attr) else: # override palette if available if (isinstance(self.default_attributes[attr_name], ColorAttr) and custom_palette is not None): attributes[attr_name] = self.default_attributes[ attr_name]._clone() attributes[attr_name].iterable = custom_palette else: attributes[attr_name] = self.default_attributes[ attr_name]._clone() # make sure all have access to data source for attr_name in attr_names: attributes[attr_name].update_data(data=source) return attributes def setup(self): """Perform any initial pre-processing, attribute config. Returns: None """ pass def process_data(self): """Make any global data manipulations before grouping. It has to be implemented by any of the inherited class representing each different chart type. It is the place where we make specific calculations for each chart. Returns: None """ pass def yield_renderers(self): """ Generator that yields the glyphs to be draw on the plot It has to be implemented by any of the inherited class representing each different chart type. Yields: :class:`GlyphRenderer` """ raise NotImplementedError( 'Subclasses of %s must implement _yield_renderers.' % self.__class__.__name__) def set_ranges(self): """Calculate and set the x and y ranges. It has to be implemented by any of the subclasses of builder representing each different chart type, and is called after :meth:`yield_renderers`. Returns: None """ raise NotImplementedError( 'Subclasses of %s must implement _set_ranges.' % self.__class__.__name__) def get_dim_extents(self): """Helper method to retrieve maximum extents of all the renderers. Returns: a dict mapping between dimension and value for x_max, y_max, x_min, y_min """ return { 'x_max': max([renderer.x_max for renderer in self.comp_glyphs]), 'y_max': max([renderer.y_max for renderer in self.comp_glyphs]), 'x_min': min([renderer.x_min for renderer in self.comp_glyphs]), 'y_min': min([renderer.y_min for renderer in self.comp_glyphs]) } def add_glyph(self, group, glyph): """Add a composite glyph. Manages the legend, since the builder might not want all attribute types used for the legend. Args: group (:class:`DataGroup`): the data the `glyph` is associated with glyph (:class:`CompositeGlyph`): the glyph associated with the `group` Returns: None """ if isinstance(glyph, list): for sub_glyph in glyph: self.comp_glyphs.append(sub_glyph) else: self.comp_glyphs.append(glyph) # handle cases where builders have specified which attributes to use for labels label = None if len(self.label_attributes) > 0: for attr in self.label_attributes: # this will get the last attribute group label for now if self.attributes[attr].columns is not None: label = self._get_group_label(group, attr=attr) # if no special case for labeling, just use the group label if label is None: label = self._get_group_label(group, attr='label') # add to legend if new and unique label if str(label) not in self.labels and label is not None: self._legends.append((label, glyph.renderers)) self.labels.append(label) def _get_group_label(self, group, attr='label'): """Get the label of the group by the attribute name. Args: group (:attr:`DataGroup`: the group of data attr (str, optional): the attribute name containing the label, defaults to 'label'. Returns: str: the label for the group """ if attr is 'label': label = group.label else: label = group[attr] if isinstance(label, dict): label = tuple(label.values()) return self._get_label(label) @staticmethod def _get_label(raw_label): """Converts a label by string or tuple to a string representation. Args: raw_label (str or tuple(any, any)): a unique identifier for the data group Returns: str: a label that is usable in charts """ # don't convert None type to string so we can test for it later if raw_label is None: return None if (isinstance(raw_label, tuple) or isinstance(raw_label, list)) and \ len(raw_label) == 1: raw_label = raw_label[0] elif isinstance(raw_label, dict): raw_label = label_from_index_dict(raw_label) return str(raw_label) def collect_attr_kwargs(self): if hasattr(super(self.__class__, self), 'default_attributes'): attrs = set(self.default_attributes.keys()) - set( (super(self.__class__, self).default_attributes or {}).keys()) else: attrs = set() return attrs def get_group_kwargs(self, group, attrs): return {attr: group[attr] for attr in attrs} def create(self, chart=None): """Builds the renderers, adding them and other components to the chart. Args: chart (:class:`Chart`, optional): the chart that will contain the glyph renderers that the `Builder` produces. Returns: :class:`Chart` """ # call methods that allow customized setup by subclasses self.setup() self.process_data() # create and add renderers to chart renderers = self.yield_renderers() if chart is None: chart = Chart() chart.add_renderers(self, renderers) # handle ranges after renders, since ranges depend on aggregations # ToDo: should reconsider where this occurs self.set_ranges() chart.add_ranges('x', self.x_range) chart.add_ranges('y', self.y_range) # sort the legend if we are told to self._legends = self._sort_legend(self.legend_sort_field, self.legend_sort_direction, self._legends, self.attributes) # always contribute legends, let Chart sort it out chart.add_legend(self._legends) chart.add_labels('x', self.xlabel) chart.add_labels('y', self.ylabel) chart.add_scales('x', self.xscale) chart.add_scales('y', self.yscale) if self.tooltips is not None: tooltips = build_hover_tooltips(hover_spec=self.tooltips, chart_cols=self.attribute_columns) chart.add_tooltips(tooltips) return chart @classmethod def generate_help(cls): help_str = '' for comp_glyph in cls.comp_glyph_types: help_str += str(comp_glyph.glyph_properties()) return help_str @staticmethod def _sort_legend(legend_sort_field, legend_sort_direction, legends, attributes): """Sort legends sorted by looping though sort_legend items ( see :attr:`Builder.sort_legend` for more details) """ if legend_sort_field: if len(attributes[legend_sort_field].columns) > 0: # TODO(fpliger): attributes should be consistent and not # need any type checking but for # the moment it is not, specially when going # though a process like binning or when data # is built for HeatMap, Scatter, etc... item_order = [ x[0] if isinstance(x, tuple) else x for x in attributes[legend_sort_field].items ] item_order = [ str(x) if not isinstance(x, string_types) else x for x in item_order ] def foo(leg): return item_order.index(leg[0]) reverse = legend_sort_direction == 'descending' return list(sorted(legends, key=foo, reverse=reverse)) return legends @property def sort_legend(self): deprecated((0, 12, 0), 'Chart.sort_legend', 'Chart.legend_sort_field') return [(self.legend_sort_field, self.legend_sort_direction)] @sort_legend.setter def sort_legend(self, value): deprecated((0, 12, 0), 'Chart.sort_legend', 'Chart.legend_sort_field') self.legend_sort_field, direction = value[0] if direction: self.legend_sort_direction = "ascending" else: self.legend_sort_direction = "descending"
class AttrSpec(HasProps): """A container for assigning attributes to values and retrieving them as needed. A special function this provides is automatically handling cases where the provided iterator is too short compared to the distinct values provided. Once created as attr_spec, you can do attr_spec[data_label], where data_label must be a one dimensional tuple of values, representing the unique group in the data. See the :meth:`AttrSpec.setup` method for the primary way to provide an existing AttrSpec with data and column values and update all derived property values. """ data = Instance(ColumnDataSource) iterable = List(Any, default=None) attrname = String(help='Name of the attribute the spec provides.') columns = Either(ColumnLabel, List(ColumnLabel), help=""" The label or list of column labels that correspond to the columns that will be used to find all distinct values (single column) or combination of values ( multiple columns) to then assign a unique attribute to. If not enough unique attribute values are found, then the attribute values will be cycled. """) default = Any(default=None, help=""" The default value for the attribute, which is used if no column is assigned to the attribute for plotting. If the default value is not provided, the first value in the `iterable` property is used. """) attr_map = Dict(Any, Any, help=""" Created by the attribute specification when `iterable` and `data` are available. The `attr_map` will include a mapping between the distinct value(s) found in `columns` and the attribute value that has been assigned. """) items = Any(default=None, help=""" The attribute specification calculates this list of distinct values that are found in `columns` of `data`. """) sort = Bool(default=True, help=""" A boolean flag to tell the attribute specification to sort `items`, when it is calculated. This affects which value of `iterable` is assigned to each distinct value in `items`. """) ascending = Bool(default=True, help=""" A boolean flag to tell the attribute specification how to sort `items` if the `sort` property is set to `True`. The default setting for `ascending` is `True`. """) bins = Instance(Bins, help=""" If an attribute spec is binning data, so that we can map one value in the `iterable` to one value in `items`, then this attribute will contain an instance of the Bins stat. This is used to create unique labels for each bin, which is then used for `items` instead of the actual unique values in `columns`. """) def __init__(self, columns=None, df=None, iterable=None, default=None, items=None, **properties): """Create a lazy evaluated attribute specification. Args: columns: a list of column labels df(:class:`~pandas.DataFrame`): the data source for the attribute spec. iterable: an iterable of distinct attribute values default: a value to use as the default attribute when no columns are passed items: the distinct values in columns. If items is provided as input, then the values provided are used instead of being calculated. This can be used to force a specific order for assignment. **properties: other properties to pass to parent :class:`HasProps` """ properties['columns'] = self._ensure_list(columns) if df is not None: properties['data'] = ColumnDataSource(df) if default is None and iterable is not None: default_iter = copy(iterable) properties['default'] = next(iter(default_iter)) elif default is not None: properties['default'] = default if iterable is not None: properties['iterable'] = iterable if items is not None: properties['items'] = items super(AttrSpec, self).__init__(**properties) if self.default is None and self.iterable is not None: self.default = next(iter(copy(self.iterable))) if self.data is not None and self.columns is not None: if df is None: df = self.data.to_df() self._generate_items(df, columns=self.columns) if self.items is not None and self.iterable is not None: self.attr_map = self._create_attr_map() @staticmethod def _ensure_list(attr): """Always returns a list with the provided value. Returns the value if a list.""" if isinstance(attr, str): return [attr] elif isinstance(attr, tuple): return list(attr) else: return attr @staticmethod def _ensure_tuple(attr): """Return tuple with the provided value. Returns the value if a tuple.""" if not isinstance(attr, tuple): return (attr,) else: return attr def _setup_default(self): """Stores the first value of iterable into `default` property.""" self.default = next(self._setup_iterable()) def _setup_iterable(self): """Default behavior is to copy and cycle the provided iterable.""" return cycle(copy(self.iterable)) def _generate_items(self, df, columns): """Produce list of unique tuples that identify each item.""" if self.sort: # TODO (fpliger): this handles pandas API change so users do not experience # the related annoying deprecation warning. This is probably worth # removing when pandas deprecated version (0.16) is "old" enough try: df = df.sort_values(by=columns, ascending=self.ascending) except AttributeError: df = df.sort(columns=columns, ascending=self.ascending) items = df[columns].drop_duplicates() self.items = [tuple(x) for x in items.to_records(index=False)] def _create_attr_map(self, df=None, columns=None): """Creates map between unique values and available attributes.""" if df is not None and columns is not None: self._generate_items(df, columns) iterable = self._setup_iterable() return {item: next(iterable) for item in self._item_tuples()} def _item_tuples(self): return [self._ensure_tuple(item) for item in self.items] def set_columns(self, columns): """Set columns property and update derived properties as needed.""" columns = self._ensure_list(columns) if all([col in self.data.column_names for col in columns]): self.columns = columns else: # we have input values other than columns # assume this is now the iterable at this point self.iterable = columns self._setup_default() def setup(self, data=None, columns=None): """Set the data and update derived properties as needed.""" if data is not None: self.data = data if columns is not None and self.data is not None: self.set_columns(columns) if self.columns is not None and self.data is not None: self.attr_map = self._create_attr_map(self.data.to_df(), self.columns) def update_data(self, data): self.setup(data=data, columns=self.columns) def __getitem__(self, item): """Lookup the attribute to use for the given unique group label.""" if not self.attr_map: return self.default elif self._ensure_tuple(item) not in self.attr_map.keys(): # make sure we have attr map self.setup() return self.attr_map[self._ensure_tuple(item)] @property def series(self): if not self.attr_map: return pd.Series() else: index = pd.MultiIndex.from_tuples(self._item_tuples(), names=self.columns) return pd.Series(list(self.attr_map.values()), index=index)
class EitherContainerDefault(hp.HasProps): foo = Either(List(Int), Int, default=[10])
class Bin(Stat): """Represents a single bin of data values and attributes of the bin.""" label = Either(String, List(String)) start = Either(Float, List(Float)) stop = Either(Float, List(Float)) start_label = String() stop_label = String() center = Either(Float, List(Float)) stat = Instance(Stat, default=Count()) width = Float() def __init__(self, bin_label, values=None, source=None, **properties): if isinstance(bin_label, tuple): bin_label = list(bin_label) else: bin_label = [bin_label] properties['label'] = bin_label bounds = self.process_bounds(bin_label) starts, stops = zip(*bounds) centers = [(start + stop) / 2.0 for start, stop in zip(starts, stops)] if len(starts) == 1: starts = starts[0] stops = stops[0] centers = centers[0] else: starts = list(starts) stops = list(stops) centers = list(centers) properties['start'] = starts properties['stop'] = stops properties['center'] = centers properties['values'] = values super(Bin, self).__init__(**properties) @staticmethod def binstr_to_list(bins): """Produce a consistent display of a bin of data.""" value_chunks = bins.split(',') value_chunks = [ val.replace('[', '').replace(']', '').replace('(', '').replace(')', '') for val in value_chunks ] bin_values = [float(value) for value in value_chunks] return bin_values[0], bin_values[1] def process_bounds(self, bin_label): if isinstance(bin_label, list): return [self.binstr_to_list(dim) for dim in bin_label] else: return [self.binstr_to_list(bin_label)] def update(self): self.stat.set_data(self.values) def calculate(self): self.value = self.stat.value
class BoxGlyph(AggregateGlyph): """Summarizes the distribution with a collection of glyphs. A box glyph produces one "box" for a given array of vales. The box is made up of multiple other child composite glyphs (intervals, scatter) and directly produces glyph renderers for the whiskers, as well. """ q1 = Float(help="""Derived value for 25% of all values.""") q2 = Float(help="""Derived value for 50% of all values.""") q3 = Float(help="""Derived value for 75% of all values.""") iqr = Float() w0 = Float(help='Lower whisker') w1 = Float(help='Upper whisker') q2_glyph = Instance(QuartileGlyph) q3_glyph = Instance(QuartileGlyph) whisker_glyph = Instance(GlyphRenderer) outliers = Either(Bool, Instance(PointGlyph)) marker = String(default='circle') whisker_width = Float(default=0.3) whisker_line_width = Float(default=2) whisker_span_line_width = Float(default=2) whisker_color = String(default='black') outlier_fill_color = String(default='red') outlier_line_color = String(default='red') outlier_size = Float(default=5) bar_color = String(default='DimGrey') def __init__(self, label, values, outliers=True, **kwargs): width = kwargs.pop('width', None) bar_color = kwargs.pop('color', None) or kwargs.get( 'bar_color') or self.lookup('bar_color').class_default() kwargs['outliers'] = kwargs.pop('outliers', None) or outliers kwargs['label'] = label kwargs['values'] = values x_label = kwargs.get('x_label') kwargs['q2_glyph'] = QuartileGlyph(label=label, x_label=x_label, values=values, interval1=0.25, interval2=0.5, width=width, color=bar_color) kwargs['q3_glyph'] = QuartileGlyph(label=label, x_label=x_label, values=values, interval1=0.5, interval2=0.75, width=width, color=bar_color) super(BoxGlyph, self).__init__(**kwargs) self.setup() def build_renderers(self): """Yields all renderers that make up the BoxGlyph.""" self.calc_quartiles() outlier_values = self.values[((self.values < self.w0) | (self.values > self.w1))] self.whisker_glyph = GlyphRenderer( glyph=Segment(x0='x0s', y0='y0s', x1='x1s', y1='y1s', line_width=self.whisker_line_width, line_color=self.whisker_color)) if len(outlier_values) > 0 and self.outliers: self.outliers = PointGlyph(label=self.label, y=outlier_values, x=[self.get_dodge_label()] * len(outlier_values), line_color=self.outlier_line_color, fill_color=self.outlier_fill_color, size=self.outlier_size, marker=self.marker) for comp_glyph in self.composite_glyphs: for renderer in comp_glyph.renderers: yield renderer yield self.whisker_glyph def calc_quartiles(self): """Sets all derived stat properties of the BoxGlyph.""" self.q1 = self.q2_glyph.start self.q2 = self.q2_glyph.end self.q3 = self.q3_glyph.end self.iqr = self.q3 - self.q1 mx = Max() mx.set_data(self.values) mn = Min() mn.set_data(self.values) self.w0 = max(self.q1 - (1.5 * self.iqr), mn.value) self.w1 = min(self.q3 + (1.5 * self.iqr), mx.value) def build_source(self): """Calculate stats and builds and returns source for whiskers.""" self.calc_quartiles() x_label = self.get_dodge_label() x_w0_label = self.get_dodge_label(shift=(self.whisker_width / 2.0)) x_w1_label = self.get_dodge_label(shift=-(self.whisker_width / 2.0)) # span0, whisker bar0, span1, whisker bar1 x0s = [x_label, x_w0_label, x_label, x_w0_label] y0s = [self.w0, self.w0, self.q3, self.w1] x1s = [x_label, x_w1_label, x_label, x_w1_label] y1s = [self.q1, self.w0, self.w1, self.w1] return dict(x0s=x0s, y0s=y0s, x1s=x1s, y1s=y1s) def _set_sources(self): """Set the column data source on the whisker glyphs.""" self.whisker_glyph.data_source = self.source def get_extent(self, func, prop_name): return func([ getattr(renderer, prop_name) for renderer in self.composite_glyphs ]) @property def composite_glyphs(self): """Returns list of composite glyphs, excluding the regular glyph renderers.""" comp_glyphs = [self.q2_glyph, self.q3_glyph] if isinstance(self.outliers, PointGlyph): comp_glyphs.append(self.outliers) return comp_glyphs @property def x_max(self): return self.get_extent(max, 'x_max') + self.right_buffer @property def x_min(self): return self.get_extent(min, 'x_min') - self.left_buffer @property def y_max(self): return max(self.w1, self.get_extent(max, 'y_max')) + self.top_buffer @property def y_min(self): return min(self.w0, self.get_extent(min, 'y_min')) - self.bottom_buffer
class EitherSimpleDefault(hp.HasProps): foo = Either(List(Int), Int, default=10)