sources

AjaxDataSource

class AjaxDataSource(*args, **kwargs)[source]

Bases: bokeh.models.sources.WebDataSource

A data source that can populate columns by making Ajax calls to REST endpoints.

The AjaxDataSource can be especially useful if you want to make a standalone document (i.e. not backed by the Bokeh server) that can still dynamically update using an existing REST API.

The response from the REST API should match the .data property of a standard ColumnDataSource, i.e. a JSON dict that maps names to arrays of values:

{
    'x' : [1, 2, 3, ...],
    'y' : [9, 3, 2, ...]
}

Alternatively, if the REST API returns a different format, a CustomJS callback can be provided to convert the REST response into Bokeh format, via the adapter property of this data source.

Initial data can be set by specifying the data property directly. This is necessary when used in conjunction with a FactorRange, even if the columns in data` are empty.

A full example can be seen at examples/howto/ajax_source.py

JSON Prototype
{
  "adapter": null,
  "content_type": "application/json",
  "data": {},
  "http_headers": {},
  "id": "1182",
  "if_modified": false,
  "js_event_callbacks": {},
  "js_property_callbacks": {},
  "max_size": null,
  "method": "POST",
  "mode": "replace",
  "name": null,
  "polling_interval": null,
  "selected": {
    "id": "1184"
  },
  "selection_policy": {
    "id": "1183"
  },
  "subscribed_events": [],
  "syncable": true,
  "tags": []
}

Public Data Attributes:

polling_interval

A polling interval (in milliseconds) for updating data source.

method

Specify the HTTP method to use for the Ajax request (GET or POST)

if_modified

Whether to include an If-Modified-Since header in Ajax requests to the server.

content_type

Set the "contentType" parameter for the Ajax request.

http_headers

Specify HTTP headers to set for the Ajax request.

Inherited from : py: class:WebDataSource

adapter

A JavaScript callback to adapt raw JSON responses to Bokeh ColumnDataSource format.

max_size

Maximum size of the data columns.

mode

Whether to append new data to existing data (up to max_size), or to replace existing data entirely.

data_url

A URL to to fetch data from.

Inherited from : py: class:ColumnDataSource

column_names

A list of the column names in this data source.

data

Mapping of column names to sequences of data.

Inherited from : py: class:ColumnarDataSource

selection_policy

An instance of a SelectionPolicy that determines how selections are set.

Inherited from : py: class:DataSource

selected

An instance of a Selection that indicates selected indices on this DataSource.

Inherited from : py: class:Model

model_class_reverse_map

id

ref

struct

A Bokeh protocol "structure" of this model, i.e. a dict of the form:.

name

An arbitrary, user-supplied name for this model.

tags

An optional list of arbitrary, user-supplied values to attach to this model.

js_event_callbacks

A mapping of event names to lists of CustomJS callbacks.

subscribed_events

List of events that are subscribed to by Python callbacks.

js_property_callbacks

A mapping of attribute names to lists of CustomJS callbacks, to be set up on BokehJS side when the document is created.

syncable

Indicates whether this model should be synchronized back to a Bokeh server when updated in a web browser.

Inherited from : py: class:HasDocumentRef

document

The Document this model is attached to (can be None)

Public Methods:

Inherited from : py: class:ColumnDataSource

__init__(*args, **kwargs)

If called with a single argument that is a dict or pandas.DataFrame, treat that implicitly as the "data" attribute.

from_df(data)

Create a dict of columns from a Pandas DataFrame, suitable for creating a ColumnDataSource.

from_groupby(data)

Create a dict of columns from a Pandas GroupBy, suitable for creating a ColumnDataSource.

to_df()

Convert this data source to pandas DataFrame.

add(data[, name])

Appends a new column of data to the data source.

remove(name)

Remove a column of data.

stream(new_data[, rollover])

Efficiently update data source columns with new append-only data.

patch(patches[, setter])

Efficiently update data source columns at specific locations

Inherited from : py: class:Model

__init_subclass__()

This method is called when a class is subclassed.

__new__(cls, *args, **kwargs)

__init__(*args, **kwargs)

If called with a single argument that is a dict or pandas.DataFrame, treat that implicitly as the "data" attribute.

__str__()

Return str(self).

__repr__()

Return repr(self).

destroy()

Clean up references to the document and property

js_on_event(event, *callbacks)

js_link(attr, other, other_attr[, attr_selector])

Link two Bokeh model properties using JavaScript.

js_on_change(event, *callbacks)

Attach a CustomJS callback to an arbitrary BokehJS model event.

on_change(attr, *callbacks)

Add a callback on this object to trigger when attr changes.

references()

Returns all Models that this object has references to.

select(selector)

Query this object and all of its references for objects that match the given selector.

select_one(selector)

Query this object and all of its references for objects that match the given selector.

set_select(selector, updates)

Update objects that match a given selector with the specified attribute/value updates.

to_json(include_defaults)

Returns a dictionary of the attributes of this object, containing only "JSON types" (string, number, boolean, none, dict, list).

to_json_string(include_defaults)

Returns a JSON string encoding the attributes of this object.

trigger(attr, old, new[, hint, setter])

Inherited from : py: class:HasProps

__init__(*args, **kwargs)

If called with a single argument that is a dict or pandas.DataFrame, treat that implicitly as the "data" attribute.

__setattr__(name, value)

Intercept attribute setting on HasProps in order to special case a few situations:

__getattr__(name)

Intercept attribute setting on HasProps in order to special case a few situations:

__str__()

Return str(self).

__repr__()

Return repr(self).

equals(other)

Structural equality of models.

static_to_serializable(serializer)

to_serializable(serializer)

set_from_json(name, json, *[, models, setter])

Set a property value on this object from JSON.

update(**kwargs)

Updates the object's properties from the given keyword arguments.

update_from_json(json_attributes, *[, ...])

Updates the object's properties from a JSON attributes dictionary.

lookup(name, *[, raises])

Find the PropertyDescriptor for a Bokeh property on a class, given the property name.

properties(*[, _with_props])

Collect the names of properties on this class.

properties_with_refs()

Collect the names of all properties on this class that also have references.

dataspecs()

Collect the names of all DataSpec properties on this class.

properties_with_values(*[, ...])

Collect a dict mapping property names to their values.

query_properties_with_values(query, *[, ...])

Query the properties values of HasProps instances with a predicate.

themed_values()

Get any theme-provided overrides.

apply_theme(property_values)

Apply a set of theme values which will be used rather than defaults, but will not override application-set values.

unapply_theme()

Remove any themed values and restore defaults.

Inherited from : py: class:HasDocumentRef

__init__(*args, **kwargs)

If called with a single argument that is a dict or pandas.DataFrame, treat that implicitly as the "data" attribute.

Inherited from : py: class:PropertyCallbackManager

__init__(*args, **kwargs)

If called with a single argument that is a dict or pandas.DataFrame, treat that implicitly as the "data" attribute.

on_change(attr, *callbacks)

Add a callback on this object to trigger when attr changes.

remove_on_change(attr, *callbacks)

Remove a callback from this object

trigger(attr, old, new[, hint, setter])

Inherited from : py: class:EventCallbackManager

__init__(*args, **kwargs)

If called with a single argument that is a dict or pandas.DataFrame, treat that implicitly as the "data" attribute.

on_event(event, *callbacks)

Run callbacks when the specified event occurs on this Model


adapter = None
Type

Nullable(Instance(CustomJS))

A JavaScript callback to adapt raw JSON responses to Bokeh ColumnDataSource format.

If provided, this callback is executes immediately after the JSON data is received, but before appending or replacing data in the data source. The CustomJS callback will receive the AjaxDataSource as cb_obj and will receive the raw JSON response as cb_data.response. The callback code should return a data object suitable for a Bokeh ColumnDataSource (i.e. a mapping of string column names to arrays of data).

content_type = 'application/json'
Type

String

Set the “contentType” parameter for the Ajax request.

data = {}
Type

ColumnData

Mapping of column names to sequences of data. The columns can be, e.g, Python lists or tuples, NumPy arrays, etc.

The .data attribute can also be set from Pandas DataFrames or GroupBy objects. In these cases, the behaviour is identical to passing the objects to the ColumnDataSource initializer.

data_url = Undefined
Type

NonNullable(String)

A URL to to fetch data from.

http_headers = {}
Type

Dict(String, String)

Specify HTTP headers to set for the Ajax request.

Example:

ajax_source.headers = { 'x-my-custom-header': 'some value' }
if_modified = False
Type

Bool

Whether to include an If-Modified-Since header in Ajax requests to the server. If this header is supported by the server, then only new data since the last request will be returned.

max_size = None
Type

Nullable(Int)

Maximum size of the data columns. If a new fetch would result in columns larger than max_size, then earlier data is dropped to make room.

method = 'POST'
Type

Enum(Enumeration(POST, GET))

Specify the HTTP method to use for the Ajax request (GET or POST)

mode = 'replace'
Type

Enum(Enumeration(replace, append))

Whether to append new data to existing data (up to max_size), or to replace existing data entirely.

name = None
Type

Nullable(String)

An arbitrary, user-supplied name for this model.

This name can be useful when querying the document to retrieve specific Bokeh models.

>>> plot.circle([1,2,3], [4,5,6], name="temp")
>>> plot.select(name="temp")
[GlyphRenderer(id='399d53f5-73e9-44d9-9527-544b761c7705', ...)]

Note

No uniqueness guarantees or other conditions are enforced on any names that are provided, nor is the name used directly by Bokeh for any reason.

polling_interval = None
Type

Nullable(Int)

A polling interval (in milliseconds) for updating data source.

selected = Selection(id='1197', ...)
Type

Readonly

An instance of a Selection that indicates selected indices on this DataSource. This is a read-only property. You may only change the attributes of this object to change the selection (e.g., selected.indices).

selection_policy = UnionRenderers(id='1199', ...)
Type

Instance(SelectionPolicy)

An instance of a SelectionPolicy that determines how selections are set.

syncable = True
Type

Bool

Indicates whether this model should be synchronized back to a Bokeh server when updated in a web browser. Setting to False may be useful to reduce network traffic when dealing with frequently updated objects whose updated values we don’t need.

Note

Setting this property to False will prevent any on_change() callbacks on this object from triggering. However, any JS-side callbacks will still work.

tags = []
Type

List

An optional list of arbitrary, user-supplied values to attach to this model.

This data can be useful when querying the document to retrieve specific Bokeh models:

>>> r = plot.circle([1,2,3], [4,5,6])
>>> r.tags = ["foo", 10]
>>> plot.select(tags=['foo', 10])
[GlyphRenderer(id='1de4c3df-a83d-480a-899b-fb263d3d5dd9', ...)]

Or simply a convenient way to attach any necessary metadata to a model that can be accessed by CustomJS callbacks, etc.

Note

No uniqueness guarantees or other conditions are enforced on any tags that are provided, nor are the tags used directly by Bokeh for any reason.

__init__(*args: Any, **kwargs: Any) None

If called with a single argument that is a dict or pandas.DataFrame, treat that implicitly as the “data” attribute.

add(data: Sequence[Unknown], name: str | None = None) str

Appends a new column of data to the data source.

Parameters
  • data (seq) – new data to add

  • name (str, optional) – column name to use. If not supplied, generate a name of the form “Series ####”

Returns

the column name used

Return type

str

apply_theme(property_values: Dict[str, Any]) None

Apply a set of theme values which will be used rather than defaults, but will not override application-set values.

The passed-in dictionary may be kept around as-is and shared with other instances to save memory (so neither the caller nor the HasProps instance should modify it).

Parameters

property_values (dict) – theme values to use in place of defaults

Returns

None

classmethod dataspecs() Dict[str, DataSpec]

Collect the names of all DataSpec properties on this class.

This method always traverses the class hierarchy and includes properties defined on any parent classes.

Returns

names of DataSpec properties

Return type

set[str]

destroy() None

Clean up references to the document and property

equals(other: bokeh.core.has_props.HasProps) bool

Structural equality of models.

Parameters

other (HasProps) – the other instance to compare to

Returns

True, if properties are structurally equal, otherwise False

classmethod from_df(data: pd.DataFrame) DataDict

Create a dict of columns from a Pandas DataFrame, suitable for creating a ColumnDataSource.

Parameters

data (DataFrame) – data to convert

Returns

dict[str, np.array]

classmethod from_groupby(data: pd.core.groupby.GroupBy) DataDict

Create a dict of columns from a Pandas GroupBy, suitable for creating a ColumnDataSource.

The data generated is the result of running describe on the group.

Parameters

data (Groupby) – data to convert

Returns

dict[str, np.array]

Link two Bokeh model properties using JavaScript.

This is a convenience method that simplifies adding a CustomJS callback to update one Bokeh model property whenever another changes value.

Parameters
  • attr (str) – The name of a Bokeh property on this model

  • other (Model) – A Bokeh model to link to self.attr

  • other_attr (str) – The property on other to link together

  • attr_selector (Union[int, str]) – The index to link an item in a subscriptable attr

Added in version 1.1

Raises

ValueError

Examples

This code with js_link:

select.js_link('value', plot, 'sizing_mode')

is equivalent to the following:

from bokeh.models import CustomJS
select.js_on_change('value',
    CustomJS(args=dict(other=plot),
             code="other.sizing_mode = this.value"
    )
)

Additionally, to use attr_selector to attach the left side of a range slider to a plot’s x_range:

range_slider.js_link('value', plot.x_range, 'start', attr_selector=0)

which is equivalent to:

from bokeh.models import CustomJS
range_slider.js_on_change('value',
    CustomJS(args=dict(other=plot.x_range),
             code="other.start = this.value[0]"
    )
)
js_on_change(event: str, *callbacks: JSEventCallback) None

Attach a CustomJS callback to an arbitrary BokehJS model event.

On the BokehJS side, change events for model properties have the form "change:property_name". As a convenience, if the event name passed to this method is also the name of a property on the model, then it will be prefixed with "change:" automatically:

# these two are equivalent
source.js_on_change('data', callback)
source.js_on_change('change:data', callback)

However, there are other kinds of events that can be useful to respond to, in addition to property change events. For example to run a callback whenever data is streamed to a ColumnDataSource, use the "stream" event on the source:

source.js_on_change('streaming', callback)
classmethod lookup(name: str, *, raises: bool = True) Optional[bokeh.core.property.descriptors.PropertyDescriptor[Any]]

Find the PropertyDescriptor for a Bokeh property on a class, given the property name.

Parameters
  • name (str) – name of the property to search for

  • raises (bool) – whether to raise or return None if missing

Returns

descriptor for property named name

Return type

PropertyDescriptor

on_change(attr: str, *callbacks: PropertyCallback) None

Add a callback on this object to trigger when attr changes.

Parameters
  • attr (str) – an attribute name on this object

  • *callbacks (callable) – callback functions to register

Returns

None

Example:

widget.on_change('value', callback1, callback2, ..., callback_n)
on_event(event: Union[str, Type[bokeh.events.Event]], *callbacks: Union[Callable[[bokeh.events.Event], None], Callable[[], None]]) None

Run callbacks when the specified event occurs on this Model

Not all Events are supported for all Models. See specific Events in bokeh.events for more information on which Models are able to trigger them.

patch(patches: Patches, setter: Setter | None = None) None

Efficiently update data source columns at specific locations

If it is only necessary to update a small subset of data in a ColumnDataSource, this method can be used to efficiently update only the subset, instead of requiring the entire data set to be sent.

This method should be passed a dictionary that maps column names to lists of tuples that describe a patch change to apply. To replace individual items in columns entirely, the tuples should be of the form:

(index, new_value)  # replace a single column value

# or

(slice, new_values) # replace several column values

Values at an index or slice will be replaced with the corresponding new values.

In the case of columns whose values are other arrays or lists, (e.g. image or patches glyphs), it is also possible to patch “subregions”. In this case the first item of the tuple should be a whose first element is the index of the array item in the CDS patch, and whose subsequent elements are integer indices or slices into the array item:

# replace the entire 10th column of the 2nd array:

  +----------------- index of item in column data source
  |
  |       +--------- row subindex into array item
  |       |
  |       |       +- column subindex into array item
  V       V       V
([2, slice(None), 10], new_values)

Imagining a list of 2d NumPy arrays, the patch above is roughly equivalent to:

data = [arr1, arr2, ...]  # list of 2d arrays

data[2][:, 10] = new_data

There are some limitations to the kinds of slices and data that can be accepted.

  • Negative start, stop, or step values for slices will result in a ValueError.

  • In a slice, start > stop will result in a ValueError

  • When patching 1d or 2d subitems, the subitems must be NumPy arrays.

  • New values must be supplied as a flattened one-dimensional array of the appropriate size.

Parameters

patches (dict[str, list[tuple]]) – lists of patches for each column

Returns

None

Raises

ValueError

Example:

The following example shows how to patch entire column elements. In this case,

source = ColumnDataSource(data=dict(foo=[10, 20, 30], bar=[100, 200, 300]))

patches = {
    'foo' : [ (slice(2), [11, 12]) ],
    'bar' : [ (0, 101), (2, 301) ],
}

source.patch(patches)

After this operation, the value of the source.data will be:

dict(foo=[11, 12, 30], bar=[101, 200, 301])

For a more comprehensive complete example, see examples/howto/patch_app.py.

classmethod properties(*, _with_props: bool = False) Union[Set[str], Dict[str, Property[Any]]]

Collect the names of properties on this class.

Warning

In a future version of Bokeh, this method will return a dictionary mapping property names to property objects. To future-proof this current usage of this method, wrap the return value in list.

Returns

property names

classmethod properties_with_refs() Dict[str, Property[Any]]

Collect the names of all properties on this class that also have references.

This method always traverses the class hierarchy and includes properties defined on any parent classes.

Returns

names of properties that have references

Return type

set[str]

properties_with_values(*, include_defaults: bool = True, include_undefined: bool = False) Dict[str, Any]

Collect a dict mapping property names to their values.

This method always traverses the class hierarchy and includes properties defined on any parent classes.

Non-serializable properties are skipped and property values are in “serialized” format which may be slightly different from the values you would normally read from the properties; the intent of this method is to return the information needed to losslessly reconstitute the object instance.

Parameters

include_defaults (bool, optional) – Whether to include properties that haven’t been explicitly set since the object was created. (default: True)

Returns

mapping from property names to their values

Return type

dict

query_properties_with_values(query: Callable[[bokeh.core.property.descriptors.PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) Dict[str, Any]

Query the properties values of HasProps instances with a predicate.

Parameters
  • query (callable) – A callable that accepts property descriptors and returns True or False

  • include_defaults (bool, optional) – Whether to include properties that have not been explicitly set by a user (default: True)

Returns

mapping of property names and values for matching properties

Return type

dict

references() Set[bokeh.model.model.Model]

Returns all Models that this object has references to.

remove(name: str) None

Remove a column of data.

Parameters

name (str) – name of the column to remove

Returns

None

Note

If the column name does not exist, a warning is issued.

remove_on_change(attr: str, *callbacks: Callable[[str, Any, Any], None]) None

Remove a callback from this object

select(selector: SelectorType) Iterable[Model]

Query this object and all of its references for objects that match the given selector.

Parameters

selector (JSON-like) –

Returns

seq[Model]

select_one(selector: SelectorType) Model | None

Query this object and all of its references for objects that match the given selector. Raises an error if more than one object is found. Returns single matching object, or None if nothing is found :param selector: :type selector: JSON-like

Returns

Model

set_from_json(name: str, json: JSON, *, models: Dict[ID, HasProps] | None = None, setter: Setter | None = None) None

Set a property value on this object from JSON.

Parameters
  • name – (str) : name of the attribute to set

  • json – (JSON-value) : value to set to the attribute to

  • models (dict or None, optional) –

    Mapping of model ids to models (default: None)

    This is needed in cases where the attributes to update also have values that have references.

  • setter (ClientSession or ServerSession or None, optional) –

    This is used to prevent “boomerang” updates to Bokeh apps.

    In the context of a Bokeh server application, incoming updates to properties will be annotated with the session that is doing the updating. This value is propagated through any subsequent change notifications that the update triggers. The session can compare the event setter to itself, and suppress any updates that originate from itself.

Returns

None

set_select(selector: Type[Model] | SelectorType, updates: Dict[str, Unknown]) None

Update objects that match a given selector with the specified attribute/value updates.

Parameters
  • selector (JSON-like) –

  • updates (dict) –

Returns

None

stream(new_data: DataDict, rollover: int | None = None) None

Efficiently update data source columns with new append-only data.

In cases where it is necessary to update data columns in, this method can efficiently send only the new data, instead of requiring the entire data set to be re-sent.

Parameters
  • new_data (dict[str, seq]) –

    a mapping of column names to sequences of new data to append to each column.

    All columns of the data source must be present in new_data, with identical-length append data.

  • rollover (int, optional) – A maximum column size, above which data from the start of the column begins to be discarded. If None, then columns will continue to grow unbounded (default: None)

Returns

None

Raises

ValueError

Example:

source = ColumnDataSource(data=dict(foo=[], bar=[]))

# has new, identical-length updates for all columns in source
new_data = {
    'foo' : [10, 20],
    'bar' : [100, 200],
}

source.stream(new_data)
themed_values() Optional[Dict[str, Any]]

Get any theme-provided overrides.

Results are returned as a dict from property name to value, or None if no theme overrides any values for this instance.

Returns

dict or None

to_df() pandas.core.frame.DataFrame

Convert this data source to pandas DataFrame.

Returns

DataFrame

to_json(include_defaults: bool) JSON

Returns a dictionary of the attributes of this object, containing only “JSON types” (string, number, boolean, none, dict, list).

References to other objects are serialized as “refs” (just the object ID and type info), so the deserializer will need to separately have the full attributes of those other objects.

There’s no corresponding from_json() because to deserialize an object is normally done in the context of a Document (since the Document can resolve references).

For most purposes it’s best to serialize and deserialize entire documents.

Parameters

include_defaults (bool) – whether to include attributes that haven’t been changed from the default

to_json_string(include_defaults: bool) str

Returns a JSON string encoding the attributes of this object.

References to other objects are serialized as references (just the object ID and type info), so the deserializer will need to separately have the full attributes of those other objects.

There’s no corresponding from_json_string() because to deserialize an object is normally done in the context of a Document (since the Document can resolve references).

For most purposes it’s best to serialize and deserialize entire documents.

Parameters

include_defaults (bool) – whether to include attributes that haven’t been changed from the default

trigger(attr: str, old: Unknown, new: Unknown, hint: DocumentPatchedEvent | None = None, setter: Setter | None = None) None
unapply_theme() None

Remove any themed values and restore defaults.

Returns

None

update(**kwargs: Any) None

Updates the object’s properties from the given keyword arguments.

Returns

None

Examples

The following are equivalent:

from bokeh.models import Range1d

r = Range1d

# set properties individually:
r.start = 10
r.end = 20

# update properties together:
r.update(start=10, end=20)
update_from_json(json_attributes: Dict[str, JSON], *, models: Mapping[ID, HasProps] | None = None, setter: Setter | None = None) None

Updates the object’s properties from a JSON attributes dictionary.

Parameters
  • json_attributes – (JSON-dict) : attributes and values to update

  • models (dict or None, optional) –

    Mapping of model ids to models (default: None)

    This is needed in cases where the attributes to update also have values that have references.

  • setter (ClientSession or ServerSession or None, optional) –

    This is used to prevent “boomerang” updates to Bokeh apps.

    In the context of a Bokeh server application, incoming updates to properties will be annotated with the session that is doing the updating. This value is propagated through any subsequent change notifications that the update triggers. The session can compare the event setter to itself, and suppress any updates that originate from itself.

Returns

None

property column_names: List[str]

A list of the column names in this data source.

property document: Document | None

The Document this model is attached to (can be None)

property struct: bokeh.core.types.ReferenceJson

A Bokeh protocol “structure” of this model, i.e. a dict of the form:

{
    'type' : << view model name >>
    'id'   : << unique model id >>
}

Additionally there may be a subtype field if this model is a subtype.

CDSView

class CDSView(*args, **kwargs)[source]

Bases: bokeh.model.model.Model

A view into a ColumnDataSource that represents a row-wise subset.

JSON Prototype
{
  "filters": [],
  "id": "1202",
  "js_event_callbacks": {},
  "js_property_callbacks": {},
  "name": null,
  "subscribed_events": [],
  "syncable": true,
  "tags": []
}

Public Data Attributes:

filters

List of filters that the view comprises.

source

The ColumnDataSource associated with this view.

Inherited from : py: class:Model

model_class_reverse_map

id

ref

struct

A Bokeh protocol "structure" of this model, i.e. a dict of the form:.

name

An arbitrary, user-supplied name for this model.

tags

An optional list of arbitrary, user-supplied values to attach to this model.

js_event_callbacks

A mapping of event names to lists of CustomJS callbacks.

subscribed_events

List of events that are subscribed to by Python callbacks.

js_property_callbacks

A mapping of attribute names to lists of CustomJS callbacks, to be set up on BokehJS side when the document is created.

syncable

Indicates whether this model should be synchronized back to a Bokeh server when updated in a web browser.

Inherited from : py: class:HasDocumentRef

document

The Document this model is attached to (can be None)

Public Methods:

Inherited from : py: class:Model

__init_subclass__()

This method is called when a class is subclassed.

__new__(cls, *args, **kwargs)

__init__(**kwargs)

__str__()

Return str(self).

__repr__()

Return repr(self).

destroy()

Clean up references to the document and property

js_on_event(event, *callbacks)

js_link(attr, other, other_attr[, attr_selector])

Link two Bokeh model properties using JavaScript.

js_on_change(event, *callbacks)

Attach a CustomJS callback to an arbitrary BokehJS model event.

on_change(attr, *callbacks)

Add a callback on this object to trigger when attr changes.

references()

Returns all Models that this object has references to.

select(selector)

Query this object and all of its references for objects that match the given selector.

select_one(selector)

Query this object and all of its references for objects that match the given selector.

set_select(selector, updates)

Update objects that match a given selector with the specified attribute/value updates.

to_json(include_defaults)

Returns a dictionary of the attributes of this object, containing only "JSON types" (string, number, boolean, none, dict, list).

to_json_string(include_defaults)

Returns a JSON string encoding the attributes of this object.

trigger(attr, old, new[, hint, setter])

Inherited from : py: class:HasProps

__init__(**kwargs)

__setattr__(name, value)

Intercept attribute setting on HasProps in order to special case a few situations:

__getattr__(name)

Intercept attribute setting on HasProps in order to special case a few situations:

__str__()

Return str(self).

__repr__()

Return repr(self).

equals(other)

Structural equality of models.

static_to_serializable(serializer)

to_serializable(serializer)

set_from_json(name, json, *[, models, setter])

Set a property value on this object from JSON.

update(**kwargs)

Updates the object's properties from the given keyword arguments.

update_from_json(json_attributes, *[, ...])

Updates the object's properties from a JSON attributes dictionary.

lookup(name, *[, raises])

Find the PropertyDescriptor for a Bokeh property on a class, given the property name.

properties(*[, _with_props])

Collect the names of properties on this class.

properties_with_refs()

Collect the names of all properties on this class that also have references.

dataspecs()

Collect the names of all DataSpec properties on this class.

properties_with_values(*[, ...])

Collect a dict mapping property names to their values.

query_properties_with_values(query, *[, ...])

Query the properties values of HasProps instances with a predicate.

themed_values()

Get any theme-provided overrides.

apply_theme(property_values)

Apply a set of theme values which will be used rather than defaults, but will not override application-set values.

unapply_theme()

Remove any themed values and restore defaults.

Inherited from : py: class:HasDocumentRef

__init__(**kwargs)

Inherited from : py: class:PropertyCallbackManager

__init__(**kwargs)

on_change(attr, *callbacks)

Add a callback on this object to trigger when attr changes.

remove_on_change(attr, *callbacks)

Remove a callback from this object

trigger(attr, old, new[, hint, setter])

Inherited from : py: class:EventCallbackManager

__init__(**kwargs)

on_event(event, *callbacks)

Run callbacks when the specified event occurs on this Model


filters = []
Type

List

List of filters that the view comprises.

name = None
Type

Nullable(String)

An arbitrary, user-supplied name for this model.

This name can be useful when querying the document to retrieve specific Bokeh models.

>>> plot.circle([1,2,3], [4,5,6], name="temp")
>>> plot.select(name="temp")
[GlyphRenderer(id='399d53f5-73e9-44d9-9527-544b761c7705', ...)]

Note

No uniqueness guarantees or other conditions are enforced on any names that are provided, nor is the name used directly by Bokeh for any reason.

source = Undefined
Type

Instance(ColumnarDataSource)

The ColumnDataSource associated with this view. Used to determine the length of the columns.

syncable = True
Type

Bool

Indicates whether this model should be synchronized back to a Bokeh server when updated in a web browser. Setting to False may be useful to reduce network traffic when dealing with frequently updated objects whose updated values we don’t need.

Note

Setting this property to False will prevent any on_change() callbacks on this object from triggering. However, any JS-side callbacks will still work.

tags = []
Type

List

An optional list of arbitrary, user-supplied values to attach to this model.

This data can be useful when querying the document to retrieve specific Bokeh models:

>>> r = plot.circle([1,2,3], [4,5,6])
>>> r.tags = ["foo", 10]
>>> plot.select(tags=['foo', 10])
[GlyphRenderer(id='1de4c3df-a83d-480a-899b-fb263d3d5dd9', ...)]

Or simply a convenient way to attach any necessary metadata to a model that can be accessed by CustomJS callbacks, etc.

Note

No uniqueness guarantees or other conditions are enforced on any tags that are provided, nor are the tags used directly by Bokeh for any reason.

apply_theme(property_values: Dict[str, Any]) None

Apply a set of theme values which will be used rather than defaults, but will not override application-set values.

The passed-in dictionary may be kept around as-is and shared with other instances to save memory (so neither the caller nor the HasProps instance should modify it).

Parameters

property_values (dict) – theme values to use in place of defaults

Returns

None

classmethod dataspecs() Dict[str, DataSpec]

Collect the names of all DataSpec properties on this class.

This method always traverses the class hierarchy and includes properties defined on any parent classes.

Returns

names of DataSpec properties

Return type

set[str]

destroy() None

Clean up references to the document and property

equals(other: bokeh.core.has_props.HasProps) bool

Structural equality of models.

Parameters

other (HasProps) – the other instance to compare to

Returns

True, if properties are structurally equal, otherwise False

Link two Bokeh model properties using JavaScript.

This is a convenience method that simplifies adding a CustomJS callback to update one Bokeh model property whenever another changes value.

Parameters
  • attr (str) – The name of a Bokeh property on this model

  • other (Model) – A Bokeh model to link to self.attr

  • other_attr (str) – The property on other to link together

  • attr_selector (Union[int, str]) – The index to link an item in a subscriptable attr

Added in version 1.1

Raises

ValueError

Examples

This code with js_link:

select.js_link('value', plot, 'sizing_mode')

is equivalent to the following:

from bokeh.models import CustomJS
select.js_on_change('value',
    CustomJS(args=dict(other=plot),
             code="other.sizing_mode = this.value"
    )
)

Additionally, to use attr_selector to attach the left side of a range slider to a plot’s x_range:

range_slider.js_link('value', plot.x_range, 'start', attr_selector=0)

which is equivalent to:

from bokeh.models import CustomJS
range_slider.js_on_change('value',
    CustomJS(args=dict(other=plot.x_range),
             code="other.start = this.value[0]"
    )
)
js_on_change(event: str, *callbacks: JSEventCallback) None

Attach a CustomJS callback to an arbitrary BokehJS model event.

On the BokehJS side, change events for model properties have the form "change:property_name". As a convenience, if the event name passed to this method is also the name of a property on the model, then it will be prefixed with "change:" automatically:

# these two are equivalent
source.js_on_change('data', callback)
source.js_on_change('change:data', callback)

However, there are other kinds of events that can be useful to respond to, in addition to property change events. For example to run a callback whenever data is streamed to a ColumnDataSource, use the "stream" event on the source:

source.js_on_change('streaming', callback)
classmethod lookup(name: str, *, raises: bool = True) Optional[bokeh.core.property.descriptors.PropertyDescriptor[Any]]

Find the PropertyDescriptor for a Bokeh property on a class, given the property name.

Parameters
  • name (str) – name of the property to search for

  • raises (bool) – whether to raise or return None if missing

Returns

descriptor for property named name

Return type

PropertyDescriptor

on_change(attr: str, *callbacks: PropertyCallback) None

Add a callback on this object to trigger when attr changes.

Parameters
  • attr (str) – an attribute name on this object

  • *callbacks (callable) – callback functions to register

Returns

None

Example:

widget.on_change('value', callback1, callback2, ..., callback_n)
on_event(event: Union[str, Type[bokeh.events.Event]], *callbacks: Union[Callable[[bokeh.events.Event], None], Callable[[], None]]) None

Run callbacks when the specified event occurs on this Model

Not all Events are supported for all Models. See specific Events in bokeh.events for more information on which Models are able to trigger them.

classmethod properties(*, _with_props: bool = False) Union[Set[str], Dict[str, Property[Any]]]

Collect the names of properties on this class.

Warning

In a future version of Bokeh, this method will return a dictionary mapping property names to property objects. To future-proof this current usage of this method, wrap the return value in list.

Returns

property names

classmethod properties_with_refs() Dict[str, Property[Any]]

Collect the names of all properties on this class that also have references.

This method always traverses the class hierarchy and includes properties defined on any parent classes.

Returns

names of properties that have references

Return type

set[str]

properties_with_values(*, include_defaults: bool = True, include_undefined: bool = False) Dict[str, Any]

Collect a dict mapping property names to their values.

This method always traverses the class hierarchy and includes properties defined on any parent classes.

Non-serializable properties are skipped and property values are in “serialized” format which may be slightly different from the values you would normally read from the properties; the intent of this method is to return the information needed to losslessly reconstitute the object instance.

Parameters

include_defaults (bool, optional) – Whether to include properties that haven’t been explicitly set since the object was created. (default: True)

Returns

mapping from property names to their values

Return type

dict

query_properties_with_values(query: Callable[[bokeh.core.property.descriptors.PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) Dict[str, Any]

Query the properties values of HasProps instances with a predicate.

Parameters
  • query (callable) – A callable that accepts property descriptors and returns True or False

  • include_defaults (bool, optional) – Whether to include properties that have not been explicitly set by a user (default: True)

Returns

mapping of property names and values for matching properties

Return type

dict

references() Set[bokeh.model.model.Model]

Returns all Models that this object has references to.

remove_on_change(attr: str, *callbacks: Callable[[str, Any, Any], None]) None

Remove a callback from this object

select(selector: SelectorType) Iterable[Model]

Query this object and all of its references for objects that match the given selector.

Parameters

selector (JSON-like) –

Returns

seq[Model]

select_one(selector: SelectorType) Model | None

Query this object and all of its references for objects that match the given selector. Raises an error if more than one object is found. Returns single matching object, or None if nothing is found :param selector: :type selector: JSON-like

Returns

Model

set_from_json(name: str, json: JSON, *, models: Dict[ID, HasProps] | None = None, setter: Setter | None = None) None

Set a property value on this object from JSON.

Parameters
  • name – (str) : name of the attribute to set

  • json – (JSON-value) : value to set to the attribute to

  • models (dict or None, optional) –

    Mapping of model ids to models (default: None)

    This is needed in cases where the attributes to update also have values that have references.

  • setter (ClientSession or ServerSession or None, optional) –

    This is used to prevent “boomerang” updates to Bokeh apps.

    In the context of a Bokeh server application, incoming updates to properties will be annotated with the session that is doing the updating. This value is propagated through any subsequent change notifications that the update triggers. The session can compare the event setter to itself, and suppress any updates that originate from itself.

Returns

None

set_select(selector: Type[Model] | SelectorType, updates: Dict[str, Unknown]) None

Update objects that match a given selector with the specified attribute/value updates.

Parameters
  • selector (JSON-like) –

  • updates (dict) –

Returns

None

themed_values() Optional[Dict[str, Any]]

Get any theme-provided overrides.

Results are returned as a dict from property name to value, or None if no theme overrides any values for this instance.

Returns

dict or None

to_json(include_defaults: bool) JSON

Returns a dictionary of the attributes of this object, containing only “JSON types” (string, number, boolean, none, dict, list).

References to other objects are serialized as “refs” (just the object ID and type info), so the deserializer will need to separately have the full attributes of those other objects.

There’s no corresponding from_json() because to deserialize an object is normally done in the context of a Document (since the Document can resolve references).

For most purposes it’s best to serialize and deserialize entire documents.

Parameters

include_defaults (bool) – whether to include attributes that haven’t been changed from the default

to_json_string(include_defaults: bool) str

Returns a JSON string encoding the attributes of this object.

References to other objects are serialized as references (just the object ID and type info), so the deserializer will need to separately have the full attributes of those other objects.

There’s no corresponding from_json_string() because to deserialize an object is normally done in the context of a Document (since the Document can resolve references).

For most purposes it’s best to serialize and deserialize entire documents.

Parameters

include_defaults (bool) – whether to include attributes that haven’t been changed from the default

trigger(attr: str, old: Unknown, new: Unknown, hint: DocumentPatchedEvent | None = None, setter: Setter | None = None) None
unapply_theme() None

Remove any themed values and restore defaults.

Returns

None

update(**kwargs: Any) None

Updates the object’s properties from the given keyword arguments.

Returns

None

Examples

The following are equivalent:

from bokeh.models import Range1d

r = Range1d

# set properties individually:
r.start = 10
r.end = 20

# update properties together:
r.update(start=10, end=20)
update_from_json(json_attributes: Dict[str, JSON], *, models: Mapping[ID, HasProps] | None = None, setter: Setter | None = None) None

Updates the object’s properties from a JSON attributes dictionary.

Parameters
  • json_attributes – (JSON-dict) : attributes and values to update

  • models (dict or None, optional) –

    Mapping of model ids to models (default: None)

    This is needed in cases where the attributes to update also have values that have references.

  • setter (ClientSession or ServerSession or None, optional) –

    This is used to prevent “boomerang” updates to Bokeh apps.

    In the context of a Bokeh server application, incoming updates to properties will be annotated with the session that is doing the updating. This value is propagated through any subsequent change notifications that the update triggers. The session can compare the event setter to itself, and suppress any updates that originate from itself.

Returns

None

property document: Document | None

The Document this model is attached to (can be None)

property struct: bokeh.core.types.ReferenceJson

A Bokeh protocol “structure” of this model, i.e. a dict of the form:

{
    'type' : << view model name >>
    'id'   : << unique model id >>
}

Additionally there may be a subtype field if this model is a subtype.

ColumnDataSource

class ColumnDataSource(*args, **kwargs)[source]

Bases: bokeh.models.sources.ColumnarDataSource

Maps names of columns to sequences or arrays.

The ColumnDataSource is a fundamental data structure of Bokeh. Most plots, data tables, etc. will be driven by a ColumnDataSource.

If the ColumnDataSource initializer is called with a single argument that can be any of the following:

  • A Python dict that maps string names to sequences of values, e.g. lists, arrays, etc.

    data = {'x': [1,2,3,4], 'y': np.array([10.0, 20.0, 30.0, 40.0])}
    
    source = ColumnDataSource(data)
    

Note

ColumnDataSource only creates a shallow copy of data. Use e.g. ColumnDataSource(copy.deepcopy(data)) if initializing from another ColumnDataSource.data object that you want to keep independent.

  • A Pandas DataFrame object

    source = ColumnDataSource(df)
    

    In this case the CDS will have columns corresponding to the columns of the DataFrame. If the DataFrame columns have multiple levels, they will be flattened using an underscore (e.g. level_0_col_level_1_col). The index of the DataFrame will be flattened to an Index of tuples if it’s a MultiIndex, and then reset using reset_index. The result will be a column with the same name if the index was named, or level_0_name_level_1_name if it was a named MultiIndex. If the Index did not have a name or the MultiIndex name could not be flattened/determined, the reset_index function will name the index column index, or level_0 if the name index is not available.

  • A Pandas GroupBy object

    group = df.groupby(('colA', 'ColB'))
    

    In this case the CDS will have columns corresponding to the result of calling group.describe(). The describe method generates columns for statistical measures such as mean and count for all the non-grouped original columns. The CDS columns are formed by joining original column names with the computed measure. For example, if a DataFrame has columns 'year' and 'mpg'. Then passing df.groupby('year') to a CDS will result in columns such as 'mpg_mean'

    If the GroupBy.describe result has a named index column, then CDS will also have a column with this name. However, if the index name (or any subname of a MultiIndex) is None, then the CDS will have a column generically named index for the index.

    Note this capability to adapt GroupBy objects may only work with Pandas >=0.20.0.

Note

There is an implicit assumption that all the columns in a given ColumnDataSource all have the same length at all times. For this reason, it is usually preferable to update the .data property of a data source “all at once”.

JSON Prototype
{
  "data": {},
  "id": "1208",
  "js_event_callbacks": {},
  "js_property_callbacks": {},
  "name": null,
  "selected": {
    "id": "1210"
  },
  "selection_policy": {
    "id": "1209"
  },
  "subscribed_events": [],
  "syncable": true,
  "tags": []
}

Public Data Attributes:

column_names

A list of the column names in this data source.

data

Mapping of column names to sequences of data.

Inherited from : py: class:ColumnarDataSource

selection_policy

An instance of a SelectionPolicy that determines how selections are set.

Inherited from : py: class:DataSource

selected

An instance of a Selection that indicates selected indices on this DataSource.

Inherited from : py: class:Model

model_class_reverse_map

id

ref

struct

A Bokeh protocol "structure" of this model, i.e. a dict of the form:.

name

An arbitrary, user-supplied name for this model.

tags

An optional list of arbitrary, user-supplied values to attach to this model.

js_event_callbacks

A mapping of event names to lists of CustomJS callbacks.

subscribed_events

List of events that are subscribed to by Python callbacks.

js_property_callbacks

A mapping of attribute names to lists of CustomJS callbacks, to be set up on BokehJS side when the document is created.

syncable

Indicates whether this model should be synchronized back to a Bokeh server when updated in a web browser.

Inherited from : py: class:HasDocumentRef

document

The Document this model is attached to (can be None)

Public Methods:

__init__()

If called with a single argument that is a dict or pandas.DataFrame, treat that implicitly as the "data" attribute.

from_df(data)

Create a dict of columns from a Pandas DataFrame, suitable for creating a ColumnDataSource.

from_groupby(data)

Create a dict of columns from a Pandas GroupBy, suitable for creating a ColumnDataSource.

to_df()

Convert this data source to pandas DataFrame.

add(data[, name])

Appends a new column of data to the data source.

remove(name)

Remove a column of data.

stream(new_data[, rollover])

Efficiently update data source columns with new append-only data.

patch(patches[, setter])

Efficiently update data source columns at specific locations

Inherited from : py: class:Model

__init_subclass__()

This method is called when a class is subclassed.

__new__(cls, *args, **kwargs)

__init__()

If called with a single argument that is a dict or pandas.DataFrame, treat that implicitly as the "data" attribute.

__str__()

Return str(self).

__repr__()

Return repr(self).

destroy()

Clean up references to the document and property

js_on_event(event, *callbacks)

js_link(attr, other, other_attr[, attr_selector])

Link two Bokeh model properties using JavaScript.

js_on_change(event, *callbacks)

Attach a CustomJS callback to an arbitrary BokehJS model event.

on_change(attr, *callbacks)

Add a callback on this object to trigger when attr changes.

references()

Returns all Models that this object has references to.

select(selector)

Query this object and all of its references for objects that match the given selector.

select_one(selector)

Query this object and all of its references for objects that match the given selector.

set_select(selector, updates)

Update objects that match a given selector with the specified attribute/value updates.

to_json(include_defaults)

Returns a dictionary of the attributes of this object, containing only "JSON types" (string, number, boolean, none, dict, list).

to_json_string(include_defaults)

Returns a JSON string encoding the attributes of this object.

trigger(attr, old, new[, hint, setter])

Inherited from : py: class:HasProps

__init__()

If called with a single argument that is a dict or pandas.DataFrame, treat that implicitly as the "data" attribute.

__setattr__(name, value)

Intercept attribute setting on HasProps in order to special case a few situations:

__getattr__(name)

Intercept attribute setting on HasProps in order to special case a few situations:

__str__()

Return str(self).

__repr__()

Return repr(self).

equals(other)

Structural equality of models.

static_to_serializable(serializer)

to_serializable(serializer)

set_from_json(name, json, *[, models, setter])

Set a property value on this object from JSON.

update(**kwargs)

Updates the object's properties from the given keyword arguments.

update_from_json(json_attributes, *[, ...])

Updates the object's properties from a JSON attributes dictionary.

lookup(name, *[, raises])

Find the PropertyDescriptor for a Bokeh property on a class, given the property name.

properties(*[, _with_props])

Collect the names of properties on this class.

properties_with_refs()

Collect the names of all properties on this class that also have references.

dataspecs()

Collect the names of all DataSpec properties on this class.

properties_with_values(*[, ...])

Collect a dict mapping property names to their values.

query_properties_with_values(query, *[, ...])

Query the properties values of HasProps instances with a predicate.

themed_values()

Get any theme-provided overrides.

apply_theme(property_values)

Apply a set of theme values which will be used rather than defaults, but will not override application-set values.

unapply_theme()

Remove any themed values and restore defaults.

Inherited from : py: class:HasDocumentRef

__init__()

If called with a single argument that is a dict or pandas.DataFrame, treat that implicitly as the "data" attribute.

Inherited from : py: class:PropertyCallbackManager

__init__()

If called with a single argument that is a dict or pandas.DataFrame, treat that implicitly as the "data" attribute.

on_change(attr, *callbacks)

Add a callback on this object to trigger when attr changes.

remove_on_change(attr, *callbacks)

Remove a callback from this object

trigger(attr, old, new[, hint, setter])

Inherited from : py: class:EventCallbackManager

__init__()

If called with a single argument that is a dict or pandas.DataFrame, treat that implicitly as the "data" attribute.

on_event(event, *callbacks)

Run callbacks when the specified event occurs on this Model


data = {}
Type

ColumnData

Mapping of column names to sequences of data. The columns can be, e.g, Python lists or tuples, NumPy arrays, etc.

The .data attribute can also be set from Pandas DataFrames or GroupBy objects. In these cases, the behaviour is identical to passing the objects to the ColumnDataSource initializer.

name = None
Type

Nullable(String)

An arbitrary, user-supplied name for this model.

This name can be useful when querying the document to retrieve specific Bokeh models.

>>> plot.circle([1,2,3], [4,5,6], name="temp")
>>> plot.select(name="temp")
[GlyphRenderer(id='399d53f5-73e9-44d9-9527-544b761c7705', ...)]

Note

No uniqueness guarantees or other conditions are enforced on any names that are provided, nor is the name used directly by Bokeh for any reason.

selected = Selection(id='1214', ...)
Type

Readonly

An instance of a Selection that indicates selected indices on this DataSource. This is a read-only property. You may only change the attributes of this object to change the selection (e.g., selected.indices).

selection_policy = UnionRenderers(id='1216', ...)
Type

Instance(SelectionPolicy)

An instance of a SelectionPolicy that determines how selections are set.

syncable = True
Type

Bool

Indicates whether this model should be synchronized back to a Bokeh server when updated in a web browser. Setting to False may be useful to reduce network traffic when dealing with frequently updated objects whose updated values we don’t need.

Note

Setting this property to False will prevent any on_change() callbacks on this object from triggering. However, any JS-side callbacks will still work.

tags = []
Type

List

An optional list of arbitrary, user-supplied values to attach to this model.

This data can be useful when querying the document to retrieve specific Bokeh models:

>>> r = plot.circle([1,2,3], [4,5,6])
>>> r.tags = ["foo", 10]
>>> plot.select(tags=['foo', 10])
[GlyphRenderer(id='1de4c3df-a83d-480a-899b-fb263d3d5dd9', ...)]

Or simply a convenient way to attach any necessary metadata to a model that can be accessed by CustomJS callbacks, etc.

Note

No uniqueness guarantees or other conditions are enforced on any tags that are provided, nor are the tags used directly by Bokeh for any reason.

__init__(data: DataDict | pd.DataFrame | pd.core.groupby.GroupBy, **kwargs: Any) None[source]
__init__(**kwargs: Any) None

If called with a single argument that is a dict or pandas.DataFrame, treat that implicitly as the “data” attribute.

add(data: Sequence[Unknown], name: str | None = None) str[source]

Appends a new column of data to the data source.

Parameters
  • data (seq) – new data to add

  • name (str, optional) – column name to use. If not supplied, generate a name of the form “Series ####”

Returns

the column name used

Return type

str

apply_theme(property_values: Dict[str, Any]) None

Apply a set of theme values which will be used rather than defaults, but will not override application-set values.

The passed-in dictionary may be kept around as-is and shared with other instances to save memory (so neither the caller nor the HasProps instance should modify it).

Parameters

property_values (dict) – theme values to use in place of defaults

Returns

None

classmethod dataspecs() Dict[str, DataSpec]

Collect the names of all DataSpec properties on this class.

This method always traverses the class hierarchy and includes properties defined on any parent classes.

Returns

names of DataSpec properties

Return type

set[str]

destroy() None

Clean up references to the document and property

equals(other: bokeh.core.has_props.HasProps) bool

Structural equality of models.

Parameters

other (HasProps) – the other instance to compare to

Returns

True, if properties are structurally equal, otherwise False

classmethod from_df(data: pd.DataFrame) DataDict[source]

Create a dict of columns from a Pandas DataFrame, suitable for creating a ColumnDataSource.

Parameters

data (DataFrame) – data to convert

Returns

dict[str, np.array]

classmethod from_groupby(data: pd.core.groupby.GroupBy) DataDict[source]

Create a dict of columns from a Pandas GroupBy, suitable for creating a ColumnDataSource.

The data generated is the result of running describe on the group.

Parameters

data (Groupby) – data to convert

Returns

dict[str, np.array]

Link two Bokeh model properties using JavaScript.

This is a convenience method that simplifies adding a CustomJS callback to update one Bokeh model property whenever another changes value.

Parameters
  • attr (str) – The name of a Bokeh property on this model

  • other (Model) – A Bokeh model to link to self.attr

  • other_attr (str) – The property on other to link together

  • attr_selector (Union[int, str]) – The index to link an item in a subscriptable attr

Added in version 1.1

Raises

ValueError

Examples

This code with js_link:

select.js_link('value', plot, 'sizing_mode')

is equivalent to the following:

from bokeh.models import CustomJS
select.js_on_change('value',
    CustomJS(args=dict(other=plot),
             code="other.sizing_mode = this.value"
    )
)

Additionally, to use attr_selector to attach the left side of a range slider to a plot’s x_range:

range_slider.js_link('value', plot.x_range, 'start', attr_selector=0)

which is equivalent to:

from bokeh.models import CustomJS
range_slider.js_on_change('value',
    CustomJS(args=dict(other=plot.x_range),
             code="other.start = this.value[0]"
    )
)
js_on_change(event: str, *callbacks: JSEventCallback) None

Attach a CustomJS callback to an arbitrary BokehJS model event.

On the BokehJS side, change events for model properties have the form "change:property_name". As a convenience, if the event name passed to this method is also the name of a property on the model, then it will be prefixed with "change:" automatically:

# these two are equivalent
source.js_on_change('data', callback)
source.js_on_change('change:data', callback)

However, there are other kinds of events that can be useful to respond to, in addition to property change events. For example to run a callback whenever data is streamed to a ColumnDataSource, use the "stream" event on the source:

source.js_on_change('streaming', callback)
classmethod lookup(name: str, *, raises: bool = True) Optional[bokeh.core.property.descriptors.PropertyDescriptor[Any]]

Find the PropertyDescriptor for a Bokeh property on a class, given the property name.

Parameters
  • name (str) – name of the property to search for

  • raises (bool) – whether to raise or return None if missing

Returns

descriptor for property named name

Return type

PropertyDescriptor

on_change(attr: str, *callbacks: PropertyCallback) None

Add a callback on this object to trigger when attr changes.

Parameters
  • attr (str) – an attribute name on this object

  • *callbacks (callable) – callback functions to register

Returns

None

Example:

widget.on_change('value', callback1, callback2, ..., callback_n)
on_event(event: Union[str, Type[bokeh.events.Event]], *callbacks: Union[Callable[[bokeh.events.Event], None], Callable[[], None]]) None

Run callbacks when the specified event occurs on this Model

Not all Events are supported for all Models. See specific Events in bokeh.events for more information on which Models are able to trigger them.

patch(patches: Patches, setter: Setter | None = None) None[source]

Efficiently update data source columns at specific locations

If it is only necessary to update a small subset of data in a ColumnDataSource, this method can be used to efficiently update only the subset, instead of requiring the entire data set to be sent.

This method should be passed a dictionary that maps column names to lists of tuples that describe a patch change to apply. To replace individual items in columns entirely, the tuples should be of the form:

(index, new_value)  # replace a single column value

# or

(slice, new_values) # replace several column values

Values at an index or slice will be replaced with the corresponding new values.

In the case of columns whose values are other arrays or lists, (e.g. image or patches glyphs), it is also possible to patch “subregions”. In this case the first item of the tuple should be a whose first element is the index of the array item in the CDS patch, and whose subsequent elements are integer indices or slices into the array item:

# replace the entire 10th column of the 2nd array:

  +----------------- index of item in column data source
  |
  |       +--------- row subindex into array item
  |       |
  |       |       +- column subindex into array item
  V       V       V
([2, slice(None), 10], new_values)

Imagining a list of 2d NumPy arrays, the patch above is roughly equivalent to:

data = [arr1, arr2, ...]  # list of 2d arrays

data[2][:, 10] = new_data

There are some limitations to the kinds of slices and data that can be accepted.

  • Negative start, stop, or step values for slices will result in a ValueError.

  • In a slice, start > stop will result in a ValueError

  • When patching 1d or 2d subitems, the subitems must be NumPy arrays.

  • New values must be supplied as a flattened one-dimensional array of the appropriate size.

Parameters

patches (dict[str, list[tuple]]) – lists of patches for each column

Returns

None

Raises

ValueError

Example:

The following example shows how to patch entire column elements. In this case,

source = ColumnDataSource(data=dict(foo=[10, 20, 30], bar=[100, 200, 300]))

patches = {
    'foo' : [ (slice(2), [11, 12]) ],
    'bar' : [ (0, 101), (2, 301) ],
}

source.patch(patches)

After this operation, the value of the source.data will be:

dict(foo=[11, 12, 30], bar=[101, 200, 301])

For a more comprehensive complete example, see examples/howto/patch_app.py.

classmethod properties(*, _with_props: bool = False) Union[Set[str], Dict[str, Property[Any]]]

Collect the names of properties on this class.

Warning

In a future version of Bokeh, this method will return a dictionary mapping property names to property objects. To future-proof this current usage of this method, wrap the return value in list.

Returns

property names

classmethod properties_with_refs() Dict[str, Property[Any]]

Collect the names of all properties on this class that also have references.

This method always traverses the class hierarchy and includes properties defined on any parent classes.

Returns

names of properties that have references

Return type

set[str]

properties_with_values(*, include_defaults: bool = True, include_undefined: bool = False) Dict[str, Any]

Collect a dict mapping property names to their values.

This method always traverses the class hierarchy and includes properties defined on any parent classes.

Non-serializable properties are skipped and property values are in “serialized” format which may be slightly different from the values you would normally read from the properties; the intent of this method is to return the information needed to losslessly reconstitute the object instance.

Parameters

include_defaults (bool, optional) – Whether to include properties that haven’t been explicitly set since the object was created. (default: True)

Returns

mapping from property names to their values

Return type

dict

query_properties_with_values(query: Callable[[bokeh.core.property.descriptors.PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) Dict[str, Any]

Query the properties values of HasProps instances with a predicate.

Parameters
  • query (callable) – A callable that accepts property descriptors and returns True or False

  • include_defaults (bool, optional) – Whether to include properties that have not been explicitly set by a user (default: True)

Returns

mapping of property names and values for matching properties

Return type

dict

references() Set[bokeh.model.model.Model]

Returns all Models that this object has references to.

remove(name: str) None[source]

Remove a column of data.

Parameters

name (str) – name of the column to remove

Returns

None

Note

If the column name does not exist, a warning is issued.

remove_on_change(attr: str, *callbacks: Callable[[str, Any, Any], None]) None

Remove a callback from this object

select(selector: SelectorType) Iterable[Model]

Query this object and all of its references for objects that match the given selector.

Parameters

selector (JSON-like) –

Returns

seq[Model]

select_one(selector: SelectorType) Model | None

Query this object and all of its references for objects that match the given selector. Raises an error if more than one object is found. Returns single matching object, or None if nothing is found :param selector: :type selector: JSON-like

Returns

Model

set_from_json(name: str, json: JSON, *, models: Dict[ID, HasProps] | None = None, setter: Setter | None = None) None

Set a property value on this object from JSON.

Parameters
  • name – (str) : name of the attribute to set

  • json – (JSON-value) : value to set to the attribute to

  • models (dict or None, optional) –

    Mapping of model ids to models (default: None)

    This is needed in cases where the attributes to update also have values that have references.

  • setter (ClientSession or ServerSession or None, optional) –

    This is used to prevent “boomerang” updates to Bokeh apps.

    In the context of a Bokeh server application, incoming updates to properties will be annotated with the session that is doing the updating. This value is propagated through any subsequent change notifications that the update triggers. The session can compare the event setter to itself, and suppress any updates that originate from itself.

Returns

None

set_select(selector: Type[Model] | SelectorType, updates: Dict[str, Unknown]) None

Update objects that match a given selector with the specified attribute/value updates.

Parameters
  • selector (JSON-like) –

  • updates (dict) –

Returns

None

stream(new_data: DataDict, rollover: int | None = None) None[source]

Efficiently update data source columns with new append-only data.

In cases where it is necessary to update data columns in, this method can efficiently send only the new data, instead of requiring the entire data set to be re-sent.

Parameters
  • new_data (dict[str, seq]) –

    a mapping of column names to sequences of new data to append to each column.

    All columns of the data source must be present in new_data, with identical-length append data.

  • rollover (int, optional) – A maximum column size, above which data from the start of the column begins to be discarded. If None, then columns will continue to grow unbounded (default: None)

Returns

None

Raises

ValueError

Example:

source = ColumnDataSource(data=dict(foo=[], bar=[]))

# has new, identical-length updates for all columns in source
new_data = {
    'foo' : [10, 20],
    'bar' : [100, 200],
}

source.stream(new_data)
themed_values() Optional[Dict[str, Any]]

Get any theme-provided overrides.

Results are returned as a dict from property name to value, or None if no theme overrides any values for this instance.

Returns

dict or None

to_df() pandas.core.frame.DataFrame[source]

Convert this data source to pandas DataFrame.

Returns

DataFrame

to_json(include_defaults: bool) JSON

Returns a dictionary of the attributes of this object, containing only “JSON types” (string, number, boolean, none, dict, list).

References to other objects are serialized as “refs” (just the object ID and type info), so the deserializer will need to separately have the full attributes of those other objects.

There’s no corresponding from_json() because to deserialize an object is normally done in the context of a Document (since the Document can resolve references).

For most purposes it’s best to serialize and deserialize entire documents.

Parameters

include_defaults (bool) – whether to include attributes that haven’t been changed from the default

to_json_string(include_defaults: bool) str

Returns a JSON string encoding the attributes of this object.

References to other objects are serialized as references (just the object ID and type info), so the deserializer will need to separately have the full attributes of those other objects.

There’s no corresponding from_json_string() because to deserialize an object is normally done in the context of a Document (since the Document can resolve references).

For most purposes it’s best to serialize and deserialize entire documents.

Parameters

include_defaults (bool) – whether to include attributes that haven’t been changed from the default

trigger(attr: str, old: Unknown, new: Unknown, hint: DocumentPatchedEvent | None = None, setter: Setter | None = None) None
unapply_theme() None

Remove any themed values and restore defaults.

Returns

None

update(**kwargs: Any) None

Updates the object’s properties from the given keyword arguments.

Returns

None

Examples

The following are equivalent:

from bokeh.models import Range1d

r = Range1d

# set properties individually:
r.start = 10
r.end = 20

# update properties together:
r.update(start=10, end=20)
update_from_json(json_attributes: Dict[str, JSON], *, models: Mapping[ID, HasProps] | None = None, setter: Setter | None = None) None

Updates the object’s properties from a JSON attributes dictionary.

Parameters
  • json_attributes – (JSON-dict) : attributes and values to update

  • models (dict or None, optional) –

    Mapping of model ids to models (default: None)

    This is needed in cases where the attributes to update also have values that have references.

  • setter (ClientSession or ServerSession or None, optional) –

    This is used to prevent “boomerang” updates to Bokeh apps.

    In the context of a Bokeh server application, incoming updates to properties will be annotated with the session that is doing the updating. This value is propagated through any subsequent change notifications that the update triggers. The session can compare the event setter to itself, and suppress any updates that originate from itself.

Returns

None

property column_names: List[str]

A list of the column names in this data source.

property document: Document | None

The Document this model is attached to (can be None)

property struct: bokeh.core.types.ReferenceJson

A Bokeh protocol “structure” of this model, i.e. a dict of the form:

{
    'type' : << view model name >>
    'id'   : << unique model id >>
}

Additionally there may be a subtype field if this model is a subtype.

ColumnarDataSource

class ColumnarDataSource(*args, **kwargs)[source]

Bases: bokeh.models.sources.DataSource

A base class for data source types, which can be mapped onto a columnar format.

Note

This is an abstract base class used to help organize the hierarchy of Bokeh model types. It is not useful to instantiate on its own.

JSON Prototype
{
  "id": "1219",
  "js_event_callbacks": {},
  "js_property_callbacks": {},
  "name": null,
  "selected": {
    "id": "1221"
  },
  "selection_policy": {
    "id": "1220"
  },
  "subscribed_events": [],
  "syncable": true,
  "tags": []
}

Public Data Attributes:

selection_policy

An instance of a SelectionPolicy that determines how selections are set.

Inherited from : py: class:DataSource

selected

An instance of a Selection that indicates selected indices on this DataSource.

Inherited from : py: class:Model

model_class_reverse_map

id

ref

struct

A Bokeh protocol "structure" of this model, i.e. a dict of the form:.

name

An arbitrary, user-supplied name for this model.

tags

An optional list of arbitrary, user-supplied values to attach to this model.

js_event_callbacks

A mapping of event names to lists of CustomJS callbacks.

subscribed_events

List of events that are subscribed to by Python callbacks.

js_property_callbacks

A mapping of attribute names to lists of CustomJS callbacks, to be set up on BokehJS side when the document is created.

syncable

Indicates whether this model should be synchronized back to a Bokeh server when updated in a web browser.

Inherited from : py: class:HasDocumentRef

document

The Document this model is attached to (can be None)

Public Methods:

Inherited from : py: class:Model

__init_subclass__()

This method is called when a class is subclassed.

__new__(cls, *args, **kwargs)

__init__(**kwargs)

__str__()

Return str(self).

__repr__()

Return repr(self).

destroy()

Clean up references to the document and property

js_on_event(event, *callbacks)

js_link(attr, other, other_attr[, attr_selector])

Link two Bokeh model properties using JavaScript.

js_on_change(event, *callbacks)

Attach a CustomJS callback to an arbitrary BokehJS model event.

on_change(attr, *callbacks)

Add a callback on this object to trigger when attr changes.

references()

Returns all Models that this object has references to.

select(selector)

Query this object and all of its references for objects that match the given selector.

select_one(selector)

Query this object and all of its references for objects that match the given selector.

set_select(selector, updates)

Update objects that match a given selector with the specified attribute/value updates.

to_json(include_defaults)

Returns a dictionary of the attributes of this object, containing only "JSON types" (string, number, boolean, none, dict, list).

to_json_string(include_defaults)

Returns a JSON string encoding the attributes of this object.

trigger(attr, old, new[, hint, setter])

Inherited from : py: class:HasProps

__init__(**kwargs)

__setattr__(name, value)

Intercept attribute setting on HasProps in order to special case a few situations:

__getattr__(name)

Intercept attribute setting on HasProps in order to special case a few situations:

__str__()

Return str(self).

__repr__()

Return repr(self).

equals(other)

Structural equality of models.

static_to_serializable(serializer)

to_serializable(serializer)

set_from_json(name, json, *[, models, setter])

Set a property value on this object from JSON.

update(**kwargs)

Updates the object's properties from the given keyword arguments.

update_from_json(json_attributes, *[, ...])

Updates the object's properties from a JSON attributes dictionary.

lookup(name, *[, raises])

Find the PropertyDescriptor for a Bokeh property on a class, given the property name.

properties(*[, _with_props])

Collect the names of properties on this class.

properties_with_refs()

Collect the names of all properties on this class that also have references.

dataspecs()

Collect the names of all DataSpec properties on this class.

properties_with_values(*[, ...])

Collect a dict mapping property names to their values.

query_properties_with_values(query, *[, ...])

Query the properties values of HasProps instances with a predicate.

themed_values()

Get any theme-provided overrides.

apply_theme(property_values)

Apply a set of theme values which will be used rather than defaults, but will not override application-set values.

unapply_theme()

Remove any themed values and restore defaults.

Inherited from : py: class:HasDocumentRef

__init__(**kwargs)

Inherited from : py: class:PropertyCallbackManager

__init__(**kwargs)

on_change(attr, *callbacks)

Add a callback on this object to trigger when attr changes.

remove_on_change(attr, *callbacks)

Remove a callback from this object

trigger(attr, old, new[, hint, setter])

Inherited from : py: class:EventCallbackManager

__init__(**kwargs)

on_event(event, *callbacks)

Run callbacks when the specified event occurs on this Model


name = None
Type

Nullable(String)

An arbitrary, user-supplied name for this model.

This name can be useful when querying the document to retrieve specific Bokeh models.

>>> plot.circle([1,2,3], [4,5,6], name="temp")
>>> plot.select(name="temp")
[GlyphRenderer(id='399d53f5-73e9-44d9-9527-544b761c7705', ...)]

Note

No uniqueness guarantees or other conditions are enforced on any names that are provided, nor is the name used directly by Bokeh for any reason.

selected = Selection(id='1224', ...)
Type

Readonly

An instance of a Selection that indicates selected indices on this DataSource. This is a read-only property. You may only change the attributes of this object to change the selection (e.g., selected.indices).

selection_policy = UnionRenderers(id='1226', ...)
Type

Instance(SelectionPolicy)

An instance of a SelectionPolicy that determines how selections are set.

syncable = True
Type

Bool

Indicates whether this model should be synchronized back to a Bokeh server when updated in a web browser. Setting to False may be useful to reduce network traffic when dealing with frequently updated objects whose updated values we don’t need.

Note

Setting this property to False will prevent any on_change() callbacks on this object from triggering. However, any JS-side callbacks will still work.

tags = []
Type

List

An optional list of arbitrary, user-supplied values to attach to this model.

This data can be useful when querying the document to retrieve specific Bokeh models:

>>> r = plot.circle([1,2,3], [4,5,6])
>>> r.tags = ["foo", 10]
>>> plot.select(tags=['foo', 10])
[GlyphRenderer(id='1de4c3df-a83d-480a-899b-fb263d3d5dd9', ...)]

Or simply a convenient way to attach any necessary metadata to a model that can be accessed by CustomJS callbacks, etc.

Note

No uniqueness guarantees or other conditions are enforced on any tags that are provided, nor are the tags used directly by Bokeh for any reason.

apply_theme(property_values: Dict[str, Any]) None

Apply a set of theme values which will be used rather than defaults, but will not override application-set values.

The passed-in dictionary may be kept around as-is and shared with other instances to save memory (so neither the caller nor the HasProps instance should modify it).

Parameters

property_values (dict) – theme values to use in place of defaults

Returns

None

classmethod dataspecs() Dict[str, DataSpec]

Collect the names of all DataSpec properties on this class.

This method always traverses the class hierarchy and includes properties defined on any parent classes.

Returns

names of DataSpec properties

Return type

set[str]

destroy() None

Clean up references to the document and property

equals(other: bokeh.core.has_props.HasProps) bool

Structural equality of models.

Parameters

other (HasProps) – the other instance to compare to

Returns

True, if properties are structurally equal, otherwise False

Link two Bokeh model properties using JavaScript.

This is a convenience method that simplifies adding a CustomJS callback to update one Bokeh model property whenever another changes value.

Parameters
  • attr (str) – The name of a Bokeh property on this model

  • other (Model) – A Bokeh model to link to self.attr

  • other_attr (str) – The property on other to link together

  • attr_selector (Union[int, str]) – The index to link an item in a subscriptable attr

Added in version 1.1

Raises

ValueError

Examples

This code with js_link:

select.js_link('value', plot, 'sizing_mode')

is equivalent to the following:

from bokeh.models import CustomJS
select.js_on_change('value',
    CustomJS(args=dict(other=plot),
             code="other.sizing_mode = this.value"
    )
)

Additionally, to use attr_selector to attach the left side of a range slider to a plot’s x_range:

range_slider.js_link('value', plot.x_range, 'start', attr_selector=0)

which is equivalent to:

from bokeh.models import CustomJS
range_slider.js_on_change('value',
    CustomJS(args=dict(other=plot.x_range),
             code="other.start = this.value[0]"
    )
)
js_on_change(event: str, *callbacks: JSEventCallback) None

Attach a CustomJS callback to an arbitrary BokehJS model event.

On the BokehJS side, change events for model properties have the form "change:property_name". As a convenience, if the event name passed to this method is also the name of a property on the model, then it will be prefixed with "change:" automatically:

# these two are equivalent
source.js_on_change('data', callback)
source.js_on_change('change:data', callback)

However, there are other kinds of events that can be useful to respond to, in addition to property change events. For example to run a callback whenever data is streamed to a ColumnDataSource, use the "stream" event on the source:

source.js_on_change('streaming', callback)
classmethod lookup(name: str, *, raises: bool = True) Optional[bokeh.core.property.descriptors.PropertyDescriptor[Any]]

Find the PropertyDescriptor for a Bokeh property on a class, given the property name.

Parameters
  • name (str) – name of the property to search for

  • raises (bool) – whether to raise or return None if missing

Returns

descriptor for property named name

Return type

PropertyDescriptor

on_change(attr: str, *callbacks: PropertyCallback) None

Add a callback on this object to trigger when attr changes.

Parameters
  • attr (str) – an attribute name on this object

  • *callbacks (callable) – callback functions to register

Returns

None

Example:

widget.on_change('value', callback1, callback2, ..., callback_n)
on_event(event: Union[str, Type[bokeh.events.Event]], *callbacks: Union[Callable[[bokeh.events.Event], None], Callable[[], None]]) None

Run callbacks when the specified event occurs on this Model

Not all Events are supported for all Models. See specific Events in bokeh.events for more information on which Models are able to trigger them.

classmethod properties(*, _with_props: bool = False) Union[Set[str], Dict[str, Property[Any]]]

Collect the names of properties on this class.

Warning

In a future version of Bokeh, this method will return a dictionary mapping property names to property objects. To future-proof this current usage of this method, wrap the return value in list.

Returns

property names

classmethod properties_with_refs() Dict[str, Property[Any]]

Collect the names of all properties on this class that also have references.

This method always traverses the class hierarchy and includes properties defined on any parent classes.

Returns

names of properties that have references

Return type

set[str]

properties_with_values(*, include_defaults: bool = True, include_undefined: bool = False) Dict[str, Any]

Collect a dict mapping property names to their values.

This method always traverses the class hierarchy and includes properties defined on any parent classes.

Non-serializable properties are skipped and property values are in “serialized” format which may be slightly different from the values you would normally read from the properties; the intent of this method is to return the information needed to losslessly reconstitute the object instance.

Parameters

include_defaults (bool, optional) – Whether to include properties that haven’t been explicitly set since the object was created. (default: True)

Returns

mapping from property names to their values

Return type

dict

query_properties_with_values(query: Callable[[bokeh.core.property.descriptors.PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) Dict[str, Any]

Query the properties values of HasProps instances with a predicate.

Parameters
  • query (callable) – A callable that accepts property descriptors and returns True or False

  • include_defaults (bool, optional) – Whether to include properties that have not been explicitly set by a user (default: True)

Returns

mapping of property names and values for matching properties

Return type

dict

references() Set[bokeh.model.model.Model]

Returns all Models that this object has references to.

remove_on_change(attr: str, *callbacks: Callable[[str, Any, Any], None]) None

Remove a callback from this object

select(selector: SelectorType) Iterable[Model]

Query this object and all of its references for objects that match the given selector.

Parameters

selector (JSON-like) –

Returns

seq[Model]

select_one(selector: SelectorType) Model | None

Query this object and all of its references for objects that match the given selector. Raises an error if more than one object is found. Returns single matching object, or None if nothing is found :param selector: :type selector: JSON-like

Returns

Model

set_from_json(name: str, json: JSON, *, models: Dict[ID, HasProps] | None = None, setter: Setter | None = None) None

Set a property value on this object from JSON.

Parameters
  • name – (str) : name of the attribute to set

  • json – (JSON-value) : value to set to the attribute to

  • models (dict or None, optional) –

    Mapping of model ids to models (default: None)

    This is needed in cases where the attributes to update also have values that have references.

  • setter (ClientSession or ServerSession or None, optional) –

    This is used to prevent “boomerang” updates to Bokeh apps.

    In the context of a Bokeh server application, incoming updates to properties will be annotated with the session that is doing the updating. This value is propagated through any subsequent change notifications that the update triggers. The session can compare the event setter to itself, and suppress any updates that originate from itself.

Returns

None

set_select(selector: Type[Model] | SelectorType, updates: Dict[str, Unknown]) None

Update objects that match a given selector with the specified attribute/value updates.

Parameters
  • selector (JSON-like) –

  • updates (dict) –

Returns

None

themed_values() Optional[Dict[str, Any]]

Get any theme-provided overrides.

Results are returned as a dict from property name to value, or None if no theme overrides any values for this instance.

Returns

dict or None

to_json(include_defaults: bool) JSON

Returns a dictionary of the attributes of this object, containing only “JSON types” (string, number, boolean, none, dict, list).

References to other objects are serialized as “refs” (just the object ID and type info), so the deserializer will need to separately have the full attributes of those other objects.

There’s no corresponding from_json() because to deserialize an object is normally done in the context of a Document (since the Document can resolve references).

For most purposes it’s best to serialize and deserialize entire documents.

Parameters

include_defaults (bool) – whether to include attributes that haven’t been changed from the default

to_json_string(include_defaults: bool) str

Returns a JSON string encoding the attributes of this object.

References to other objects are serialized as references (just the object ID and type info), so the deserializer will need to separately have the full attributes of those other objects.

There’s no corresponding from_json_string() because to deserialize an object is normally done in the context of a Document (since the Document can resolve references).

For most purposes it’s best to serialize and deserialize entire documents.

Parameters

include_defaults (bool) – whether to include attributes that haven’t been changed from the default

trigger(attr: str, old: Unknown, new: Unknown, hint: DocumentPatchedEvent | None = None, setter: Setter | None = None) None
unapply_theme() None

Remove any themed values and restore defaults.

Returns

None

update(**kwargs: Any) None

Updates the object’s properties from the given keyword arguments.

Returns

None

Examples

The following are equivalent:

from bokeh.models import Range1d

r = Range1d

# set properties individually:
r.start = 10
r.end = 20

# update properties together:
r.update(start=10, end=20)
update_from_json(json_attributes: Dict[str, JSON], *, models: Mapping[ID, HasProps] | None = None, setter: Setter | None = None) None

Updates the object’s properties from a JSON attributes dictionary.

Parameters
  • json_attributes – (JSON-dict) : attributes and values to update

  • models (dict or None, optional) –

    Mapping of model ids to models (default: None)

    This is needed in cases where the attributes to update also have values that have references.

  • setter (ClientSession or ServerSession or None, optional) –

    This is used to prevent “boomerang” updates to Bokeh apps.

    In the context of a Bokeh server application, incoming updates to properties will be annotated with the session that is doing the updating. This value is propagated through any subsequent change notifications that the update triggers. The session can compare the event setter to itself, and suppress any updates that originate from itself.

Returns

None

property document: Document | None

The Document this model is attached to (can be None)

property struct: bokeh.core.types.ReferenceJson

A Bokeh protocol “structure” of this model, i.e. a dict of the form:

{
    'type' : << view model name >>
    'id'   : << unique model id >>
}

Additionally there may be a subtype field if this model is a subtype.

DataSource

class DataSource(*args, **kwargs)[source]

Bases: bokeh.model.model.Model

A base class for data source types.

Note

This is an abstract base class used to help organize the hierarchy of Bokeh model types. It is not useful to instantiate on its own.

JSON Prototype
{
  "id": "1229",
  "js_event_callbacks": {},
  "js_property_callbacks": {},
  "name": null,
  "selected": {
    "id": "1230"
  },
  "subscribed_events": [],
  "syncable": true,
  "tags": []
}

Public Data Attributes:

selected

An instance of a Selection that indicates selected indices on this DataSource.

Inherited from : py: class:Model

model_class_reverse_map

id

ref

struct

A Bokeh protocol "structure" of this model, i.e. a dict of the form:.

name

An arbitrary, user-supplied name for this model.

tags

An optional list of arbitrary, user-supplied values to attach to this model.

js_event_callbacks

A mapping of event names to lists of CustomJS callbacks.

subscribed_events

List of events that are subscribed to by Python callbacks.

js_property_callbacks

A mapping of attribute names to lists of CustomJS callbacks, to be set up on BokehJS side when the document is created.

syncable

Indicates whether this model should be synchronized back to a Bokeh server when updated in a web browser.

Inherited from : py: class:HasDocumentRef

document

The Document this model is attached to (can be None)

Public Methods:

Inherited from : py: class:Model

__init_subclass__()

This method is called when a class is subclassed.

__new__(cls, *args, **kwargs)

__init__(**kwargs)

__str__()

Return str(self).

__repr__()

Return repr(self).

destroy()

Clean up references to the document and property

js_on_event(event, *callbacks)

js_link(attr, other, other_attr[, attr_selector])

Link two Bokeh model properties using JavaScript.

js_on_change(event, *callbacks)

Attach a CustomJS callback to an arbitrary BokehJS model event.

on_change(attr, *callbacks)

Add a callback on this object to trigger when attr changes.

references()

Returns all Models that this object has references to.

select(selector)

Query this object and all of its references for objects that match the given selector.

select_one(selector)

Query this object and all of its references for objects that match the given selector.

set_select(selector, updates)

Update objects that match a given selector with the specified attribute/value updates.

to_json(include_defaults)

Returns a dictionary of the attributes of this object, containing only "JSON types" (string, number, boolean, none, dict, list).

to_json_string(include_defaults)

Returns a JSON string encoding the attributes of this object.

trigger(attr, old, new[, hint, setter])

Inherited from : py: class:HasProps

__init__(**kwargs)

__setattr__(name, value)

Intercept attribute setting on HasProps in order to special case a few situations:

__getattr__(name)

Intercept attribute setting on HasProps in order to special case a few situations:

__str__()

Return str(self).

__repr__()

Return repr(self).

equals(other)

Structural equality of models.

static_to_serializable(serializer)

to_serializable(serializer)

set_from_json(name, json, *[, models, setter])

Set a property value on this object from JSON.

update(**kwargs)

Updates the object's properties from the given keyword arguments.

update_from_json(json_attributes, *[, ...])

Updates the object's properties from a JSON attributes dictionary.

lookup(name, *[, raises])

Find the PropertyDescriptor for a Bokeh property on a class, given the property name.

properties(*[, _with_props])

Collect the names of properties on this class.

properties_with_refs()

Collect the names of all properties on this class that also have references.

dataspecs()

Collect the names of all DataSpec properties on this class.

properties_with_values(*[, ...])

Collect a dict mapping property names to their values.

query_properties_with_values(query, *[, ...])

Query the properties values of HasProps instances with a predicate.

themed_values()

Get any theme-provided overrides.

apply_theme(property_values)

Apply a set of theme values which will be used rather than defaults, but will not override application-set values.

unapply_theme()

Remove any themed values and restore defaults.

Inherited from : py: class:HasDocumentRef

__init__(**kwargs)

Inherited from : py: class:PropertyCallbackManager

__init__(**kwargs)

on_change(attr, *callbacks)

Add a callback on this object to trigger when attr changes.

remove_on_change(attr, *callbacks)

Remove a callback from this object

trigger(attr, old, new[, hint, setter])

Inherited from : py: class:EventCallbackManager

__init__(**kwargs)

on_event(event, *callbacks)

Run callbacks when the specified event occurs on this Model


name = None
Type

Nullable(String)

An arbitrary, user-supplied name for this model.

This name can be useful when querying the document to retrieve specific Bokeh models.

>>> plot.circle([1,2,3], [4,5,6], name="temp")
>>> plot.select(name="temp")
[GlyphRenderer(id='399d53f5-73e9-44d9-9527-544b761c7705', ...)]

Note

No uniqueness guarantees or other conditions are enforced on any names that are provided, nor is the name used directly by Bokeh for any reason.

selected = Selection(id='1233', ...)
Type

Readonly

An instance of a Selection that indicates selected indices on this DataSource. This is a read-only property. You may only change the attributes of this object to change the selection (e.g., selected.indices).

syncable = True
Type

Bool

Indicates whether this model should be synchronized back to a Bokeh server when updated in a web browser. Setting to False may be useful to reduce network traffic when dealing with frequently updated objects whose updated values we don’t need.

Note

Setting this property to False will prevent any on_change() callbacks on this object from triggering. However, any JS-side callbacks will still work.

tags = []
Type

List

An optional list of arbitrary, user-supplied values to attach to this model.

This data can be useful when querying the document to retrieve specific Bokeh models:

>>> r = plot.circle([1,2,3], [4,5,6])
>>> r.tags = ["foo", 10]
>>> plot.select(tags=['foo', 10])
[GlyphRenderer(id='1de4c3df-a83d-480a-899b-fb263d3d5dd9', ...)]

Or simply a convenient way to attach any necessary metadata to a model that can be accessed by CustomJS callbacks, etc.

Note

No uniqueness guarantees or other conditions are enforced on any tags that are provided, nor are the tags used directly by Bokeh for any reason.

apply_theme(property_values: Dict[str, Any]) None

Apply a set of theme values which will be used rather than defaults, but will not override application-set values.

The passed-in dictionary may be kept around as-is and shared with other instances to save memory (so neither the caller nor the HasProps instance should modify it).

Parameters

property_values (dict) – theme values to use in place of defaults

Returns

None

classmethod dataspecs() Dict[str, DataSpec]

Collect the names of all DataSpec properties on this class.

This method always traverses the class hierarchy and includes properties defined on any parent classes.

Returns

names of DataSpec properties

Return type

set[str]

destroy() None

Clean up references to the document and property

equals(other: bokeh.core.has_props.HasProps) bool

Structural equality of models.

Parameters

other (HasProps) – the other instance to compare to

Returns

True, if properties are structurally equal, otherwise False

Link two Bokeh model properties using JavaScript.

This is a convenience method that simplifies adding a CustomJS callback to update one Bokeh model property whenever another changes value.

Parameters
  • attr (str) – The name of a Bokeh property on this model

  • other (Model) – A Bokeh model to link to self.attr

  • other_attr (str) – The property on other to link together

  • attr_selector (Union[int, str]) – The index to link an item in a subscriptable attr

Added in version 1.1

Raises

ValueError

Examples

This code with js_link:

select.js_link('value', plot, 'sizing_mode')

is equivalent to the following:

from bokeh.models import CustomJS
select.js_on_change('value',
    CustomJS(args=dict(other=plot),
             code="other.sizing_mode = this.value"
    )
)

Additionally, to use attr_selector to attach the left side of a range slider to a plot’s x_range:

range_slider.js_link('value', plot.x_range, 'start', attr_selector=0)

which is equivalent to:

from bokeh.models import CustomJS
range_slider.js_on_change('value',
    CustomJS(args=dict(other=plot.x_range),
             code="other.start = this.value[0]"
    )
)
js_on_change(event: str, *callbacks: JSEventCallback) None

Attach a CustomJS callback to an arbitrary BokehJS model event.

On the BokehJS side, change events for model properties have the form "change:property_name". As a convenience, if the event name passed to this method is also the name of a property on the model, then it will be prefixed with "change:" automatically:

# these two are equivalent
source.js_on_change('data', callback)
source.js_on_change('change:data', callback)

However, there are other kinds of events that can be useful to respond to, in addition to property change events. For example to run a callback whenever data is streamed to a ColumnDataSource, use the "stream" event on the source:

source.js_on_change('streaming', callback)
classmethod lookup(name: str, *, raises: bool = True) Optional[bokeh.core.property.descriptors.PropertyDescriptor[Any]]

Find the PropertyDescriptor for a Bokeh property on a class, given the property name.

Parameters
  • name (str) – name of the property to search for

  • raises (bool) – whether to raise or return None if missing

Returns

descriptor for property named name

Return type

PropertyDescriptor

on_change(attr: str, *callbacks: PropertyCallback) None

Add a callback on this object to trigger when attr changes.

Parameters
  • attr (str) – an attribute name on this object

  • *callbacks (callable) – callback functions to register

Returns

None

Example:

widget.on_change('value', callback1, callback2, ..., callback_n)
on_event(event: Union[str, Type[bokeh.events.Event]], *callbacks: Union[Callable[[bokeh.events.Event], None], Callable[[], None]]) None

Run callbacks when the specified event occurs on this Model

Not all Events are supported for all Models. See specific Events in bokeh.events for more information on which Models are able to trigger them.

classmethod properties(*, _with_props: bool = False) Union[Set[str], Dict[str, Property[Any]]]

Collect the names of properties on this class.

Warning

In a future version of Bokeh, this method will return a dictionary mapping property names to property objects. To future-proof this current usage of this method, wrap the return value in list.

Returns

property names

classmethod properties_with_refs() Dict[str, Property[Any]]

Collect the names of all properties on this class that also have references.

This method always traverses the class hierarchy and includes properties defined on any parent classes.

Returns

names of properties that have references

Return type

set[str]

properties_with_values(*, include_defaults: bool = True, include_undefined: bool = False) Dict[str, Any]

Collect a dict mapping property names to their values.

This method always traverses the class hierarchy and includes properties defined on any parent classes.

Non-serializable properties are skipped and property values are in “serialized” format which may be slightly different from the values you would normally read from the properties; the intent of this method is to return the information needed to losslessly reconstitute the object instance.

Parameters

include_defaults (bool, optional) – Whether to include properties that haven’t been explicitly set since the object was created. (default: True)

Returns

mapping from property names to their values

Return type

dict

query_properties_with_values(query: Callable[[bokeh.core.property.descriptors.PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) Dict[str, Any]

Query the properties values of HasProps instances with a predicate.

Parameters
  • query (callable) – A callable that accepts property descriptors and returns True or False

  • include_defaults (bool, optional) – Whether to include properties that have not been explicitly set by a user (default: True)

Returns

mapping of property names and values for matching properties

Return type

dict

references() Set[bokeh.model.model.Model]

Returns all Models that this object has references to.

remove_on_change(attr: str, *callbacks: Callable[[str, Any, Any], None]) None

Remove a callback from this object

select(selector: SelectorType) Iterable[Model]

Query this object and all of its references for objects that match the given selector.

Parameters

selector (JSON-like) –

Returns

seq[Model]

select_one(selector: SelectorType) Model | None

Query this object and all of its references for objects that match the given selector. Raises an error if more than one object is found. Returns single matching object, or None if nothing is found :param selector: :type selector: JSON-like

Returns

Model

set_from_json(name: str, json: JSON, *, models: Dict[ID, HasProps] | None = None, setter: Setter | None = None) None

Set a property value on this object from JSON.

Parameters
  • name – (str) : name of the attribute to set

  • json – (JSON-value) : value to set to the attribute to

  • models (dict or None, optional) –

    Mapping of model ids to models (default: None)

    This is needed in cases where the attributes to update also have values that have references.

  • setter (ClientSession or ServerSession or None, optional) –

    This is used to prevent “boomerang” updates to Bokeh apps.

    In the context of a Bokeh server application, incoming updates to properties will be annotated with the session that is doing the updating. This value is propagated through any subsequent change notifications that the update triggers. The session can compare the event setter to itself, and suppress any updates that originate from itself.

Returns

None

set_select(selector: Type[Model] | SelectorType, updates: Dict[str, Unknown]) None

Update objects that match a given selector with the specified attribute/value updates.

Parameters
  • selector (JSON-like) –

  • updates (dict) –

Returns

None

themed_values() Optional[Dict[str, Any]]

Get any theme-provided overrides.

Results are returned as a dict from property name to value, or None if no theme overrides any values for this instance.

Returns

dict or None

to_json(include_defaults: bool) JSON

Returns a dictionary of the attributes of this object, containing only “JSON types” (string, number, boolean, none, dict, list).

References to other objects are serialized as “refs” (just the object ID and type info), so the deserializer will need to separately have the full attributes of those other objects.

There’s no corresponding from_json() because to deserialize an object is normally done in the context of a Document (since the Document can resolve references).

For most purposes it’s best to serialize and deserialize entire documents.

Parameters

include_defaults (bool) – whether to include attributes that haven’t been changed from the default

to_json_string(include_defaults: bool) str

Returns a JSON string encoding the attributes of this object.

References to other objects are serialized as references (just the object ID and type info), so the deserializer will need to separately have the full attributes of those other objects.

There’s no corresponding from_json_string() because to deserialize an object is normally done in the context of a Document (since the Document can resolve references).

For most purposes it’s best to serialize and deserialize entire documents.

Parameters

include_defaults (bool) – whether to include attributes that haven’t been changed from the default

trigger(attr: str, old: Unknown, new: Unknown, hint: DocumentPatchedEvent | None = None, setter: Setter | None = None) None
unapply_theme() None

Remove any themed values and restore defaults.

Returns

None

update(**kwargs: Any) None

Updates the object’s properties from the given keyword arguments.

Returns

None

Examples

The following are equivalent:

from bokeh.models import Range1d

r = Range1d

# set properties individually:
r.start = 10
r.end = 20

# update properties together:
r.update(start=10, end=20)
update_from_json(json_attributes: Dict[str, JSON], *, models: Mapping[ID, HasProps] | None = None, setter: Setter | None = None) None

Updates the object’s properties from a JSON attributes dictionary.

Parameters
  • json_attributes – (JSON-dict) : attributes and values to update

  • models (dict or None, optional) –

    Mapping of model ids to models (default: None)

    This is needed in cases where the attributes to update also have values that have references.

  • setter (ClientSession or ServerSession or None, optional) –

    This is used to prevent “boomerang” updates to Bokeh apps.

    In the context of a Bokeh server application, incoming updates to properties will be annotated with the session that is doing the updating. This value is propagated through any subsequent change notifications that the update triggers. The session can compare the event setter to itself, and suppress any updates that originate from itself.

Returns

None

property document: Document | None

The Document this model is attached to (can be None)

property struct: bokeh.core.types.ReferenceJson

A Bokeh protocol “structure” of this model, i.e. a dict of the form:

{
    'type' : << view model name >>
    'id'   : << unique model id >>
}

Additionally there may be a subtype field if this model is a subtype.

GeoJSONDataSource

class GeoJSONDataSource(*args, **kwargs)[source]

Bases: bokeh.models.sources.ColumnarDataSource

JSON Prototype
{
  "id": "1236",
  "js_event_callbacks": {},
  "js_property_callbacks": {},
  "name": null,
  "selected": {
    "id": "1238"
  },
  "selection_policy": {
    "id": "1237"
  },
  "subscribed_events": [],
  "syncable": true,
  "tags": []
}

Public Data Attributes:

geojson

GeoJSON that contains features for plotting.

Inherited from : py: class:ColumnarDataSource

selection_policy

An instance of a SelectionPolicy that determines how selections are set.

Inherited from : py: class:DataSource

selected

An instance of a Selection that indicates selected indices on this DataSource.

Inherited from : py: class:Model

model_class_reverse_map

id

ref

struct

A Bokeh protocol "structure" of this model, i.e. a dict of the form:.

name

An arbitrary, user-supplied name for this model.

tags

An optional list of arbitrary, user-supplied values to attach to this model.

js_event_callbacks

A mapping of event names to lists of CustomJS callbacks.

subscribed_events

List of events that are subscribed to by Python callbacks.

js_property_callbacks

A mapping of attribute names to lists of CustomJS callbacks, to be set up on BokehJS side when the document is created.

syncable

Indicates whether this model should be synchronized back to a Bokeh server when updated in a web browser.

Inherited from : py: class:HasDocumentRef

document

The Document this model is attached to (can be None)

Public Methods:

Inherited from : py: class:Model

__init_subclass__()

This method is called when a class is subclassed.

__new__(cls, *args, **kwargs)

__init__(**kwargs)

__str__()

Return str(self).

__repr__()

Return repr(self).

destroy()

Clean up references to the document and property

js_on_event(event, *callbacks)

js_link(attr, other, other_attr[, attr_selector])

Link two Bokeh model properties using JavaScript.

js_on_change(event, *callbacks)

Attach a CustomJS callback to an arbitrary BokehJS model event.

on_change(attr, *callbacks)

Add a callback on this object to trigger when attr changes.

references()

Returns all Models that this object has references to.

select(selector)

Query this object and all of its references for objects that match the given selector.

select_one(selector)

Query this object and all of its references for objects that match the given selector.

set_select(selector, updates)

Update objects that match a given selector with the specified attribute/value updates.

to_json(include_defaults)

Returns a dictionary of the attributes of this object, containing only "JSON types" (string, number, boolean, none, dict, list).

to_json_string(include_defaults)

Returns a JSON string encoding the attributes of this object.

trigger(attr, old, new[, hint, setter])

Inherited from : py: class:HasProps

__init__(**kwargs)

__setattr__(name, value)

Intercept attribute setting on HasProps in order to special case a few situations:

__getattr__(name)

Intercept attribute setting on HasProps in order to special case a few situations:

__str__()

Return str(self).

__repr__()

Return repr(self).

equals(other)

Structural equality of models.

static_to_serializable(serializer)

to_serializable(serializer)

set_from_json(name, json, *[, models, setter])

Set a property value on this object from JSON.

update(**kwargs)

Updates the object's properties from the given keyword arguments.

update_from_json(json_attributes, *[, ...])

Updates the object's properties from a JSON attributes dictionary.

lookup(name, *[, raises])

Find the PropertyDescriptor for a Bokeh property on a class, given the property name.

properties(*[, _with_props])

Collect the names of properties on this class.

properties_with_refs()

Collect the names of all properties on this class that also have references.

dataspecs()

Collect the names of all DataSpec properties on this class.

properties_with_values(*[, ...])

Collect a dict mapping property names to their values.

query_properties_with_values(query, *[, ...])

Query the properties values of HasProps instances with a predicate.

themed_values()

Get any theme-provided overrides.

apply_theme(property_values)

Apply a set of theme values which will be used rather than defaults, but will not override application-set values.

unapply_theme()

Remove any themed values and restore defaults.

Inherited from : py: class:HasDocumentRef

__init__(**kwargs)

Inherited from : py: class:PropertyCallbackManager

__init__(**kwargs)

on_change(attr, *callbacks)

Add a callback on this object to trigger when attr changes.

remove_on_change(attr, *callbacks)

Remove a callback from this object

trigger(attr, old, new[, hint, setter])

Inherited from : py: class:EventCallbackManager

__init__(**kwargs)

on_event(event, *callbacks)

Run callbacks when the specified event occurs on this Model


geojson = Undefined
Type

NonNullable(JSON)

GeoJSON that contains features for plotting. Currently GeoJSONDataSource can only process a FeatureCollection or GeometryCollection.

name = None
Type

Nullable(String)

An arbitrary, user-supplied name for this model.

This name can be useful when querying the document to retrieve specific Bokeh models.

>>> plot.circle([1,2,3], [4,5,6], name="temp")
>>> plot.select(name="temp")
[GlyphRenderer(id='399d53f5-73e9-44d9-9527-544b761c7705', ...)]

Note

No uniqueness guarantees or other conditions are enforced on any names that are provided, nor is the name used directly by Bokeh for any reason.

selected = Selection(id='1242', ...)
Type

Readonly

An instance of a Selection that indicates selected indices on this DataSource. This is a read-only property. You may only change the attributes of this object to change the selection (e.g., selected.indices).

selection_policy = UnionRenderers(id='1244', ...)
Type

Instance(SelectionPolicy)

An instance of a SelectionPolicy that determines how selections are set.

syncable = True
Type

Bool

Indicates whether this model should be synchronized back to a Bokeh server when updated in a web browser. Setting to False may be useful to reduce network traffic when dealing with frequently updated objects whose updated values we don’t need.

Note

Setting this property to False will prevent any on_change() callbacks on this object from triggering. However, any JS-side callbacks will still work.

tags = []
Type

List

An optional list of arbitrary, user-supplied values to attach to this model.

This data can be useful when querying the document to retrieve specific Bokeh models:

>>> r = plot.circle([1,2,3], [4,5,6])
>>> r.tags = ["foo", 10]
>>> plot.select(tags=['foo', 10])
[GlyphRenderer(id='1de4c3df-a83d-480a-899b-fb263d3d5dd9', ...)]

Or simply a convenient way to attach any necessary metadata to a model that can be accessed by CustomJS callbacks, etc.

Note

No uniqueness guarantees or other conditions are enforced on any tags that are provided, nor are the tags used directly by Bokeh for any reason.

apply_theme(property_values: Dict[str, Any]) None

Apply a set of theme values which will be used rather than defaults, but will not override application-set values.

The passed-in dictionary may be kept around as-is and shared with other instances to save memory (so neither the caller nor the HasProps instance should modify it).

Parameters

property_values (dict) – theme values to use in place of defaults

Returns

None

classmethod dataspecs() Dict[str, DataSpec]

Collect the names of all DataSpec properties on this class.

This method always traverses the class hierarchy and includes properties defined on any parent classes.

Returns

names of DataSpec properties

Return type

set[str]

destroy() None

Clean up references to the document and property

equals(other: bokeh.core.has_props.HasProps) bool

Structural equality of models.

Parameters

other (HasProps) – the other instance to compare to

Returns

True, if properties are structurally equal, otherwise False

Link two Bokeh model properties using JavaScript.

This is a convenience method that simplifies adding a CustomJS callback to update one Bokeh model property whenever another changes value.

Parameters
  • attr (str) – The name of a Bokeh property on this model

  • other (Model) – A Bokeh model to link to self.attr

  • other_attr (str) – The property on other to link together

  • attr_selector (Union[int, str]) – The index to link an item in a subscriptable attr

Added in version 1.1

Raises

ValueError

Examples

This code with js_link:

select.js_link('value', plot, 'sizing_mode')

is equivalent to the following:

from bokeh.models import CustomJS
select.js_on_change('value',
    CustomJS(args=dict(other=plot),
             code="other.sizing_mode = this.value"
    )
)

Additionally, to use attr_selector to attach the left side of a range slider to a plot’s x_range:

range_slider.js_link('value', plot.x_range, 'start', attr_selector=0)

which is equivalent to:

from bokeh.models import CustomJS
range_slider.js_on_change('value',
    CustomJS(args=dict(other=plot.x_range),
             code="other.start = this.value[0]"
    )
)
js_on_change(event: str, *callbacks: JSEventCallback) None

Attach a CustomJS callback to an arbitrary BokehJS model event.

On the BokehJS side, change events for model properties have the form "change:property_name". As a convenience, if the event name passed to this method is also the name of a property on the model, then it will be prefixed with "change:" automatically:

# these two are equivalent
source.js_on_change('data', callback)
source.js_on_change('change:data', callback)

However, there are other kinds of events that can be useful to respond to, in addition to property change events. For example to run a callback whenever data is streamed to a ColumnDataSource, use the "stream" event on the source:

source.js_on_change('streaming', callback)
classmethod lookup(name: str, *, raises: bool = True) Optional[bokeh.core.property.descriptors.PropertyDescriptor[Any]]

Find the PropertyDescriptor for a Bokeh property on a class, given the property name.

Parameters
  • name (str) – name of the property to search for

  • raises (bool) – whether to raise or return None if missing

Returns

descriptor for property named name

Return type

PropertyDescriptor

on_change(attr: str, *callbacks: PropertyCallback) None

Add a callback on this object to trigger when attr changes.

Parameters
  • attr (str) – an attribute name on this object

  • *callbacks (callable) – callback functions to register

Returns

None

Example:

widget.on_change('value', callback1, callback2, ..., callback_n)
on_event(event: Union[str, Type[bokeh.events.Event]], *callbacks: Union[Callable[[bokeh.events.Event], None], Callable[[], None]]) None

Run callbacks when the specified event occurs on this Model

Not all Events are supported for all Models. See specific Events in bokeh.events for more information on which Models are able to trigger them.

classmethod properties(*, _with_props: bool = False) Union[Set[str], Dict[str, Property[Any]]]

Collect the names of properties on this class.

Warning

In a future version of Bokeh, this method will return a dictionary mapping property names to property objects. To future-proof this current usage of this method, wrap the return value in list.

Returns

property names

classmethod properties_with_refs() Dict[str, Property[Any]]

Collect the names of all properties on this class that also have references.

This method always traverses the class hierarchy and includes properties defined on any parent classes.

Returns

names of properties that have references

Return type

set[str]

properties_with_values(*, include_defaults: bool = True, include_undefined: bool = False) Dict[str, Any]

Collect a dict mapping property names to their values.

This method always traverses the class hierarchy and includes properties defined on any parent classes.

Non-serializable properties are skipped and property values are in “serialized” format which may be slightly different from the values you would normally read from the properties; the intent of this method is to return the information needed to losslessly reconstitute the object instance.

Parameters

include_defaults (bool, optional) – Whether to include properties that haven’t been explicitly set since the object was created. (default: True)

Returns

mapping from property names to their values

Return type

dict

query_properties_with_values(query: Callable[[bokeh.core.property.descriptors.PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) Dict[str, Any]

Query the properties values of HasProps instances with a predicate.

Parameters
  • query (callable) – A callable that accepts property descriptors and returns True or False

  • include_defaults (bool, optional) – Whether to include properties that have not been explicitly set by a user (default: True)

Returns

mapping of property names and values for matching properties

Return type

dict

references() Set[bokeh.model.model.Model]

Returns all Models that this object has references to.

remove_on_change(attr: str, *callbacks: Callable[[str, Any, Any], None]) None

Remove a callback from this object

select(selector: SelectorType) Iterable[Model]

Query this object and all of its references for objects that match the given selector.

Parameters

selector (JSON-like) –

Returns

seq[Model]

select_one(selector: SelectorType) Model | None

Query this object and all of its references for objects that match the given selector. Raises an error if more than one object is found. Returns single matching object, or None if nothing is found :param selector: :type selector: JSON-like

Returns

Model

set_from_json(name: str, json: JSON, *, models: Dict[ID, HasProps] | None = None, setter: Setter | None = None) None

Set a property value on this object from JSON.

Parameters
  • name – (str) : name of the attribute to set

  • json – (JSON-value) : value to set to the attribute to

  • models (dict or None, optional) –

    Mapping of model ids to models (default: None)

    This is needed in cases where the attributes to update also have values that have references.

  • setter (ClientSession or ServerSession or None, optional) –

    This is used to prevent “boomerang” updates to Bokeh apps.

    In the context of a Bokeh server application, incoming updates to properties will be annotated with the session that is doing the updating. This value is propagated through any subsequent change notifications that the update triggers. The session can compare the event setter to itself, and suppress any updates that originate from itself.

Returns

None

set_select(selector: Type[Model] | SelectorType, updates: Dict[str, Unknown]) None

Update objects that match a given selector with the specified attribute/value updates.

Parameters
  • selector (JSON-like) –

  • updates (dict) –

Returns

None

themed_values() Optional[Dict[str, Any]]

Get any theme-provided overrides.

Results are returned as a dict from property name to value, or None if no theme overrides any values for this instance.

Returns

dict or None

to_json(include_defaults: bool) JSON

Returns a dictionary of the attributes of this object, containing only “JSON types” (string, number, boolean, none, dict, list).

References to other objects are serialized as “refs” (just the object ID and type info), so the deserializer will need to separately have the full attributes of those other objects.

There’s no corresponding from_json() because to deserialize an object is normally done in the context of a Document (since the Document can resolve references).

For most purposes it’s best to serialize and deserialize entire documents.

Parameters

include_defaults (bool) – whether to include attributes that haven’t been changed from the default

to_json_string(include_defaults: bool) str

Returns a JSON string encoding the attributes of this object.

References to other objects are serialized as references (just the object ID and type info), so the deserializer will need to separately have the full attributes of those other objects.

There’s no corresponding from_json_string() because to deserialize an object is normally done in the context of a Document (since the Document can resolve references).

For most purposes it’s best to serialize and deserialize entire documents.

Parameters

include_defaults (bool) – whether to include attributes that haven’t been changed from the default

trigger(attr: str, old: Unknown, new: Unknown, hint: DocumentPatchedEvent | None = None, setter: Setter | None = None) None
unapply_theme() None

Remove any themed values and restore defaults.

Returns

None

update(**kwargs: Any) None

Updates the object’s properties from the given keyword arguments.

Returns

None

Examples

The following are equivalent:

from bokeh.models import Range1d

r = Range1d

# set properties individually:
r.start = 10
r.end = 20

# update properties together:
r.update(start=10, end=20)
update_from_json(json_attributes: Dict[str, JSON], *, models: Mapping[ID, HasProps] | None = None, setter: Setter | None = None) None

Updates the object’s properties from a JSON attributes dictionary.

Parameters
  • json_attributes – (JSON-dict) : attributes and values to update

  • models (dict or None, optional) –

    Mapping of model ids to models (default: None)

    This is needed in cases where the attributes to update also have values that have references.

  • setter (ClientSession or ServerSession or None, optional) –

    This is used to prevent “boomerang” updates to Bokeh apps.

    In the context of a Bokeh server application, incoming updates to properties will be annotated with the session that is doing the updating. This value is propagated through any subsequent change notifications that the update triggers. The session can compare the event setter to itself, and suppress any updates that originate from itself.

Returns

None

property document: Document | None

The Document this model is attached to (can be None)

property struct: bokeh.core.types.ReferenceJson

A Bokeh protocol “structure” of this model, i.e. a dict of the form:

{
    'type' : << view model name >>
    'id'   : << unique model id >>
}

Additionally there may be a subtype field if this model is a subtype.

ServerSentDataSource

class ServerSentDataSource(*args, **kwargs)[source]

Bases: bokeh.models.sources.WebDataSource

A data source that can populate columns by receiving server sent events endpoints.

JSON Prototype
{
  "adapter": null,
  "data": {},
  "id": "1247",
  "js_event_callbacks": {},
  "js_property_callbacks": {},
  "max_size": null,
  "mode": "replace",
  "name": null,
  "selected": {
    "id": "1249"
  },
  "selection_policy": {
    "id": "1248"
  },
  "subscribed_events": [],
  "syncable": true,
  "tags": []
}

Public Data Attributes:

Inherited from : py: class:WebDataSource

adapter

A JavaScript callback to adapt raw JSON responses to Bokeh ColumnDataSource format.

max_size

Maximum size of the data columns.

mode

Whether to append new data to existing data (up to max_size), or to replace existing data entirely.

data_url

A URL to to fetch data from.

Inherited from : py: class:ColumnDataSource

column_names

A list of the column names in this data source.

data

Mapping of column names to sequences of data.

Inherited from : py: class:ColumnarDataSource

selection_policy

An instance of a SelectionPolicy that determines how selections are set.

Inherited from : py: class:DataSource

selected

An instance of a Selection that indicates selected indices on this DataSource.

Inherited from : py: class:Model

model_class_reverse_map

id

ref

struct

A Bokeh protocol "structure" of this model, i.e. a dict of the form:.

name

An arbitrary, user-supplied name for this model.

tags

An optional list of arbitrary, user-supplied values to attach to this model.

js_event_callbacks

A mapping of event names to lists of CustomJS callbacks.

subscribed_events

List of events that are subscribed to by Python callbacks.

js_property_callbacks

A mapping of attribute names to lists of CustomJS callbacks, to be set up on BokehJS side when the document is created.

syncable

Indicates whether this model should be synchronized back to a Bokeh server when updated in a web browser.

Inherited from : py: class:HasDocumentRef

document

The Document this model is attached to (can be None)

Public Methods:

Inherited from : py: class:ColumnDataSource

__init__(*args, **kwargs)

If called with a single argument that is a dict or pandas.DataFrame, treat that implicitly as the "data" attribute.

from_df(data)

Create a dict of columns from a Pandas DataFrame, suitable for creating a ColumnDataSource.

from_groupby(data)

Create a dict of columns from a Pandas GroupBy, suitable for creating a ColumnDataSource.

to_df()

Convert this data source to pandas DataFrame.

add(data[, name])

Appends a new column of data to the data source.

remove(name)

Remove a column of data.

stream(new_data[, rollover])

Efficiently update data source columns with new append-only data.

patch(patches[, setter])

Efficiently update data source columns at specific locations

Inherited from : py: class:Model

__init_subclass__()

This method is called when a class is subclassed.

__new__(cls, *args, **kwargs)

__init__(*args, **kwargs)

If called with a single argument that is a dict or pandas.DataFrame, treat that implicitly as the "data" attribute.

__str__()

Return str(self).

__repr__()

Return repr(self).

destroy()

Clean up references to the document and property

js_on_event(event, *callbacks)

js_link(attr, other, other_attr[, attr_selector])

Link two Bokeh model properties using JavaScript.

js_on_change(event, *callbacks)

Attach a CustomJS callback to an arbitrary BokehJS model event.

on_change(attr, *callbacks)

Add a callback on this object to trigger when attr changes.

references()

Returns all Models that this object has references to.

select(selector)

Query this object and all of its references for objects that match the given selector.

select_one(selector)

Query this object and all of its references for objects that match the given selector.

set_select(selector, updates)

Update objects that match a given selector with the specified attribute/value updates.

to_json(include_defaults)

Returns a dictionary of the attributes of this object, containing only "JSON types" (string, number, boolean, none, dict, list).

to_json_string(include_defaults)

Returns a JSON string encoding the attributes of this object.

trigger(attr, old, new[, hint, setter])

Inherited from : py: class:HasProps

__init__(*args, **kwargs)

If called with a single argument that is a dict or pandas.DataFrame, treat that implicitly as the "data" attribute.

__setattr__(name, value)

Intercept attribute setting on HasProps in order to special case a few situations:

__getattr__(name)

Intercept attribute setting on HasProps in order to special case a few situations:

__str__()

Return str(self).

__repr__()

Return repr(self).

equals(other)

Structural equality of models.

static_to_serializable(serializer)

to_serializable(serializer)

set_from_json(name, json, *[, models, setter])

Set a property value on this object from JSON.

update(**kwargs)

Updates the object's properties from the given keyword arguments.

update_from_json(json_attributes, *[, ...])

Updates the object's properties from a JSON attributes dictionary.

lookup(name, *[, raises])

Find the PropertyDescriptor for a Bokeh property on a class, given the property name.

properties(*[, _with_props])

Collect the names of properties on this class.

properties_with_refs()

Collect the names of all properties on this class that also have references.

dataspecs()

Collect the names of all DataSpec properties on this class.

properties_with_values(*[, ...])

Collect a dict mapping property names to their values.

query_properties_with_values(query, *[, ...])

Query the properties values of HasProps instances with a predicate.

themed_values()

Get any theme-provided overrides.

apply_theme(property_values)

Apply a set of theme values which will be used rather than defaults, but will not override application-set values.

unapply_theme()

Remove any themed values and restore defaults.

Inherited from : py: class:HasDocumentRef

__init__(*args, **kwargs)

If called with a single argument that is a dict or pandas.DataFrame, treat that implicitly as the "data" attribute.

Inherited from : py: class:PropertyCallbackManager

__init__(*args, **kwargs)

If called with a single argument that is a dict or pandas.DataFrame, treat that implicitly as the "data" attribute.

on_change(attr, *callbacks)

Add a callback on this object to trigger when attr changes.

remove_on_change(attr, *callbacks)

Remove a callback from this object

trigger(attr, old, new[, hint, setter])

Inherited from : py: class:EventCallbackManager

__init__(*args, **kwargs)

If called with a single argument that is a dict or pandas.DataFrame, treat that implicitly as the "data" attribute.

on_event(event, *callbacks)

Run callbacks when the specified event occurs on this Model


adapter = None
Type

Nullable(Instance(CustomJS))

A JavaScript callback to adapt raw JSON responses to Bokeh ColumnDataSource format.

If provided, this callback is executes immediately after the JSON data is received, but before appending or replacing data in the data source. The CustomJS callback will receive the AjaxDataSource as cb_obj and will receive the raw JSON response as cb_data.response. The callback code should return a data object suitable for a Bokeh ColumnDataSource (i.e. a mapping of string column names to arrays of data).

data = {}
Type

ColumnData

Mapping of column names to sequences of data. The columns can be, e.g, Python lists or tuples, NumPy arrays, etc.

The .data attribute can also be set from Pandas DataFrames or GroupBy objects. In these cases, the behaviour is identical to passing the objects to the ColumnDataSource initializer.

data_url = Undefined
Type

NonNullable(String)

A URL to to fetch data from.

max_size = None
Type

Nullable(Int)

Maximum size of the data columns. If a new fetch would result in columns larger than max_size, then earlier data is dropped to make room.

mode = 'replace'
Type

Enum(Enumeration(replace, append))

Whether to append new data to existing data (up to max_size), or to replace existing data entirely.

name = None
Type

Nullable(String)

An arbitrary, user-supplied name for this model.

This name can be useful when querying the document to retrieve specific Bokeh models.

>>> plot.circle([1,2,3], [4,5,6], name="temp")
>>> plot.select(name="temp")
[GlyphRenderer(id='399d53f5-73e9-44d9-9527-544b761c7705', ...)]

Note

No uniqueness guarantees or other conditions are enforced on any names that are provided, nor is the name used directly by Bokeh for any reason.

selected = Selection(id='1257', ...)
Type

Readonly

An instance of a Selection that indicates selected indices on this DataSource. This is a read-only property. You may only change the attributes of this object to change the selection (e.g., selected.indices).

selection_policy = UnionRenderers(id='1259', ...)
Type

Instance(SelectionPolicy)

An instance of a SelectionPolicy that determines how selections are set.

syncable = True
Type

Bool

Indicates whether this model should be synchronized back to a Bokeh server when updated in a web browser. Setting to False may be useful to reduce network traffic when dealing with frequently updated objects whose updated values we don’t need.

Note

Setting this property to False will prevent any on_change() callbacks on this object from triggering. However, any JS-side callbacks will still work.

tags = []
Type

List

An optional list of arbitrary, user-supplied values to attach to this model.

This data can be useful when querying the document to retrieve specific Bokeh models:

>>> r = plot.circle([1,2,3], [4,5,6])
>>> r.tags = ["foo", 10]
>>> plot.select(tags=['foo', 10])
[GlyphRenderer(id='1de4c3df-a83d-480a-899b-fb263d3d5dd9', ...)]

Or simply a convenient way to attach any necessary metadata to a model that can be accessed by CustomJS callbacks, etc.

Note

No uniqueness guarantees or other conditions are enforced on any tags that are provided, nor are the tags used directly by Bokeh for any reason.

__init__(*args: Any, **kwargs: Any) None

If called with a single argument that is a dict or pandas.DataFrame, treat that implicitly as the “data” attribute.

add(data: Sequence[Unknown], name: str | None = None) str

Appends a new column of data to the data source.

Parameters
  • data (seq) – new data to add

  • name (str, optional) – column name to use. If not supplied, generate a name of the form “Series ####”

Returns

the column name used

Return type

str

apply_theme(property_values: Dict[str, Any]) None

Apply a set of theme values which will be used rather than defaults, but will not override application-set values.

The passed-in dictionary may be kept around as-is and shared with other instances to save memory (so neither the caller nor the HasProps instance should modify it).

Parameters

property_values (dict) – theme values to use in place of defaults

Returns

None

classmethod dataspecs() Dict[str, DataSpec]

Collect the names of all DataSpec properties on this class.

This method always traverses the class hierarchy and includes properties defined on any parent classes.

Returns

names of DataSpec properties

Return type

set[str]

destroy() None

Clean up references to the document and property

equals(other: bokeh.core.has_props.HasProps) bool

Structural equality of models.

Parameters

other (HasProps) – the other instance to compare to

Returns

True, if properties are structurally equal, otherwise False

classmethod from_df(data: pd.DataFrame) DataDict

Create a dict of columns from a Pandas DataFrame, suitable for creating a ColumnDataSource.

Parameters

data (DataFrame) – data to convert

Returns

dict[str, np.array]

classmethod from_groupby(data: pd.core.groupby.GroupBy) DataDict

Create a dict of columns from a Pandas GroupBy, suitable for creating a ColumnDataSource.

The data generated is the result of running describe on the group.

Parameters

data (Groupby) – data to convert

Returns

dict[str, np.array]

Link two Bokeh model properties using JavaScript.

This is a convenience method that simplifies adding a CustomJS callback to update one Bokeh model property whenever another changes value.

Parameters
  • attr (str) – The name of a Bokeh property on this model

  • other (Model) – A Bokeh model to link to self.attr

  • other_attr (str) – The property on other to link together

  • attr_selector (Union[int, str]) – The index to link an item in a subscriptable attr

Added in version 1.1

Raises

ValueError

Examples

This code with js_link:

select.js_link('value', plot, 'sizing_mode')

is equivalent to the following:

from bokeh.models import CustomJS
select.js_on_change('value',
    CustomJS(args=dict(other=plot),
             code="other.sizing_mode = this.value"
    )
)

Additionally, to use attr_selector to attach the left side of a range slider to a plot’s x_range:

range_slider.js_link('value', plot.x_range, 'start', attr_selector=0)

which is equivalent to:

from bokeh.models import CustomJS
range_slider.js_on_change('value',
    CustomJS(args=dict(other=plot.x_range),
             code="other.start = this.value[0]"
    )
)
js_on_change(event: str, *callbacks: JSEventCallback) None

Attach a CustomJS callback to an arbitrary BokehJS model event.

On the BokehJS side, change events for model properties have the form "change:property_name". As a convenience, if the event name passed to this method is also the name of a property on the model, then it will be prefixed with "change:" automatically:

# these two are equivalent
source.js_on_change('data', callback)
source.js_on_change('change:data', callback)

However, there are other kinds of events that can be useful to respond to, in addition to property change events. For example to run a callback whenever data is streamed to a ColumnDataSource, use the "stream" event on the source:

source.js_on_change('streaming', callback)
classmethod lookup(name: str, *, raises: bool = True) Optional[bokeh.core.property.descriptors.PropertyDescriptor[Any]]

Find the PropertyDescriptor for a Bokeh property on a class, given the property name.

Parameters
  • name (str) – name of the property to search for

  • raises (bool) – whether to raise or return None if missing

Returns

descriptor for property named name

Return type

PropertyDescriptor

on_change(attr: str, *callbacks: PropertyCallback) None

Add a callback on this object to trigger when attr changes.

Parameters
  • attr (str) – an attribute name on this object

  • *callbacks (callable) – callback functions to register

Returns

None

Example:

widget.on_change('value', callback1, callback2, ..., callback_n)
on_event(event: Union[str, Type[bokeh.events.Event]], *callbacks: Union[Callable[[bokeh.events.Event], None], Callable[[], None]]) None

Run callbacks when the specified event occurs on this Model

Not all Events are supported for all Models. See specific Events in bokeh.events for more information on which Models are able to trigger them.

patch(patches: Patches, setter: Setter | None = None) None

Efficiently update data source columns at specific locations

If it is only necessary to update a small subset of data in a ColumnDataSource, this method can be used to efficiently update only the subset, instead of requiring the entire data set to be sent.

This method should be passed a dictionary that maps column names to lists of tuples that describe a patch change to apply. To replace individual items in columns entirely, the tuples should be of the form:

(index, new_value)  # replace a single column value

# or

(slice, new_values) # replace several column values

Values at an index or slice will be replaced with the corresponding new values.

In the case of columns whose values are other arrays or lists, (e.g. image or patches glyphs), it is also possible to patch “subregions”. In this case the first item of the tuple should be a whose first element is the index of the array item in the CDS patch, and whose subsequent elements are integer indices or slices into the array item:

# replace the entire 10th column of the 2nd array:

  +----------------- index of item in column data source
  |
  |       +--------- row subindex into array item
  |       |
  |       |       +- column subindex into array item
  V       V       V
([2, slice(None), 10], new_values)

Imagining a list of 2d NumPy arrays, the patch above is roughly equivalent to:

data = [arr1, arr2, ...]  # list of 2d arrays

data[2][:, 10] = new_data

There are some limitations to the kinds of slices and data that can be accepted.

  • Negative start, stop, or step values for slices will result in a ValueError.

  • In a slice, start > stop will result in a ValueError

  • When patching 1d or 2d subitems, the subitems must be NumPy arrays.

  • New values must be supplied as a flattened one-dimensional array of the appropriate size.

Parameters

patches (dict[str, list[tuple]]) – lists of patches for each column

Returns

None

Raises

ValueError

Example:

The following example shows how to patch entire column elements. In this case,

source = ColumnDataSource(data=dict(foo=[10, 20, 30], bar=[100, 200, 300]))

patches = {
    'foo' : [ (slice(2), [11, 12]) ],
    'bar' : [ (0, 101), (2, 301) ],
}

source.patch(patches)

After this operation, the value of the source.data will be:

dict(foo=[11, 12, 30], bar=[101, 200, 301])

For a more comprehensive complete example, see examples/howto/patch_app.py.

classmethod properties(*, _with_props: bool = False) Union[Set[str], Dict[str, Property[Any]]]

Collect the names of properties on this class.

Warning

In a future version of Bokeh, this method will return a dictionary mapping property names to property objects. To future-proof this current usage of this method, wrap the return value in list.

Returns

property names

classmethod properties_with_refs() Dict[str, Property[Any]]

Collect the names of all properties on this class that also have references.

This method always traverses the class hierarchy and includes properties defined on any parent classes.

Returns

names of properties that have references

Return type

set[str]

properties_with_values(*, include_defaults: bool = True, include_undefined: bool = False) Dict[str, Any]

Collect a dict mapping property names to their values.

This method always traverses the class hierarchy and includes properties defined on any parent classes.

Non-serializable properties are skipped and property values are in “serialized” format which may be slightly different from the values you would normally read from the properties; the intent of this method is to return the information needed to losslessly reconstitute the object instance.

Parameters

include_defaults (bool, optional) – Whether to include properties that haven’t been explicitly set since the object was created. (default: True)

Returns

mapping from property names to their values

Return type

dict

query_properties_with_values(query: Callable[[bokeh.core.property.descriptors.PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) Dict[str, Any]

Query the properties values of HasProps instances with a predicate.

Parameters
  • query (callable) – A callable that accepts property descriptors and returns True or False

  • include_defaults (bool, optional) – Whether to include properties that have not been explicitly set by a user (default: True)

Returns

mapping of property names and values for matching properties

Return type

dict

references() Set[bokeh.model.model.Model]

Returns all Models that this object has references to.

remove(name: str) None

Remove a column of data.

Parameters

name (str) – name of the column to remove

Returns

None

Note

If the column name does not exist, a warning is issued.

remove_on_change(attr: str, *callbacks: Callable[[str, Any, Any], None]) None

Remove a callback from this object

select(selector: SelectorType) Iterable[Model]

Query this object and all of its references for objects that match the given selector.

Parameters

selector (JSON-like) –

Returns

seq[Model]

select_one(selector: SelectorType) Model | None

Query this object and all of its references for objects that match the given selector. Raises an error if more than one object is found. Returns single matching object, or None if nothing is found :param selector: :type selector: JSON-like

Returns

Model

set_from_json(name: str, json: JSON, *, models: Dict[ID, HasProps] | None = None, setter: Setter | None = None) None

Set a property value on this object from JSON.

Parameters
  • name – (str) : name of the attribute to set

  • json – (JSON-value) : value to set to the attribute to

  • models (dict or None, optional) –

    Mapping of model ids to models (default: None)

    This is needed in cases where the attributes to update also have values that have references.

  • setter (ClientSession or ServerSession or None, optional) –

    This is used to prevent “boomerang” updates to Bokeh apps.

    In the context of a Bokeh server application, incoming updates to properties will be annotated with the session that is doing the updating. This value is propagated through any subsequent change notifications that the update triggers. The session can compare the event setter to itself, and suppress any updates that originate from itself.

Returns

None

set_select(selector: Type[Model] | SelectorType, updates: Dict[str, Unknown]) None

Update objects that match a given selector with the specified attribute/value updates.

Parameters
  • selector (JSON-like) –

  • updates (dict) –

Returns

None

stream(new_data: DataDict, rollover: int | None = None) None

Efficiently update data source columns with new append-only data.

In cases where it is necessary to update data columns in, this method can efficiently send only the new data, instead of requiring the entire data set to be re-sent.

Parameters
  • new_data (dict[str, seq]) –

    a mapping of column names to sequences of new data to append to each column.

    All columns of the data source must be present in new_data, with identical-length append data.

  • rollover (int, optional) – A maximum column size, above which data from the start of the column begins to be discarded. If None, then columns will continue to grow unbounded (default: None)

Returns

None

Raises

ValueError

Example:

source = ColumnDataSource(data=dict(foo=[], bar=[]))

# has new, identical-length updates for all columns in source
new_data = {
    'foo' : [10, 20],
    'bar' : [100, 200],
}

source.stream(new_data)
themed_values() Optional[Dict[str, Any]]

Get any theme-provided overrides.

Results are returned as a dict from property name to value, or None if no theme overrides any values for this instance.

Returns

dict or None

to_df() pandas.core.frame.DataFrame

Convert this data source to pandas DataFrame.

Returns

DataFrame

to_json(include_defaults: bool) JSON

Returns a dictionary of the attributes of this object, containing only “JSON types” (string, number, boolean, none, dict, list).

References to other objects are serialized as “refs” (just the object ID and type info), so the deserializer will need to separately have the full attributes of those other objects.

There’s no corresponding from_json() because to deserialize an object is normally done in the context of a Document (since the Document can resolve references).

For most purposes it’s best to serialize and deserialize entire documents.

Parameters

include_defaults (bool) – whether to include attributes that haven’t been changed from the default

to_json_string(include_defaults: bool) str

Returns a JSON string encoding the attributes of this object.

References to other objects are serialized as references (just the object ID and type info), so the deserializer will need to separately have the full attributes of those other objects.

There’s no corresponding from_json_string() because to deserialize an object is normally done in the context of a Document (since the Document can resolve references).

For most purposes it’s best to serialize and deserialize entire documents.

Parameters

include_defaults (bool) – whether to include attributes that haven’t been changed from the default

trigger(attr: str, old: Unknown, new: Unknown, hint: DocumentPatchedEvent | None = None, setter: Setter | None = None) None
unapply_theme() None

Remove any themed values and restore defaults.

Returns

None

update(**kwargs: Any) None

Updates the object’s properties from the given keyword arguments.

Returns

None

Examples

The following are equivalent:

from bokeh.models import Range1d

r = Range1d

# set properties individually:
r.start = 10
r.end = 20

# update properties together:
r.update(start=10, end=20)
update_from_json(json_attributes: Dict[str, JSON], *, models: Mapping[ID, HasProps] | None = None, setter: Setter | None = None) None

Updates the object’s properties from a JSON attributes dictionary.

Parameters
  • json_attributes – (JSON-dict) : attributes and values to update

  • models (dict or None, optional) –

    Mapping of model ids to models (default: None)

    This is needed in cases where the attributes to update also have values that have references.

  • setter (ClientSession or ServerSession or None, optional) –

    This is used to prevent “boomerang” updates to Bokeh apps.

    In the context of a Bokeh server application, incoming updates to properties will be annotated with the session that is doing the updating. This value is propagated through any subsequent change notifications that the update triggers. The session can compare the event setter to itself, and suppress any updates that originate from itself.

Returns

None

property column_names: List[str]

A list of the column names in this data source.

property document: Document | None

The Document this model is attached to (can be None)

property struct: bokeh.core.types.ReferenceJson

A Bokeh protocol “structure” of this model, i.e. a dict of the form:

{
    'type' : << view model name >>
    'id'   : << unique model id >>
}

Additionally there may be a subtype field if this model is a subtype.

WebDataSource

class WebDataSource(*args, **kwargs)[source]

Bases: bokeh.models.sources.ColumnDataSource

Base class for web column data sources that can update from data URLs.

Note

This base class is typically not useful to instantiate on its own.

Note

This is an abstract base class used to help organize the hierarchy of Bokeh model types. It is not useful to instantiate on its own.

JSON Prototype
{
  "adapter": null,
  "data": {},
  "id": "1262",
  "js_event_callbacks": {},
  "js_property_callbacks": {},
  "max_size": null,
  "mode": "replace",
  "name": null,
  "selected": {
    "id": "1264"
  },
  "selection_policy": {
    "id": "1263"
  },
  "subscribed_events": [],
  "syncable": true,
  "tags": []
}

Public Data Attributes:

adapter

A JavaScript callback to adapt raw JSON responses to Bokeh ColumnDataSource format.

max_size

Maximum size of the data columns.

mode

Whether to append new data to existing data (up to max_size), or to replace existing data entirely.

data_url

A URL to to fetch data from.

Inherited from : py: class:ColumnDataSource

column_names

A list of the column names in this data source.

data

Mapping of column names to sequences of data.

Inherited from : py: class:ColumnarDataSource

selection_policy

An instance of a SelectionPolicy that determines how selections are set.

Inherited from : py: class:DataSource

selected

An instance of a Selection that indicates selected indices on this DataSource.

Inherited from : py: class:Model

model_class_reverse_map

id

ref

struct

A Bokeh protocol "structure" of this model, i.e. a dict of the form:.

name

An arbitrary, user-supplied name for this model.

tags

An optional list of arbitrary, user-supplied values to attach to this model.

js_event_callbacks

A mapping of event names to lists of CustomJS callbacks.

subscribed_events

List of events that are subscribed to by Python callbacks.

js_property_callbacks

A mapping of attribute names to lists of CustomJS callbacks, to be set up on BokehJS side when the document is created.

syncable

Indicates whether this model should be synchronized back to a Bokeh server when updated in a web browser.

Inherited from : py: class:HasDocumentRef

document

The Document this model is attached to (can be None)

Public Methods:

Inherited from : py: class:ColumnDataSource

__init__(*args, **kwargs)

If called with a single argument that is a dict or pandas.DataFrame, treat that implicitly as the "data" attribute.

from_df(data)

Create a dict of columns from a Pandas DataFrame, suitable for creating a ColumnDataSource.

from_groupby(data)

Create a dict of columns from a Pandas GroupBy, suitable for creating a ColumnDataSource.

to_df()

Convert this data source to pandas DataFrame.

add(data[, name])

Appends a new column of data to the data source.

remove(name)

Remove a column of data.

stream(new_data[, rollover])

Efficiently update data source columns with new append-only data.

patch(patches[, setter])

Efficiently update data source columns at specific locations

Inherited from : py: class:Model

__init_subclass__()

This method is called when a class is subclassed.

__new__(cls, *args, **kwargs)

__init__(*args, **kwargs)

If called with a single argument that is a dict or pandas.DataFrame, treat that implicitly as the "data" attribute.

__str__()

Return str(self).

__repr__()

Return repr(self).

destroy()

Clean up references to the document and property

js_on_event(event, *callbacks)

js_link(attr, other, other_attr[, attr_selector])

Link two Bokeh model properties using JavaScript.

js_on_change(event, *callbacks)

Attach a CustomJS callback to an arbitrary BokehJS model event.

on_change(attr, *callbacks)

Add a callback on this object to trigger when attr changes.

references()

Returns all Models that this object has references to.

select(selector)

Query this object and all of its references for objects that match the given selector.

select_one(selector)

Query this object and all of its references for objects that match the given selector.

set_select(selector, updates)

Update objects that match a given selector with the specified attribute/value updates.

to_json(include_defaults)

Returns a dictionary of the attributes of this object, containing only "JSON types" (string, number, boolean, none, dict, list).

to_json_string(include_defaults)

Returns a JSON string encoding the attributes of this object.

trigger(attr, old, new[, hint, setter])

Inherited from : py: class:HasProps

__init__(*args, **kwargs)

If called with a single argument that is a dict or pandas.DataFrame, treat that implicitly as the "data" attribute.

__setattr__(name, value)

Intercept attribute setting on HasProps in order to special case a few situations:

__getattr__(name)

Intercept attribute setting on HasProps in order to special case a few situations:

__str__()

Return str(self).

__repr__()

Return repr(self).

equals(other)

Structural equality of models.

static_to_serializable(serializer)

to_serializable(serializer)

set_from_json(name, json, *[, models, setter])

Set a property value on this object from JSON.

update(**kwargs)

Updates the object's properties from the given keyword arguments.

update_from_json(json_attributes, *[, ...])

Updates the object's properties from a JSON attributes dictionary.

lookup(name, *[, raises])

Find the PropertyDescriptor for a Bokeh property on a class, given the property name.

properties(*[, _with_props])

Collect the names of properties on this class.

properties_with_refs()

Collect the names of all properties on this class that also have references.

dataspecs()

Collect the names of all DataSpec properties on this class.

properties_with_values(*[, ...])

Collect a dict mapping property names to their values.

query_properties_with_values(query, *[, ...])

Query the properties values of HasProps instances with a predicate.

themed_values()

Get any theme-provided overrides.

apply_theme(property_values)

Apply a set of theme values which will be used rather than defaults, but will not override application-set values.

unapply_theme()

Remove any themed values and restore defaults.

Inherited from : py: class:HasDocumentRef

__init__(*args, **kwargs)

If called with a single argument that is a dict or pandas.DataFrame, treat that implicitly as the "data" attribute.

Inherited from : py: class:PropertyCallbackManager

__init__(*args, **kwargs)

If called with a single argument that is a dict or pandas.DataFrame, treat that implicitly as the "data" attribute.

on_change(attr, *callbacks)

Add a callback on this object to trigger when attr changes.

remove_on_change(attr, *callbacks)

Remove a callback from this object

trigger(attr, old, new[, hint, setter])

Inherited from : py: class:EventCallbackManager

__init__(*args, **kwargs)

If called with a single argument that is a dict or pandas.DataFrame, treat that implicitly as the "data" attribute.

on_event(event, *callbacks)

Run callbacks when the specified event occurs on this Model


adapter = None
Type

Nullable(Instance(CustomJS))

A JavaScript callback to adapt raw JSON responses to Bokeh ColumnDataSource format.

If provided, this callback is executes immediately after the JSON data is received, but before appending or replacing data in the data source. The CustomJS callback will receive the AjaxDataSource as cb_obj and will receive the raw JSON response as cb_data.response. The callback code should return a data object suitable for a Bokeh ColumnDataSource (i.e. a mapping of string column names to arrays of data).

data = {}
Type

ColumnData

Mapping of column names to sequences of data. The columns can be, e.g, Python lists or tuples, NumPy arrays, etc.

The .data attribute can also be set from Pandas DataFrames or GroupBy objects. In these cases, the behaviour is identical to passing the objects to the ColumnDataSource initializer.

data_url = Undefined
Type

NonNullable(String)

A URL to to fetch data from.

max_size = None
Type

Nullable(Int)

Maximum size of the data columns. If a new fetch would result in columns larger than max_size, then earlier data is dropped to make room.

mode = 'replace'
Type

Enum(Enumeration(replace, append))

Whether to append new data to existing data (up to max_size), or to replace existing data entirely.

name = None
Type

Nullable(String)

An arbitrary, user-supplied name for this model.

This name can be useful when querying the document to retrieve specific Bokeh models.

>>> plot.circle([1,2,3], [4,5,6], name="temp")
>>> plot.select(name="temp")
[GlyphRenderer(id='399d53f5-73e9-44d9-9527-544b761c7705', ...)]

Note

No uniqueness guarantees or other conditions are enforced on any names that are provided, nor is the name used directly by Bokeh for any reason.

selected = Selection(id='1272', ...)
Type

Readonly

An instance of a Selection that indicates selected indices on this DataSource. This is a read-only property. You may only change the attributes of this object to change the selection (e.g., selected.indices).

selection_policy = UnionRenderers(id='1274', ...)
Type

Instance(SelectionPolicy)

An instance of a SelectionPolicy that determines how selections are set.

syncable = True
Type

Bool

Indicates whether this model should be synchronized back to a Bokeh server when updated in a web browser. Setting to False may be useful to reduce network traffic when dealing with frequently updated objects whose updated values we don’t need.

Note

Setting this property to False will prevent any on_change() callbacks on this object from triggering. However, any JS-side callbacks will still work.

tags = []
Type

List

An optional list of arbitrary, user-supplied values to attach to this model.

This data can be useful when querying the document to retrieve specific Bokeh models:

>>> r = plot.circle([1,2,3], [4,5,6])
>>> r.tags = ["foo", 10]
>>> plot.select(tags=['foo', 10])
[GlyphRenderer(id='1de4c3df-a83d-480a-899b-fb263d3d5dd9', ...)]

Or simply a convenient way to attach any necessary metadata to a model that can be accessed by CustomJS callbacks, etc.

Note

No uniqueness guarantees or other conditions are enforced on any tags that are provided, nor are the tags used directly by Bokeh for any reason.

__init__(*args: Any, **kwargs: Any) None

If called with a single argument that is a dict or pandas.DataFrame, treat that implicitly as the “data” attribute.

add(data: Sequence[Unknown], name: str | None = None) str

Appends a new column of data to the data source.

Parameters
  • data (seq) – new data to add

  • name (str, optional) – column name to use. If not supplied, generate a name of the form “Series ####”

Returns

the column name used

Return type

str

apply_theme(property_values: Dict[str, Any]) None

Apply a set of theme values which will be used rather than defaults, but will not override application-set values.

The passed-in dictionary may be kept around as-is and shared with other instances to save memory (so neither the caller nor the HasProps instance should modify it).

Parameters

property_values (dict) – theme values to use in place of defaults

Returns

None

classmethod dataspecs() Dict[str, DataSpec]

Collect the names of all DataSpec properties on this class.

This method always traverses the class hierarchy and includes properties defined on any parent classes.

Returns

names of DataSpec properties

Return type

set[str]

destroy() None

Clean up references to the document and property

equals(other: bokeh.core.has_props.HasProps) bool

Structural equality of models.

Parameters

other (HasProps) – the other instance to compare to

Returns

True, if properties are structurally equal, otherwise False

classmethod from_df(data: pd.DataFrame) DataDict

Create a dict of columns from a Pandas DataFrame, suitable for creating a ColumnDataSource.

Parameters

data (DataFrame) – data to convert

Returns

dict[str, np.array]

classmethod from_groupby(data: pd.core.groupby.GroupBy) DataDict

Create a dict of columns from a Pandas GroupBy, suitable for creating a ColumnDataSource.

The data generated is the result of running describe on the group.

Parameters

data (Groupby) – data to convert

Returns

dict[str, np.array]

Link two Bokeh model properties using JavaScript.

This is a convenience method that simplifies adding a CustomJS callback to update one Bokeh model property whenever another changes value.

Parameters
  • attr (str) – The name of a Bokeh property on this model

  • other (Model) – A Bokeh model to link to self.attr

  • other_attr (str) – The property on other to link together

  • attr_selector (Union[int, str]) – The index to link an item in a subscriptable attr

Added in version 1.1

Raises

ValueError

Examples

This code with js_link:

select.js_link('value', plot, 'sizing_mode')

is equivalent to the following:

from bokeh.models import CustomJS
select.js_on_change('value',
    CustomJS(args=dict(other=plot),
             code="other.sizing_mode = this.value"
    )
)

Additionally, to use attr_selector to attach the left side of a range slider to a plot’s x_range:

range_slider.js_link('value', plot.x_range, 'start', attr_selector=0)

which is equivalent to:

from bokeh.models import CustomJS
range_slider.js_on_change('value',
    CustomJS(args=dict(other=plot.x_range),
             code="other.start = this.value[0]"
    )
)
js_on_change(event: str, *callbacks: JSEventCallback) None

Attach a CustomJS callback to an arbitrary BokehJS model event.

On the BokehJS side, change events for model properties have the form "change:property_name". As a convenience, if the event name passed to this method is also the name of a property on the model, then it will be prefixed with "change:" automatically:

# these two are equivalent
source.js_on_change('data', callback)
source.js_on_change('change:data', callback)

However, there are other kinds of events that can be useful to respond to, in addition to property change events. For example to run a callback whenever data is streamed to a ColumnDataSource, use the "stream" event on the source:

source.js_on_change('streaming', callback)
classmethod lookup(name: str, *, raises: bool = True) Optional[bokeh.core.property.descriptors.PropertyDescriptor[Any]]

Find the PropertyDescriptor for a Bokeh property on a class, given the property name.

Parameters
  • name (str) – name of the property to search for

  • raises (bool) – whether to raise or return None if missing

Returns

descriptor for property named name

Return type

PropertyDescriptor

on_change(attr: str, *callbacks: PropertyCallback) None

Add a callback on this object to trigger when attr changes.

Parameters
  • attr (str) – an attribute name on this object

  • *callbacks (callable) – callback functions to register

Returns

None

Example:

widget.on_change('value', callback1, callback2, ..., callback_n)
on_event(event: Union[str, Type[bokeh.events.Event]], *callbacks: Union[Callable[[bokeh.events.Event], None], Callable[[], None]]) None

Run callbacks when the specified event occurs on this Model

Not all Events are supported for all Models. See specific Events in bokeh.events for more information on which Models are able to trigger them.

patch(patches: Patches, setter: Setter | None = None) None

Efficiently update data source columns at specific locations

If it is only necessary to update a small subset of data in a ColumnDataSource, this method can be used to efficiently update only the subset, instead of requiring the entire data set to be sent.

This method should be passed a dictionary that maps column names to lists of tuples that describe a patch change to apply. To replace individual items in columns entirely, the tuples should be of the form:

(index, new_value)  # replace a single column value

# or

(slice, new_values) # replace several column values

Values at an index or slice will be replaced with the corresponding new values.

In the case of columns whose values are other arrays or lists, (e.g. image or patches glyphs), it is also possible to patch “subregions”. In this case the first item of the tuple should be a whose first element is the index of the array item in the CDS patch, and whose subsequent elements are integer indices or slices into the array item:

# replace the entire 10th column of the 2nd array:

  +----------------- index of item in column data source
  |
  |       +--------- row subindex into array item
  |       |
  |       |       +- column subindex into array item
  V       V       V
([2, slice(None), 10], new_values)

Imagining a list of 2d NumPy arrays, the patch above is roughly equivalent to:

data = [arr1, arr2, ...]  # list of 2d arrays

data[2][:, 10] = new_data

There are some limitations to the kinds of slices and data that can be accepted.

  • Negative start, stop, or step values for slices will result in a ValueError.

  • In a slice, start > stop will result in a ValueError

  • When patching 1d or 2d subitems, the subitems must be NumPy arrays.

  • New values must be supplied as a flattened one-dimensional array of the appropriate size.

Parameters

patches (dict[str, list[tuple]]) – lists of patches for each column

Returns

None

Raises

ValueError

Example:

The following example shows how to patch entire column elements. In this case,

source = ColumnDataSource(data=dict(foo=[10, 20, 30], bar=[100, 200, 300]))

patches = {
    'foo' : [ (slice(2), [11, 12]) ],
    'bar' : [ (0, 101), (2, 301) ],
}

source.patch(patches)

After this operation, the value of the source.data will be:

dict(foo=[11, 12, 30], bar=[101, 200, 301])

For a more comprehensive complete example, see examples/howto/patch_app.py.

classmethod properties(*, _with_props: bool = False) Union[Set[str], Dict[str, Property[Any]]]

Collect the names of properties on this class.

Warning

In a future version of Bokeh, this method will return a dictionary mapping property names to property objects. To future-proof this current usage of this method, wrap the return value in list.

Returns

property names

classmethod properties_with_refs() Dict[str, Property[Any]]

Collect the names of all properties on this class that also have references.

This method always traverses the class hierarchy and includes properties defined on any parent classes.

Returns

names of properties that have references

Return type

set[str]

properties_with_values(*, include_defaults: bool = True, include_undefined: bool = False) Dict[str, Any]

Collect a dict mapping property names to their values.

This method always traverses the class hierarchy and includes properties defined on any parent classes.

Non-serializable properties are skipped and property values are in “serialized” format which may be slightly different from the values you would normally read from the properties; the intent of this method is to return the information needed to losslessly reconstitute the object instance.

Parameters

include_defaults (bool, optional) – Whether to include properties that haven’t been explicitly set since the object was created. (default: True)

Returns

mapping from property names to their values

Return type

dict

query_properties_with_values(query: Callable[[bokeh.core.property.descriptors.PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) Dict[str, Any]

Query the properties values of HasProps instances with a predicate.

Parameters
  • query (callable) – A callable that accepts property descriptors and returns True or False

  • include_defaults (bool, optional) – Whether to include properties that have not been explicitly set by a user (default: True)

Returns

mapping of property names and values for matching properties

Return type

dict

references() Set[bokeh.model.model.Model]

Returns all Models that this object has references to.

remove(name: str) None

Remove a column of data.

Parameters

name (str) – name of the column to remove

Returns

None

Note

If the column name does not exist, a warning is issued.

remove_on_change(attr: str, *callbacks: Callable[[str, Any, Any], None]) None

Remove a callback from this object

select(selector: SelectorType) Iterable[Model]

Query this object and all of its references for objects that match the given selector.

Parameters

selector (JSON-like) –

Returns

seq[Model]

select_one(selector: SelectorType) Model | None

Query this object and all of its references for objects that match the given selector. Raises an error if more than one object is found. Returns single matching object, or None if nothing is found :param selector: :type selector: JSON-like

Returns

Model

set_from_json(name: str, json: JSON, *, models: Dict[ID, HasProps] | None = None, setter: Setter | None = None) None

Set a property value on this object from JSON.

Parameters
  • name – (str) : name of the attribute to set

  • json – (JSON-value) : value to set to the attribute to

  • models (dict or None, optional) –

    Mapping of model ids to models (default: None)

    This is needed in cases where the attributes to update also have values that have references.

  • setter (ClientSession or ServerSession or None, optional) –

    This is used to prevent “boomerang” updates to Bokeh apps.

    In the context of a Bokeh server application, incoming updates to properties will be annotated with the session that is doing the updating. This value is propagated through any subsequent change notifications that the update triggers. The session can compare the event setter to itself, and suppress any updates that originate from itself.

Returns

None

set_select(selector: Type[Model] | SelectorType, updates: Dict[str, Unknown]) None

Update objects that match a given selector with the specified attribute/value updates.

Parameters
  • selector (JSON-like) –

  • updates (dict) –

Returns

None

stream(new_data: DataDict, rollover: int | None = None) None

Efficiently update data source columns with new append-only data.

In cases where it is necessary to update data columns in, this method can efficiently send only the new data, instead of requiring the entire data set to be re-sent.

Parameters
  • new_data (dict[str, seq]) –

    a mapping of column names to sequences of new data to append to each column.

    All columns of the data source must be present in new_data, with identical-length append data.

  • rollover (int, optional) – A maximum column size, above which data from the start of the column begins to be discarded. If None, then columns will continue to grow unbounded (default: None)

Returns

None

Raises

ValueError

Example:

source = ColumnDataSource(data=dict(foo=[], bar=[]))

# has new, identical-length updates for all columns in source
new_data = {
    'foo' : [10, 20],
    'bar' : [100, 200],
}

source.stream(new_data)
themed_values() Optional[Dict[str, Any]]

Get any theme-provided overrides.

Results are returned as a dict from property name to value, or None if no theme overrides any values for this instance.

Returns

dict or None

to_df() pandas.core.frame.DataFrame

Convert this data source to pandas DataFrame.

Returns

DataFrame

to_json(include_defaults: bool) JSON

Returns a dictionary of the attributes of this object, containing only “JSON types” (string, number, boolean, none, dict, list).

References to other objects are serialized as “refs” (just the object ID and type info), so the deserializer will need to separately have the full attributes of those other objects.

There’s no corresponding from_json() because to deserialize an object is normally done in the context of a Document (since the Document can resolve references).

For most purposes it’s best to serialize and deserialize entire documents.

Parameters

include_defaults (bool) – whether to include attributes that haven’t been changed from the default

to_json_string(include_defaults: bool) str

Returns a JSON string encoding the attributes of this object.

References to other objects are serialized as references (just the object ID and type info), so the deserializer will need to separately have the full attributes of those other objects.

There’s no corresponding from_json_string() because to deserialize an object is normally done in the context of a Document (since the Document can resolve references).

For most purposes it’s best to serialize and deserialize entire documents.

Parameters

include_defaults (bool) – whether to include attributes that haven’t been changed from the default

trigger(attr: str, old: Unknown, new: Unknown, hint: DocumentPatchedEvent | None = None, setter: Setter | None = None) None
unapply_theme() None

Remove any themed values and restore defaults.

Returns

None

update(**kwargs: Any) None

Updates the object’s properties from the given keyword arguments.

Returns

None

Examples

The following are equivalent:

from bokeh.models import Range1d

r = Range1d

# set properties individually:
r.start = 10
r.end = 20

# update properties together:
r.update(start=10, end=20)
update_from_json(json_attributes: Dict[str, JSON], *, models: Mapping[ID, HasProps] | None = None, setter: Setter | None = None) None

Updates the object’s properties from a JSON attributes dictionary.

Parameters
  • json_attributes – (JSON-dict) : attributes and values to update

  • models (dict or None, optional) –

    Mapping of model ids to models (default: None)

    This is needed in cases where the attributes to update also have values that have references.

  • setter (ClientSession or ServerSession or None, optional) –

    This is used to prevent “boomerang” updates to Bokeh apps.

    In the context of a Bokeh server application, incoming updates to properties will be annotated with the session that is doing the updating. This value is propagated through any subsequent change notifications that the update triggers. The session can compare the event setter to itself, and suppress any updates that originate from itself.

Returns

None

property column_names: List[str]

A list of the column names in this data source.

property document: Document | None

The Document this model is attached to (can be None)

property struct: bokeh.core.types.ReferenceJson

A Bokeh protocol “structure” of this model, i.e. a dict of the form:

{
    'type' : << view model name >>
    'id'   : << unique model id >>
}

Additionally there may be a subtype field if this model is a subtype.

WebSource

alias of bokeh.models.sources.WebDataSource