数据源

class AjaxDataSource(*args: Any, id: ID | None = None, **kwargs: Any)

基类: WebDataSource

一种可以通过向 REST 端点发出 Ajax 调用来填充列的数据源。

AjaxDataSource 在您想要创建一个独立的文档（即不受 Bokeh 服务器支持）但仍然可以使用现有的 REST API 进行动态更新时特别有用。

REST API 的响应应与标准 ColumnDataSource 的 .data 属性匹配，即一个 JSON 字典，它将名称映射到值的数组。

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

或者，如果 REST API 返回不同的格式，则可以通过此数据源的 adapter 属性提供 CustomJS 回调来将 REST 响应转换为 Bokeh 格式。

可以通过直接指定 data 属性来设置初始数据。当与 FactorRange 结合使用时，即使 data` 中的列为空，这也是必要的。

可以在 examples/basic/data/ajax_source.py 中看到完整的示例。

JSON 原型

{
  "adapter": null, 
  "content_type": "application/json", 
  "data": {
    "type": "map"
  }, 
  "data_url": {
    "name": "unset", 
    "type": "symbol"
  }, 
  "default_values": {
    "type": "map"
  }, 
  "http_headers": {
    "type": "map"
  }, 
  "id": "p62692", 
  "if_modified": false, 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "max_size": null, 
  "method": "POST", 
  "mode": "replace", 
  "name": null, 
  "polling_interval": null, 
  "selected": {
    "attributes": {
      "indices": [], 
      "line_indices": []
    }, 
    "id": "p62693", 
    "name": "Selection", 
    "type": "object"
  }, 
  "selection_policy": {
    "id": "p62694", 
    "name": "UnionRenderers", 
    "type": "object"
  }, 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": []
}

adapter = None

类型:

Nullable(Instance(CustomJS))

一个 JavaScript 回调，用于将原始 JSON 响应适配到 Bokeh ColumnDataSource 格式。

如果提供，则此回调会在接收 JSON 数据后立即执行，但在将数据追加到或替换数据源中的数据之前执行。 CustomJS 回调将接收 AjaxDataSource 作为 cb_obj，并将接收原始 JSON 响应作为 cb_data.response。回调代码应返回一个适合 Bokeh ColumnDataSource 的 data 对象（即字符串列名称到数据数组的映射）。

content_type = 'application/json'

类型:

字符串

设置 Ajax 请求的“contentType”参数。

data = {}

类型:

列数据

列名称到数据序列的映射。列可以是，例如，Python 列表或元组、NumPy 数组等。

还可以从 Pandas DataFrame 或 GroupBy 对象设置 .data 属性。在这些情况下，行为与将对象传递给 ColumnDataSource 初始化程序相同。

data_url = Undefined

类型:

Required(String)

要从中获取数据的 URL。

default_values = {}

类型:

Dict(String, Any)

定义每列的默认值。

当插入数据源中的行时使用，例如通过编辑工具，当未明确提供给定列的值时。如果缺少默认值，工具将默认使用其自己的配置，或者尝试让数据源推断一个合理的默认值。

http_headers = {}

类型:

Dict(String, String)

指定要为 Ajax 请求设置的 HTTP 标头。

示例

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

if_modified = False

类型:

布尔值

是否在 Ajax 请求中包含 If-Modified-Since 标头以发送到服务器。如果服务器支持此标头，则仅返回自上次请求以来的新数据。

max_size = None

类型:

Nullable(Int)

数据列的最大大小。如果新的获取会导致列大于 max_size，则会删除较早的数据以腾出空间。

method = 'POST'

类型:

Enum(Enumeration(POST, GET))

指定用于 Ajax 请求的 HTTP 方法（GET 或 POST）。

mode = 'replace'

类型:

Enum(Enumeration(replace, append))

是将新数据追加到现有数据（最多 max_size），还是完全替换现有数据。

name = None

类型:

Nullable(String)

此模型的任意用户提供的名称。

在查询文档以检索特定 Bokeh 模型时，此名称可能很有用。

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

注意

不保证任何提供的名称的唯一性或其他条件，Bokeh 也不会出于任何原因直接使用该名称。

polling_interval = None

类型:

Nullable(Int)

更新数据源的轮询间隔（以毫秒为单位）。

selected = Selection(id='p62734', ...)

类型:

只读

一个 Selection 实例，指示此 DataSource 上选定的索引。这是一个只读属性。您只能更改此对象的属性以更改选择（例如，selected.indices）。

selection_policy = UnionRenderers(id='p62738', ...)

类型:

Instance(SelectionPolicy)

一个 SelectionPolicy 实例，用于确定如何设置选择。

syncable = True

类型:

布尔值

指示此模型在 Web 浏览器中更新时是否应同步回 Bokeh 服务器。在处理经常更新的对象（我们不需要其更新的值）时，设置为 False 可能有助于减少网络流量。

注意

将此属性设置为 False 将阻止此对象上的任何 on_change() 回调触发。但是，任何 JS 端回调仍然有效。

tags = []

类型:

列表

一个可选的任意用户提供的值的列表，用于附加到此模型。

在查询文档以检索特定 Bokeh 模型时，此数据可能很有用。

>>> 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', ...)]

或者，这只是一个方便的方法，可以将任何必要的元数据附加到模型，这些元数据可以通过 CustomJS 回调等访问。

注意

不保证任何提供的标签的唯一性或其他条件，Bokeh 也不会出于任何原因直接使用这些标签。

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

将新的一列数据追加到数据源。

参数：

• data (seq) – 要添加的新数据

• name (str, optional) – 要使用的列名。如果未提供，则生成格式为“Series ####”的名称

返回值：

使用的列名

返回类型：

str

apply_theme(property_values: dict[str, Any]) → None

应用一组主题值，这些值将用于代替默认值，但不会覆盖应用程序设置的值。

传入的字典可以原样保留并与其他实例共享以节省内存（因此调用者和 HasProps 实例都不应修改它）。

参数：

property_values (dict) – 要代替默认值使用的主题值

返回值：

无

classmethod clear_extensions() → None

清除任何当前定义的自定义扩展。

序列化调用将导致任何当前定义的自定义扩展包含在生成的文档中，无论是否使用它们。此方法可用于清除所有现有的自定义扩展定义。

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

这会创建原始模型的浅克隆，即任何可变容器或子模型都不会被复制。允许在克隆时覆盖特定属性。

classmethod dataspecs() → dict[str, DataSpec]

收集此类上所有 DataSpec 属性的名称。

此方法始终遍历类层次结构，并包含在任何父类上定义的属性。

返回值：

DataSpec 属性的名称

返回类型：

set[str]

类方法 descriptors() → list[PropertyDescriptor[Any]]

定义顺序的属性描述符列表。

destroy() → None

清理对文档和属性的引用。

equals(other: HasProps) → bool

模型的结构相等性。

参数：

other (HasProps) – 要比较的另一个实例

返回值：

如果属性在结构上相等，则为 True，否则为 False

类方法 from_df(data: pd.DataFrame) → DataDict

创建一个包含 Pandas DataFrame 中列的 dict，适用于创建 ColumnDataSource。

参数：

data (DataFrame) – 要转换的数据

返回值：

dict[str, np.array]

类方法 from_groupby(data: pd.core.groupby.GroupBy) → DataDict

创建一个包含 Pandas GroupBy 中列的 dict，适用于创建 ColumnDataSource。

生成的数据是针对组运行 describe 的结果。

参数：

data (Groupby) – 要转换的数据

返回值：

dict[str, np.array]

js_link(attr: str, other: Model, other_attr: str, attr_selector: int | str | None = None) → None

使用 JavaScript 链接两个 Bokeh 模型属性。

这是一种简化方法，用于简化添加 CustomJS 回调，以便在另一个属性值发生更改时更新一个 Bokeh 模型属性。

参数：

• attr (str) – 此模型上 Bokeh 属性的名称

• other (Model) – 要链接到 self.attr 的 Bokeh 模型

• other_attr (str) – other 上要链接在一起的属性

• attr_selector (int | str) – 链接可订阅 attr 中项目的索引

版本 1.1 中添加。

引发:

ValueError –

示例

使用 js_link 的此代码

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

等效于以下内容

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

此外，要使用 attr_selector 将范围滑块的左侧连接到绘图的 x_range

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

等效于

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: JSChangeCallback) → None

将 CustomJS 回调附加到任意 BokehJS 模型事件。

在 BokehJS 端，模型属性的更改事件采用 "change:property_name" 的形式。为了方便起见，如果传递给此方法的事件名称也是模型上某个属性的名称，则会自动在其前面加上 "change:"

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

但是，除了属性更改事件之外，还有其他一些有用的事件可以响应。例如，要在一个回调函数中运行数据流式传输到 ColumnDataSource 的事件，请在源上使用 "stream" 事件

source.js_on_change('streaming', callback)

类方法 lookup(name: str, *, raises: bool = True) → PropertyDescriptor[Any] | None

在类中查找给定属性名称的 Bokeh 属性的 PropertyDescriptor。

参数：

• name (str) – 要搜索的属性的名称

• raises (bool) – 如果缺少属性，是否引发异常或返回 None

返回值：

名为 name 的属性的描述符

返回类型：

PropertyDescriptor

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

在此对象上添加一个回调，以便在 attr 发生更改时触发。

参数：

• attr (str) – 此对象上的属性名称

• *callbacks (callable) – 要注册的回调函数

返回值：

无

示例

widget.on_change('value', callback1, callback2, ..., callback_n)

on_event(event: str | type[Event], *callbacks: Callable[[Event], None] | Callable[[], None]) → None

当此模型上发生指定事件时运行回调函数

并非所有模型都支持所有事件。有关哪些模型能够触发事件的更多信息，请参阅bokeh.events中的特定事件。

classmethod parameters() → list[Parameter]

生成适合从 Glyph 派生的函数的 Python Parameter 值。

返回值：

list(Parameter)

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

有效更新特定位置的数据源列

如果只需要更新ColumnDataSource中的一小部分数据，则可以使用此方法有效地仅更新该子集，而不是需要发送整个数据集。

此方法应传递一个字典，该字典将列名映射到描述要应用的补丁更改的元组列表。要完全替换列中的单个项目，元组应采用以下形式

(index, new_value)  # replace a single column value

# or

(slice, new_values) # replace several column values

索引或切片处的值将替换为相应的新的值。

对于其值为其他数组或列表的列（例如图像或补丁 Glyph），也可以修补“子区域”。在这种情况下，元组的第一个项目应为，其第一个元素是 CDS 补丁中数组项目的索引，其后续元素是数组项目中的整数索引或切片

# 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)

假设一个二维 NumPy 数组列表，上面的补丁大致等价于

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

data[2][:, 10] = new_data

可以接受的切片和数据类型有一些限制。

• 切片的负start、stop或step值将导致ValueError。

• 在切片中，start > stop将导致ValueError

• 在修补一维或二维子项时，子项必须是 NumPy 数组。

• 新值必须作为适当大小的**扁平化一维数组**提供。

参数：

patches (dict[str, list[tuple]]) – 每列的补丁列表

返回值：

无

引发:

ValueError –

示例

以下示例显示了如何修补整个列元素。在这种情况下，

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)

此操作后，source.data的值将为

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

有关更全面的示例，请参阅examples/server/app/patch_app.py。

classmethod properties(*, _with_props: bool = False) → set[str] | dict[str, Property[Any]]

收集此类上属性的名称。

警告

在 Bokeh 的未来版本中，此方法将返回一个字典，该字典将属性名称映射到属性对象。为了使此方法的当前用法面向未来，请将返回值包装在list中。

返回值：

属性名称

classmethod properties_with_refs() → dict[str, Property[Any]]

收集此类上所有也具有引用的属性的名称。

此方法始终遍历类层次结构，并包含在任何父类上定义的属性。

返回值：

具有引用的属性的名称

返回类型：

set[str]

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

收集一个将属性名称映射到其值的字典。

此方法始终遍历类层次结构，并包含在任何父类上定义的属性。

不可序列化的属性将被跳过，并且属性值将采用“序列化”格式，这可能与您通常从属性中读取的值略有不同；此方法的目的是返回无损重建对象实例所需的信息。

参数：

include_defaults (bool, 可选) – 是否包含自对象创建以来尚未显式设置的属性。（默认值：True）

返回值：

属性名称与其值的映射

返回类型：

字典

query_properties_with_values(query: Callable[[PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

使用谓词查询HasProps实例的属性值。

参数：

• query (可调用对象) – 一个可调用对象，它接受属性描述符并返回 True 或 False

• include_defaults (bool, 可选) – 是否包含用户未显式设置的属性（默认值：True）

返回值：

匹配属性的属性名称和值的映射

返回类型：

字典

references() → set[Model]

返回此对象引用的所有Models。

remove(name: str) → None

删除一列数据。

参数：

name (str) – 要删除的列的名称

返回值：

无

注意

如果列名不存在，则会发出警告。

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

从此对象中删除回调函数

select(selector: SelectorType) → Iterable[Model]

查询此对象及其所有引用，以查找与给定选择器匹配的对象。

参数：

selector (类似 JSON)

返回值：

seq[Model]

select_one(selector: SelectorType) → Model | None

查询此对象及其所有引用，以查找与给定选择器匹配的对象。如果找到多个对象，则引发错误。返回单个匹配对象，如果未找到任何对象，则返回 None :param selector: :type selector: 类似 JSON

返回值：

模型

set_from_json(name: str, value: Any, *, setter: Setter | None = None) → None

从此对象中的 JSON 设置属性值。

参数：

• name (str) – 要设置的属性的名称

• value (JSON 值) – 要设置为属性的值

• setter (ClientSession 或 ServerSession 或 None, 可选) –

  这用于防止对 Bokeh 应用程序进行“回旋镖”更新。

  在 Bokeh 服务器应用程序的上下文中，属性的传入更新将用进行更新的会话进行注释。此值会通过更新触发的任何后续更改通知进行传播。会话可以将事件设置器与自身进行比较，并抑制任何源自自身的更新。

返回值：

无

set_select(selector: type[Model] | SelectorType, updates: dict[str, Any]) → None

使用指定的属性/值更新来更新与给定选择器匹配的对象。

参数：

• selector (类似 JSON)

• updates (dict)

返回值：

无

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

有效地使用新的追加数据更新数据源列。

在需要更新数据列的情况下，此方法可以有效地仅发送新数据，而不是要求重新发送整个数据集。

参数：

• new_data (dict[str, seq]) –

  列名到要追加到每个列的新数据的序列的映射。

  数据源的所有列都必须出现在 new_data 中，并具有相同长度的追加数据。

• rollover (int, optional) – 最大列大小，超过此大小，列开头的数据将开始被丢弃。如果为 None，则列将无限增长（默认值：None）

返回值：

无

引发:

ValueError –

示例

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() → dict[str, Any] | None

获取任何主题提供的覆盖。

结果作为从属性名称到值的字典返回，如果主题未覆盖此实例的任何值，则返回 None。

返回值：

dict 或 None

to_df() → pd.DataFrame

将此数据源转换为 pandas DataFrame。

返回值：

DataFrame

to_serializable(serializer: Serializer) → ObjectRefRep

将此对象转换为可序列化表示形式。

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

unapply_theme() → None

移除任何主题值并恢复默认值。

返回值：

无

update(**kwargs: Any) → None

根据给定的关键字参数更新对象的属性。

返回值：

无

示例

以下是等效的

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)

property column_names: list[str]

此数据源中列名称的列表。

property document: Document | None

此模型附加到的 Document（可以为 None）

class CDSView(*args: Any, id: ID | None = None, **kwargs: Any)

基类: Model

表示行级子集的 ColumnDataSource 的视图。

JSON 原型

{
  "filter": {
    "id": "p62746", 
    "name": "AllIndices", 
    "type": "object"
  }, 
  "id": "p62745", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "name": null, 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": []
}

filter = AllIndices(id='p62749', ...)

类型:

Instance(Filter)

定义此视图应用到的数据源中要使用的索引子集。

默认情况下，使用所有索引（AllIndices 过滤器）。这可以通过使用专门的过滤器（如 IndexFilter、BooleanFilter 等）来更改。可以使用集合操作组合过滤器以创建非平凡的数据掩码。这可以通过直接使用模型（如 InversionFilter、UnionFilter 等）或在过滤器上使用集合运算符来实现，例如：

# filters everything but indexes 10 and 11
cds_view.filter &= ~IndexFilter(indices=[10, 11])

name = None

类型:

Nullable(String)

此模型的任意用户提供的名称。

在查询文档以检索特定 Bokeh 模型时，此名称可能很有用。

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

注意

不保证任何提供的名称的唯一性或其他条件，Bokeh 也不会出于任何原因直接使用该名称。

syncable = True

类型:

布尔值

指示此模型在 Web 浏览器中更新时是否应同步回 Bokeh 服务器。在处理经常更新的对象（我们不需要其更新的值）时，设置为 False 可能有助于减少网络流量。

注意

将此属性设置为 False 将阻止此对象上的任何 on_change() 回调触发。但是，任何 JS 端回调仍然有效。

tags = []

类型:

列表

一个可选的任意用户提供的值的列表，用于附加到此模型。

在查询文档以检索特定 Bokeh 模型时，此数据可能很有用。

>>> 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', ...)]

或者，这只是一个方便的方法，可以将任何必要的元数据附加到模型，这些元数据可以通过 CustomJS 回调等访问。

注意

不保证任何提供的标签的唯一性或其他条件，Bokeh 也不会出于任何原因直接使用这些标签。

apply_theme(property_values: dict[str, Any]) → None

应用一组主题值，这些值将用于代替默认值，但不会覆盖应用程序设置的值。

传入的字典可以原样保留并与其他实例共享以节省内存（因此调用者和 HasProps 实例都不应修改它）。

参数：

property_values (dict) – 要代替默认值使用的主题值

返回值：

无

classmethod clear_extensions() → None

清除任何当前定义的自定义扩展。

序列化调用将导致任何当前定义的自定义扩展包含在生成的文档中，无论是否使用它们。此方法可用于清除所有现有的自定义扩展定义。

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

这会创建原始模型的浅克隆，即任何可变容器或子模型都不会被复制。允许在克隆时覆盖特定属性。

classmethod dataspecs() → dict[str, DataSpec]

收集此类上所有 DataSpec 属性的名称。

此方法始终遍历类层次结构，并包含在任何父类上定义的属性。

返回值：

DataSpec 属性的名称

返回类型：

set[str]

classmethod descriptors() → list[PropertyDescriptor[Any]]

定义顺序的属性描述符列表。

destroy() → None

清理对文档和属性的引用。

equals(other: HasProps) → bool

模型的结构相等性。

参数：

other (HasProps) – 要比较的另一个实例

返回值：

如果属性在结构上相等，则为 True，否则为 False

js_link(attr: str, other: Model, other_attr: str, attr_selector: int | str | None = None) → None

使用 JavaScript 链接两个 Bokeh 模型属性。

这是一种简化方法，用于简化添加 CustomJS 回调，以便在另一个属性值发生更改时更新一个 Bokeh 模型属性。

参数：

• attr (str) – 此模型上 Bokeh 属性的名称

• other (Model) – 要链接到 self.attr 的 Bokeh 模型

• other_attr (str) – other 上要链接在一起的属性

• attr_selector (int | str) – 链接可订阅 attr 中项目的索引

版本 1.1 中添加。

引发:

ValueError –

示例

使用 js_link 的此代码

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

等效于以下内容

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

此外，要使用 attr_selector 将范围滑块的左侧连接到绘图的 x_range

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

等效于

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: JSChangeCallback) → None

将 CustomJS 回调附加到任意 BokehJS 模型事件。

在 BokehJS 端，模型属性的更改事件采用 "change:property_name" 的形式。为了方便起见，如果传递给此方法的事件名称也是模型上某个属性的名称，则会自动在其前面加上 "change:"

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

但是，除了属性更改事件之外，还有其他一些有用的事件可以响应。例如，要在一个回调函数中运行数据流式传输到 ColumnDataSource 的事件，请在源上使用 "stream" 事件

source.js_on_change('streaming', callback)

classmethod lookup(name: str, *, raises: bool = True) → PropertyDescriptor[Any] | None

在类中查找给定属性名称的 Bokeh 属性的 PropertyDescriptor。

参数：

• name (str) – 要搜索的属性的名称

• raises (bool) – 如果缺少属性，是否引发异常或返回 None

返回值：

名为 name 的属性的描述符

返回类型：

PropertyDescriptor

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

在此对象上添加一个回调，以便在 attr 发生更改时触发。

参数：

• attr (str) – 此对象上的属性名称

• *callbacks (callable) – 要注册的回调函数

返回值：

无

示例

widget.on_change('value', callback1, callback2, ..., callback_n)

on_event(event: str | type[Event], *callbacks: Callable[[Event], None] | Callable[[], None]) → None

当此模型上发生指定事件时运行回调函数

并非所有模型都支持所有事件。有关哪些模型能够触发事件的更多信息，请参阅bokeh.events中的特定事件。

classmethod parameters() → list[Parameter]

生成适合从 Glyph 派生的函数的 Python Parameter 值。

返回值：

list(Parameter)

classmethod properties(*, _with_props: bool = False) → set[str] | dict[str, Property[Any]]

收集此类上属性的名称。

警告

在 Bokeh 的未来版本中，此方法将返回一个字典，该字典将属性名称映射到属性对象。为了使此方法的当前用法面向未来，请将返回值包装在list中。

返回值：

属性名称

classmethod properties_with_refs() → dict[str, Property[Any]]

收集此类上所有也具有引用的属性的名称。

此方法始终遍历类层次结构，并包含在任何父类上定义的属性。

返回值：

具有引用的属性的名称

返回类型：

set[str]

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

收集一个将属性名称映射到其值的字典。

此方法始终遍历类层次结构，并包含在任何父类上定义的属性。

不可序列化的属性将被跳过，并且属性值将采用“序列化”格式，这可能与您通常从属性中读取的值略有不同；此方法的目的是返回无损重建对象实例所需的信息。

参数：

include_defaults (bool, 可选) – 是否包含自对象创建以来尚未显式设置的属性。（默认值：True）

返回值：

属性名称与其值的映射

返回类型：

字典

query_properties_with_values(query: Callable[[PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

使用谓词查询HasProps实例的属性值。

参数：

• query (可调用对象) – 一个可调用对象，它接受属性描述符并返回 True 或 False

• include_defaults (bool, 可选) – 是否包含用户未显式设置的属性（默认值：True）

返回值：

匹配属性的属性名称和值的映射

返回类型：

字典

references() → set[Model]

返回此对象引用的所有Models。

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

从此对象中删除回调函数

select(selector: SelectorType) → Iterable[Model]

查询此对象及其所有引用，以查找与给定选择器匹配的对象。

参数：

selector (类似 JSON)

返回值：

seq[Model]

select_one(selector: SelectorType) → Model | None

查询此对象及其所有引用，以查找与给定选择器匹配的对象。如果找到多个对象，则引发错误。返回单个匹配对象，如果未找到任何对象，则返回 None :param selector: :type selector: 类似 JSON

返回值：

模型

set_from_json(name: str, value: Any, *, setter: Setter | None = None) → None

从此对象中的 JSON 设置属性值。

参数：

• name (str) – 要设置的属性的名称

• value (JSON 值) – 要设置为属性的值

• setter (ClientSession 或 ServerSession 或 None, 可选) –

  这用于防止对 Bokeh 应用程序进行“回旋镖”更新。

  在 Bokeh 服务器应用程序的上下文中，属性的传入更新将用进行更新的会话进行注释。此值会通过更新触发的任何后续更改通知进行传播。会话可以将事件设置器与自身进行比较，并抑制任何源自自身的更新。

返回值：

无

set_select(selector: type[Model] | SelectorType, updates: dict[str, Any]) → None

使用指定的属性/值更新来更新与给定选择器匹配的对象。

参数：

• selector (类似 JSON)

• updates (dict)

返回值：

无

themed_values() → dict[str, Any] | None

获取任何主题提供的覆盖。

结果作为从属性名称到值的字典返回，如果主题未覆盖此实例的任何值，则返回 None。

返回值：

dict 或 None

to_serializable(serializer: Serializer) → ObjectRefRep

将此对象转换为可序列化表示形式。

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

unapply_theme() → None

移除任何主题值并恢复默认值。

返回值：

无

update(**kwargs: Any) → None

根据给定的关键字参数更新对象的属性。

返回值：

无

示例

以下是等效的

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)

property document: Document | None

此模型附加到的 Document（可以为 None）

class ColumnDataSource(*args: Any, id: ID | None = None, **kwargs: Any)

基类: ColumnarDataSource

将列名称映射到序列或数组。

ColumnDataSource 是 Bokeh 的一个基本数据结构。大多数绘图、数据表等都将由 ColumnDataSource 驱动。

如果 ColumnDataSource 初始化器被调用，并且带有一个参数，该参数可以是以下任何一种：

• 一个 Python dict，它将字符串名称映射到值序列，例如列表、数组等。

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

注意

ColumnDataSource 仅创建 data 的浅拷贝。如果从另一个您想要保持独立的 ColumnDataSource.data 对象进行初始化，请使用例如 ColumnDataSource(copy.deepcopy(data))。

• 一个 Pandas DataFrame 对象

  source = ColumnDataSource(df)
  

  在这种情况下，CDS 将包含与 DataFrame 的列相对应的列。如果 DataFrame 的列具有多个级别，则将使用下划线将其展平（例如 level_0_col_level_1_col）。如果 DataFrame 的索引是 MultiIndex，则将其展平为元组的 Index，然后使用 reset_index 重置。如果索引已命名，则结果将是具有相同名称的列；如果它是命名的 MultiIndex，则结果将是 level_0_name_level_1_name。如果 Index 没有名称或 MultiIndex 名称无法展平/确定，则 reset_index 函数将索引列命名为 index，或者如果名称 index 不可用，则命名为 level_0。

• Pandas GroupBy 对象

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

  在这种情况下，CDS 将包含与调用 group.describe() 的结果相对应的列。describe 方法为所有未分组的原始列生成统计度量的列，例如 mean 和 count。CDS 列通过将原始列名与计算出的度量值连接起来形成。例如，如果 DataFrame 具有列 'year' 和 'mpg'。然后将 df.groupby('year') 传递给 CDS 将生成诸如 'mpg_mean' 之类的列。

  如果 GroupBy.describe 结果具有命名的索引列，则 CDS 也将具有一个与此名称相同的列。但是，如果索引名称（或 MultiIndex 的任何子名称）为 None，则 CDS 将为索引生成一个名为 index 的通用列。

  请注意，这种适应 GroupBy 对象的功能可能仅适用于 Pandas >=0.20.0。

注意

有一个隐含的假设，即给定 ColumnDataSource 中的所有列在任何时候都具有相同的长度。因此，通常最好“一次性”更新数据源的 .data 属性。

JSON 原型

{
  "data": {
    "type": "map"
  }, 
  "default_values": {
    "type": "map"
  }, 
  "id": "p62756", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "name": null, 
  "selected": {
    "attributes": {
      "indices": [], 
      "line_indices": []
    }, 
    "id": "p62757", 
    "name": "Selection", 
    "type": "object"
  }, 
  "selection_policy": {
    "id": "p62758", 
    "name": "UnionRenderers", 
    "type": "object"
  }, 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": []
}

data = {}

类型:

列数据

列名称到数据序列的映射。列可以是，例如，Python 列表或元组、NumPy 数组等。

还可以从 Pandas DataFrame 或 GroupBy 对象设置 .data 属性。在这些情况下，行为与将对象传递给 ColumnDataSource 初始化程序相同。

default_values = {}

类型:

Dict(String, Any)

定义每列的默认值。

当插入数据源中的行时使用，例如通过编辑工具，当未明确提供给定列的值时。如果缺少默认值，工具将默认使用其自己的配置，或者尝试让数据源推断一个合理的默认值。

name = None

类型:

Nullable(String)

此模型的任意用户提供的名称。

在查询文档以检索特定 Bokeh 模型时，此名称可能很有用。

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

注意

不保证任何提供的名称的唯一性或其他条件，Bokeh 也不会出于任何原因直接使用该名称。

selected = Selection(id='p62771', ...)

类型:

只读

一个 Selection 实例，指示此 DataSource 上选定的索引。这是一个只读属性。您只能更改此对象的属性以更改选择（例如，selected.indices）。

selection_policy = UnionRenderers(id='p62775', ...)

类型:

Instance(SelectionPolicy)

一个 SelectionPolicy 实例，用于确定如何设置选择。

syncable = True

类型:

布尔值

指示此模型在 Web 浏览器中更新时是否应同步回 Bokeh 服务器。在处理经常更新的对象（我们不需要其更新的值）时，设置为 False 可能有助于减少网络流量。

注意

将此属性设置为 False 将阻止此对象上的任何 on_change() 回调触发。但是，任何 JS 端回调仍然有效。

tags = []

类型:

列表

一个可选的任意用户提供的值的列表，用于附加到此模型。

在查询文档以检索特定 Bokeh 模型时，此数据可能很有用。

>>> 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', ...)]

或者，这只是一个方便的方法，可以将任何必要的元数据附加到模型，这些元数据可以通过 CustomJS 回调等访问。

注意

不保证任何提供的标签的唯一性或其他条件，Bokeh 也不会出于任何原因直接使用这些标签。

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

__init__(**kwargs: Any) → None

如果使用单个参数（字典或 pandas.DataFrame）调用，则将其隐式视为“data”属性。

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

将新的一列数据追加到数据源。

参数：

• data (seq) – 要添加的新数据

• name (str, optional) – 要使用的列名。如果未提供，则生成格式为“Series ####”的名称

返回值：

使用的列名

返回类型：

str

apply_theme(property_values: dict[str, Any]) → None

应用一组主题值，这些值将用于代替默认值，但不会覆盖应用程序设置的值。

传入的字典可以原样保留并与其他实例共享以节省内存（因此调用者和 HasProps 实例都不应修改它）。

参数：

property_values (dict) – 要代替默认值使用的主题值

返回值：

无

classmethod clear_extensions() → None

清除任何当前定义的自定义扩展。

序列化调用将导致任何当前定义的自定义扩展包含在生成的文档中，无论是否使用它们。此方法可用于清除所有现有的自定义扩展定义。

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

这会创建原始模型的浅克隆，即任何可变容器或子模型都不会被复制。允许在克隆时覆盖特定属性。

classmethod dataspecs() → dict[str, DataSpec]

收集此类上所有 DataSpec 属性的名称。

此方法始终遍历类层次结构，并包含在任何父类上定义的属性。

返回值：

DataSpec 属性的名称

返回类型：

set[str]

classmethod descriptors() → list[PropertyDescriptor[Any]]

定义顺序的属性描述符列表。

destroy() → None

清理对文档和属性的引用。

equals(other: HasProps) → bool

模型的结构相等性。

参数：

other (HasProps) – 要比较的另一个实例

返回值：

如果属性在结构上相等，则为 True，否则为 False

类方法 from_df(data: pd.DataFrame) → DataDict

创建一个包含 Pandas DataFrame 中列的 dict，适用于创建 ColumnDataSource。

参数：

data (DataFrame) – 要转换的数据

返回值：

dict[str, np.array]

类方法 from_groupby(data: pd.core.groupby.GroupBy) → DataDict

创建一个包含 Pandas GroupBy 中列的 dict，适用于创建 ColumnDataSource。

生成的数据是针对组运行 describe 的结果。

参数：

data (Groupby) – 要转换的数据

返回值：

dict[str, np.array]

js_link(attr: str, other: Model, other_attr: str, attr_selector: int | str | None = None) → None

使用 JavaScript 链接两个 Bokeh 模型属性。

这是一种简化方法，用于简化添加 CustomJS 回调，以便在另一个属性值发生更改时更新一个 Bokeh 模型属性。

参数：

• attr (str) – 此模型上 Bokeh 属性的名称

• other (Model) – 要链接到 self.attr 的 Bokeh 模型

• other_attr (str) – other 上要链接在一起的属性

• attr_selector (int | str) – 链接可订阅 attr 中项目的索引

版本 1.1 中添加。

引发:

ValueError –

示例

使用 js_link 的此代码

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

等效于以下内容

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

此外，要使用 attr_selector 将范围滑块的左侧连接到绘图的 x_range

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

等效于

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: JSChangeCallback) → None

将 CustomJS 回调附加到任意 BokehJS 模型事件。

在 BokehJS 端，模型属性的更改事件采用 "change:property_name" 的形式。为了方便起见，如果传递给此方法的事件名称也是模型上某个属性的名称，则会自动在其前面加上 "change:"

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

但是，除了属性更改事件之外，还有其他一些有用的事件可以响应。例如，要在一个回调函数中运行数据流式传输到 ColumnDataSource 的事件，请在源上使用 "stream" 事件

source.js_on_change('streaming', callback)

类方法 lookup(name: str, *, raises: bool = True) → PropertyDescriptor[Any] | None

在类中查找给定属性名称的 Bokeh 属性的 PropertyDescriptor。

参数：

• name (str) – 要搜索的属性的名称

• raises (bool) – 如果缺少属性，是否引发异常或返回 None

返回值：

名为 name 的属性的描述符

返回类型：

PropertyDescriptor

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

在此对象上添加一个回调，以便在 attr 发生更改时触发。

参数：

• attr (str) – 此对象上的属性名称

• *callbacks (callable) – 要注册的回调函数

返回值：

无

示例

widget.on_change('value', callback1, callback2, ..., callback_n)

on_event(event: str | type[Event], *callbacks: Callable[[Event], None] | Callable[[], None]) → None

当此模型上发生指定事件时运行回调函数

并非所有模型都支持所有事件。有关哪些模型能够触发事件的更多信息，请参阅bokeh.events中的特定事件。

类方法 parameters() → list[Parameter]

生成适合从 Glyph 派生的函数的 Python Parameter 值。

返回值：

list(Parameter)

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

有效更新特定位置的数据源列

如果只需要更新ColumnDataSource中的一小部分数据，则可以使用此方法有效地仅更新该子集，而不是需要发送整个数据集。

此方法应传递一个字典，该字典将列名映射到描述要应用的补丁更改的元组列表。要完全替换列中的单个项目，元组应采用以下形式

(index, new_value)  # replace a single column value

# or

(slice, new_values) # replace several column values

索引或切片处的值将替换为相应的新的值。

对于其值为其他数组或列表的列（例如图像或补丁 Glyph），也可以修补“子区域”。在这种情况下，元组的第一个项目应为，其第一个元素是 CDS 补丁中数组项目的索引，其后续元素是数组项目中的整数索引或切片

# 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)

假设一个二维 NumPy 数组列表，上面的补丁大致等价于

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

data[2][:, 10] = new_data

可以接受的切片和数据类型有一些限制。

• 切片的负start、stop或step值将导致ValueError。

• 在切片中，start > stop将导致ValueError

• 在修补一维或二维子项时，子项必须是 NumPy 数组。

• 新值必须作为适当大小的**扁平化一维数组**提供。

参数：

patches (dict[str, list[tuple]]) – 每列的补丁列表

返回值：

无

引发:

ValueError –

示例

以下示例显示了如何修补整个列元素。在这种情况下，

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)

此操作后，source.data的值将为

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

有关更全面的示例，请参阅examples/server/app/patch_app.py。

classmethod properties(*, _with_props: bool = False) → set[str] | dict[str, Property[Any]]

收集此类上属性的名称。

警告

在 Bokeh 的未来版本中，此方法将返回一个字典，该字典将属性名称映射到属性对象。为了使此方法的当前用法面向未来，请将返回值包装在list中。

返回值：

属性名称

classmethod properties_with_refs() → dict[str, Property[Any]]

收集此类上所有也具有引用的属性的名称。

此方法始终遍历类层次结构，并包含在任何父类上定义的属性。

返回值：

具有引用的属性的名称

返回类型：

set[str]

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

收集一个将属性名称映射到其值的字典。

此方法始终遍历类层次结构，并包含在任何父类上定义的属性。

不可序列化的属性将被跳过，并且属性值将采用“序列化”格式，这可能与您通常从属性中读取的值略有不同；此方法的目的是返回无损重建对象实例所需的信息。

参数：

include_defaults (bool, 可选) – 是否包含自对象创建以来尚未显式设置的属性。（默认值：True）

返回值：

属性名称与其值的映射

返回类型：

字典

query_properties_with_values(query: Callable[[PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

使用谓词查询HasProps实例的属性值。

参数：

• query (可调用对象) – 一个可调用对象，它接受属性描述符并返回 True 或 False

• include_defaults (bool, 可选) – 是否包含用户未显式设置的属性（默认值：True）

返回值：

匹配属性的属性名称和值的映射

返回类型：

字典

references() → set[Model]

返回此对象引用的所有Models。

remove(name: str) → None

删除一列数据。

参数：

name (str) – 要删除的列的名称

返回值：

无

注意

如果列名不存在，则会发出警告。

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

从此对象中删除回调函数

select(selector: SelectorType) → Iterable[Model]

查询此对象及其所有引用，以查找与给定选择器匹配的对象。

参数：

selector (类似 JSON)

返回值：

seq[Model]

select_one(selector: SelectorType) → Model | None

查询此对象及其所有引用，以查找与给定选择器匹配的对象。如果找到多个对象，则引发错误。返回单个匹配对象，如果未找到任何对象，则返回 None :param selector: :type selector: 类似 JSON

返回值：

模型

set_from_json(name: str, value: Any, *, setter: Setter | None = None) → None

从此对象中的 JSON 设置属性值。

参数：

• name (str) – 要设置的属性的名称

• value (JSON 值) – 要设置为属性的值

• setter (ClientSession 或 ServerSession 或 None, 可选) –

  这用于防止对 Bokeh 应用程序进行“回旋镖”更新。

  在 Bokeh 服务器应用程序的上下文中，属性的传入更新将用进行更新的会话进行注释。此值会通过更新触发的任何后续更改通知进行传播。会话可以将事件设置器与自身进行比较，并抑制任何源自自身的更新。

返回值：

无

set_select(selector: type[Model] | SelectorType, updates: dict[str, Any]) → None

使用指定的属性/值更新来更新与给定选择器匹配的对象。

参数：

• selector (类似 JSON)

• updates (dict)

返回值：

无

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

有效地使用新的追加数据更新数据源列。

在需要更新数据列的情况下，此方法可以有效地仅发送新数据，而不是要求重新发送整个数据集。

参数：

• new_data (dict[str, seq]) –

  列名到要追加到每个列的新数据的序列的映射。

  数据源的所有列都必须出现在 new_data 中，并具有相同长度的追加数据。

• rollover (int, optional) – 最大列大小，超过此大小，列开头的数据将开始被丢弃。如果为 None，则列将无限增长（默认值：None）

返回值：

无

引发:

ValueError –

示例

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() → dict[str, Any] | None

获取任何主题提供的覆盖。

结果作为从属性名称到值的字典返回，如果主题未覆盖此实例的任何值，则返回 None。

返回值：

dict 或 None

to_df() → pd.DataFrame

将此数据源转换为 pandas DataFrame。

返回值：

DataFrame

to_serializable(serializer: Serializer) → ObjectRefRep

将此对象转换为可序列化表示形式。

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

unapply_theme() → None

移除任何主题值并恢复默认值。

返回值：

无

update(**kwargs: Any) → None

根据给定的关键字参数更新对象的属性。

返回值：

无

示例

以下是等效的

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)

property column_names: list[str]

此数据源中列名称的列表。

property document: Document | None

此模型附加到的 Document（可以为 None）

class ColumnarDataSource(*args: Any, id: ID | None = None, **kwargs: Any)

基类: DataSource

数据源类型的基类，可以映射到列格式。

注意

这是一个抽象基类，用于帮助组织 Bokeh 模型类型的层次结构。**它本身没有用处，不能实例化。**

JSON 原型

{
  "default_values": {
    "type": "map"
  }, 
  "id": "p62782", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "name": null, 
  "selected": {
    "attributes": {
      "indices": [], 
      "line_indices": []
    }, 
    "id": "p62783", 
    "name": "Selection", 
    "type": "object"
  }, 
  "selection_policy": {
    "id": "p62784", 
    "name": "UnionRenderers", 
    "type": "object"
  }, 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": []
}

default_values = {}

类型:

Dict(String, Any)

定义每列的默认值。

当插入数据源中的行时使用，例如通过编辑工具，当未明确提供给定列的值时。如果缺少默认值，工具将默认使用其自己的配置，或者尝试让数据源推断一个合理的默认值。

name = None

类型:

Nullable(String)

此模型的任意用户提供的名称。

在查询文档以检索特定 Bokeh 模型时，此名称可能很有用。

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

注意

不保证任何提供的名称的唯一性或其他条件，Bokeh 也不会出于任何原因直接使用该名称。

selected = Selection(id='p62794', ...)

类型:

只读

一个 Selection 实例，指示此 DataSource 上选定的索引。这是一个只读属性。您只能更改此对象的属性以更改选择（例如，selected.indices）。

selection_policy = UnionRenderers(id='p62798', ...)

类型:

Instance(SelectionPolicy)

一个 SelectionPolicy 实例，用于确定如何设置选择。

syncable = True

类型:

布尔值

指示此模型在 Web 浏览器中更新时是否应同步回 Bokeh 服务器。在处理经常更新的对象（我们不需要其更新的值）时，设置为 False 可能有助于减少网络流量。

注意

将此属性设置为 False 将阻止此对象上的任何 on_change() 回调触发。但是，任何 JS 端回调仍然有效。

tags = []

类型:

列表

一个可选的任意用户提供的值的列表，用于附加到此模型。

在查询文档以检索特定 Bokeh 模型时，此数据可能很有用。

>>> 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', ...)]

或者，这只是一个方便的方法，可以将任何必要的元数据附加到模型，这些元数据可以通过 CustomJS 回调等访问。

注意

不保证任何提供的标签的唯一性或其他条件，Bokeh 也不会出于任何原因直接使用这些标签。

apply_theme(property_values: dict[str, Any]) → None

应用一组主题值，这些值将用于代替默认值，但不会覆盖应用程序设置的值。

传入的字典可以原样保留并与其他实例共享以节省内存（因此调用者和 HasProps 实例都不应修改它）。

参数：

property_values (dict) – 要代替默认值使用的主题值

返回值：

无

classmethod clear_extensions() → None

清除任何当前定义的自定义扩展。

序列化调用将导致任何当前定义的自定义扩展包含在生成的文档中，无论是否使用它们。此方法可用于清除所有现有的自定义扩展定义。

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

这会创建原始模型的浅克隆，即任何可变容器或子模型都不会被复制。允许在克隆时覆盖特定属性。

classmethod dataspecs() → dict[str, DataSpec]

收集此类上所有 DataSpec 属性的名称。

此方法始终遍历类层次结构，并包含在任何父类上定义的属性。

返回值：

DataSpec 属性的名称

返回类型：

set[str]

类方法 descriptors() → list[PropertyDescriptor[Any]]

定义顺序的属性描述符列表。

destroy() → None

清理对文档和属性的引用。

equals(other: HasProps) → bool

模型的结构相等性。

参数：

other (HasProps) – 要比较的另一个实例

返回值：

如果属性在结构上相等，则为 True，否则为 False

js_link(attr: str, other: Model, other_attr: str, attr_selector: int | str | None = None) → None

使用 JavaScript 链接两个 Bokeh 模型属性。

这是一种简化方法，用于简化添加 CustomJS 回调，以便在另一个属性值发生更改时更新一个 Bokeh 模型属性。

参数：

• attr (str) – 此模型上 Bokeh 属性的名称

• other (Model) – 要链接到 self.attr 的 Bokeh 模型

• other_attr (str) – other 上要链接在一起的属性

• attr_selector (int | str) – 链接可订阅 attr 中项目的索引

版本 1.1 中添加。

引发:

ValueError –

示例

使用 js_link 的此代码

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

等效于以下内容

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

此外，要使用 attr_selector 将范围滑块的左侧连接到绘图的 x_range

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

等效于

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: JSChangeCallback) → None

将 CustomJS 回调附加到任意 BokehJS 模型事件。

在 BokehJS 端，模型属性的更改事件采用 "change:property_name" 的形式。为了方便起见，如果传递给此方法的事件名称也是模型上某个属性的名称，则会自动在其前面加上 "change:"

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

但是，除了属性更改事件之外，还有其他一些有用的事件可以响应。例如，要在一个回调函数中运行数据流式传输到 ColumnDataSource 的事件，请在源上使用 "stream" 事件

source.js_on_change('streaming', callback)

类方法 lookup(name: str, *, raises: bool = True) → PropertyDescriptor[Any] | None

在类中查找给定属性名称的 Bokeh 属性的 PropertyDescriptor。

参数：

• name (str) – 要搜索的属性的名称

• raises (bool) – 如果缺少属性，是否引发异常或返回 None

返回值：

名为 name 的属性的描述符

返回类型：

PropertyDescriptor

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

在此对象上添加一个回调，以便在 attr 发生更改时触发。

参数：

• attr (str) – 此对象上的属性名称

• *callbacks (callable) – 要注册的回调函数

返回值：

无

示例

widget.on_change('value', callback1, callback2, ..., callback_n)

on_event(event: str | type[Event], *callbacks: Callable[[Event], None] | Callable[[], None]) → None

当此模型上发生指定事件时运行回调函数

并非所有模型都支持所有事件。有关哪些模型能够触发事件的更多信息，请参阅bokeh.events中的特定事件。

类方法 parameters() → list[Parameter]

生成适合从 Glyph 派生的函数的 Python Parameter 值。

返回值：

list(Parameter)

类方法 properties(*, _with_props: bool = False) → set[str] | dict[str, Property[Any]]

收集此类上属性的名称。

警告

在 Bokeh 的未来版本中，此方法将返回一个字典，该字典将属性名称映射到属性对象。为了使此方法的当前用法面向未来，请将返回值包装在list中。

返回值：

属性名称

类方法 properties_with_refs() → dict[str, Property[Any]]

收集此类上所有也具有引用的属性的名称。

此方法始终遍历类层次结构，并包含在任何父类上定义的属性。

返回值：

具有引用的属性的名称

返回类型：

set[str]

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

收集一个将属性名称映射到其值的字典。

此方法始终遍历类层次结构，并包含在任何父类上定义的属性。

不可序列化的属性将被跳过，并且属性值将采用“序列化”格式，这可能与您通常从属性中读取的值略有不同；此方法的目的是返回无损重建对象实例所需的信息。

参数：

include_defaults (bool, 可选) – 是否包含自对象创建以来尚未显式设置的属性。（默认值：True）

返回值：

属性名称与其值的映射

返回类型：

字典

query_properties_with_values(query: Callable[[PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

使用谓词查询HasProps实例的属性值。

参数：

• query (可调用对象) – 一个可调用对象，它接受属性描述符并返回 True 或 False

• include_defaults (bool, 可选) – 是否包含用户未显式设置的属性（默认值：True）

返回值：

匹配属性的属性名称和值的映射

返回类型：

字典

references() → set[Model]

返回此对象引用的所有Models。

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

从此对象中删除回调函数

select(selector: SelectorType) → Iterable[Model]

查询此对象及其所有引用，以查找与给定选择器匹配的对象。

参数：

selector (类似 JSON)

返回值：

seq[Model]

select_one(selector: SelectorType) → Model | None

查询此对象及其所有引用，以查找与给定选择器匹配的对象。如果找到多个对象，则引发错误。返回单个匹配对象，如果未找到任何对象，则返回 None :param selector: :type selector: 类似 JSON

返回值：

模型

set_from_json(name: str, value: Any, *, setter: Setter | None = None) → None

从此对象中的 JSON 设置属性值。

参数：

• name (str) – 要设置的属性的名称

• value (JSON 值) – 要设置为属性的值

• setter (ClientSession 或 ServerSession 或 None, 可选) –

  这用于防止对 Bokeh 应用程序进行“回旋镖”更新。

  在 Bokeh 服务器应用程序的上下文中，属性的传入更新将用进行更新的会话进行注释。此值会通过更新触发的任何后续更改通知进行传播。会话可以将事件设置器与自身进行比较，并抑制任何源自自身的更新。

返回值：

无

set_select(selector: type[Model] | SelectorType, updates: dict[str, Any]) → None

使用指定的属性/值更新来更新与给定选择器匹配的对象。

参数：

• selector (类似 JSON)

• updates (dict)

返回值：

无

themed_values() → dict[str, Any] | None

获取任何主题提供的覆盖。

结果作为从属性名称到值的字典返回，如果主题未覆盖此实例的任何值，则返回 None。

返回值：

dict 或 None

to_serializable(serializer: Serializer) → ObjectRefRep

将此对象转换为可序列化表示形式。

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

unapply_theme() → None

移除任何主题值并恢复默认值。

返回值：

无

update(**kwargs: Any) → None

根据给定的关键字参数更新对象的属性。

返回值：

无

示例

以下是等效的

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)

属性 document: Document | None

此模型附加到的 Document（可以为 None）

类 DataSource(*args: Any, id: ID | None = None, **kwargs: Any)

基类: Model

数据源类型的基类。

注意

这是一个抽象基类，用于帮助组织 Bokeh 模型类型的层次结构。**它本身没有用处，不能实例化。**

JSON 原型

{
  "id": "p62805", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "name": null, 
  "selected": {
    "attributes": {
      "indices": [], 
      "line_indices": []
    }, 
    "id": "p62806", 
    "name": "Selection", 
    "type": "object"
  }, 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": []
}

name = None

类型:

Nullable(String)

此模型的任意用户提供的名称。

在查询文档以检索特定 Bokeh 模型时，此名称可能很有用。

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

注意

不保证任何提供的名称的唯一性或其他条件，Bokeh 也不会出于任何原因直接使用该名称。

selected = Selection(id='p62811', ...)

类型:

只读

一个 Selection 实例，指示此 DataSource 上选定的索引。这是一个只读属性。您只能更改此对象的属性以更改选择（例如，selected.indices）。

syncable = True

类型:

布尔值

指示此模型在 Web 浏览器中更新时是否应同步回 Bokeh 服务器。在处理经常更新的对象（我们不需要其更新的值）时，设置为 False 可能有助于减少网络流量。

注意

将此属性设置为 False 将阻止此对象上的任何 on_change() 回调触发。但是，任何 JS 端回调仍然有效。

tags = []

类型:

列表

一个可选的任意用户提供的值的列表，用于附加到此模型。

在查询文档以检索特定 Bokeh 模型时，此数据可能很有用。

>>> 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', ...)]

或者，这只是一个方便的方法，可以将任何必要的元数据附加到模型，这些元数据可以通过 CustomJS 回调等访问。

注意

不保证任何提供的标签的唯一性或其他条件，Bokeh 也不会出于任何原因直接使用这些标签。

apply_theme(property_values: dict[str, Any]) → None

应用一组主题值，这些值将用于代替默认值，但不会覆盖应用程序设置的值。

传入的字典可以原样保留并与其他实例共享以节省内存（因此调用者和 HasProps 实例都不应修改它）。

参数：

property_values (dict) – 要代替默认值使用的主题值

返回值：

无

类方法 clear_extensions() → None

清除任何当前定义的自定义扩展。

序列化调用将导致任何当前定义的自定义扩展包含在生成的文档中，无论是否使用它们。此方法可用于清除所有现有的自定义扩展定义。

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

这会创建原始模型的浅克隆，即任何可变容器或子模型都不会被复制。允许在克隆时覆盖特定属性。

类方法 dataspecs() → dict[str, DataSpec]

收集此类上所有 DataSpec 属性的名称。

此方法始终遍历类层次结构，并包含在任何父类上定义的属性。

返回值：

DataSpec 属性的名称

返回类型：

set[str]

类方法 descriptors() → list[PropertyDescriptor[Any]]

定义顺序的属性描述符列表。

destroy() → None

清理对文档和属性的引用。

equals(other: HasProps) → bool

模型的结构相等性。

参数：

other (HasProps) – 要比较的另一个实例

返回值：

如果属性在结构上相等，则为 True，否则为 False

js_link(attr: str, other: Model, other_attr: str, attr_selector: int | str | None = None) → None

使用 JavaScript 链接两个 Bokeh 模型属性。

这是一种简化方法，用于简化添加 CustomJS 回调，以便在另一个属性值发生更改时更新一个 Bokeh 模型属性。

参数：

• attr (str) – 此模型上 Bokeh 属性的名称

• other (Model) – 要链接到 self.attr 的 Bokeh 模型

• other_attr (str) – other 上要链接在一起的属性

• attr_selector (int | str) – 链接可订阅 attr 中项目的索引

版本 1.1 中添加。

引发:

ValueError –

示例

使用 js_link 的此代码

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

等效于以下内容

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

此外，要使用 attr_selector 将范围滑块的左侧连接到绘图的 x_range

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

等效于

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: JSChangeCallback) → None

将 CustomJS 回调附加到任意 BokehJS 模型事件。

在 BokehJS 端，模型属性的更改事件采用 "change:property_name" 的形式。为了方便起见，如果传递给此方法的事件名称也是模型上某个属性的名称，则会自动在其前面加上 "change:"

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

但是，除了属性更改事件之外，还有其他一些有用的事件可以响应。例如，要在一个回调函数中运行数据流式传输到 ColumnDataSource 的事件，请在源上使用 "stream" 事件

source.js_on_change('streaming', callback)

类方法 lookup(name: str, *, raises: bool = True) → PropertyDescriptor[Any] | None

在类中查找给定属性名称的 Bokeh 属性的 PropertyDescriptor。

参数：

• name (str) – 要搜索的属性的名称

• raises (bool) – 如果缺少属性，是否引发异常或返回 None

返回值：

名为 name 的属性的描述符

返回类型：

PropertyDescriptor

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

在此对象上添加一个回调，以便在 attr 发生更改时触发。

参数：

• attr (str) – 此对象上的属性名称

• *callbacks (callable) – 要注册的回调函数

返回值：

无

示例

widget.on_change('value', callback1, callback2, ..., callback_n)

on_event(event: str | type[Event], *callbacks: Callable[[Event], None] | Callable[[], None]) → None

当此模型上发生指定事件时运行回调函数

并非所有模型都支持所有事件。有关哪些模型能够触发事件的更多信息，请参阅bokeh.events中的特定事件。

classmethod parameters() → list[Parameter]

生成适合从 Glyph 派生的函数的 Python Parameter 值。

返回值：

list(Parameter)

classmethod properties(*, _with_props: bool = False) → set[str] | dict[str, Property[Any]]

收集此类上属性的名称。

警告

在 Bokeh 的未来版本中，此方法将返回一个字典，该字典将属性名称映射到属性对象。为了使此方法的当前用法面向未来，请将返回值包装在list中。

返回值：

属性名称

classmethod properties_with_refs() → dict[str, Property[Any]]

收集此类上所有也具有引用的属性的名称。

此方法始终遍历类层次结构，并包含在任何父类上定义的属性。

返回值：

具有引用的属性的名称

返回类型：

set[str]

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

收集一个将属性名称映射到其值的字典。

此方法始终遍历类层次结构，并包含在任何父类上定义的属性。

不可序列化的属性将被跳过，并且属性值将采用“序列化”格式，这可能与您通常从属性中读取的值略有不同；此方法的目的是返回无损重建对象实例所需的信息。

参数：

include_defaults (bool, 可选) – 是否包含自对象创建以来尚未显式设置的属性。（默认值：True）

返回值：

属性名称与其值的映射

返回类型：

字典

query_properties_with_values(query: Callable[[PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

使用谓词查询HasProps实例的属性值。

参数：

• query (可调用对象) – 一个可调用对象，它接受属性描述符并返回 True 或 False

• include_defaults (bool, 可选) – 是否包含用户未显式设置的属性（默认值：True）

返回值：

匹配属性的属性名称和值的映射

返回类型：

字典

references() → set[Model]

返回此对象引用的所有Models。

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

从此对象中删除回调函数

select(selector: SelectorType) → Iterable[Model]

查询此对象及其所有引用，以查找与给定选择器匹配的对象。

参数：

selector (类似 JSON)

返回值：

seq[Model]

select_one(selector: SelectorType) → Model | None

查询此对象及其所有引用，以查找与给定选择器匹配的对象。如果找到多个对象，则引发错误。返回单个匹配对象，如果未找到任何对象，则返回 None :param selector: :type selector: 类似 JSON

返回值：

模型

set_from_json(name: str, value: Any, *, setter: Setter | None = None) → None

从此对象中的 JSON 设置属性值。

参数：

• name (str) – 要设置的属性的名称

• value (JSON 值) – 要设置为属性的值

• setter (ClientSession 或 ServerSession 或 None, 可选) –

  这用于防止对 Bokeh 应用程序进行“回旋镖”更新。

  在 Bokeh 服务器应用程序的上下文中，属性的传入更新将用进行更新的会话进行注释。此值会通过更新触发的任何后续更改通知进行传播。会话可以将事件设置器与自身进行比较，并抑制任何源自自身的更新。

返回值：

无

set_select(selector: type[Model] | SelectorType, updates: dict[str, Any]) → None

使用指定的属性/值更新来更新与给定选择器匹配的对象。

参数：

• selector (类似 JSON)

• updates (dict)

返回值：

无

themed_values() → dict[str, Any] | None

获取任何主题提供的覆盖。

结果作为从属性名称到值的字典返回，如果主题未覆盖此实例的任何值，则返回 None。

返回值：

dict 或 None

to_serializable(serializer: Serializer) → ObjectRefRep

将此对象转换为可序列化表示形式。

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

unapply_theme() → None

移除任何主题值并恢复默认值。

返回值：

无

update(**kwargs: Any) → None

根据给定的关键字参数更新对象的属性。

返回值：

无

示例

以下是等效的

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)

property document: Document | None

此模型附加到的 Document（可以为 None）

class GeoJSONDataSource(*args: Any, id: ID | None = None, **kwargs: Any)

基类: ColumnarDataSource

JSON 原型

{
  "default_values": {
    "type": "map"
  }, 
  "geojson": {
    "name": "unset", 
    "type": "symbol"
  }, 
  "id": "p62816", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "name": null, 
  "selected": {
    "attributes": {
      "indices": [], 
      "line_indices": []
    }, 
    "id": "p62817", 
    "name": "Selection", 
    "type": "object"
  }, 
  "selection_policy": {
    "id": "p62818", 
    "name": "UnionRenderers", 
    "type": "object"
  }, 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": []
}

default_values = {}

类型:

Dict(String, Any)

定义每列的默认值。

当插入数据源中的行时使用，例如通过编辑工具，当未明确提供给定列的值时。如果缺少默认值，工具将默认使用其自己的配置，或者尝试让数据源推断一个合理的默认值。

geojson = Undefined

类型:

Required(JSON)

包含用于绘图的要素的 GeoJSON。目前 GeoJSONDataSource 只能处理 FeatureCollection 或 GeometryCollection。

name = None

类型:

Nullable(String)

此模型的任意用户提供的名称。

在查询文档以检索特定 Bokeh 模型时，此名称可能很有用。

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

注意

不保证任何提供的名称的唯一性或其他条件，Bokeh 也不会出于任何原因直接使用该名称。

selected = Selection(id='p62831', ...)

类型:

只读

一个 Selection 实例，指示此 DataSource 上选定的索引。这是一个只读属性。您只能更改此对象的属性以更改选择（例如，selected.indices）。

selection_policy = UnionRenderers(id='p62835', ...)

类型:

Instance(SelectionPolicy)

一个 SelectionPolicy 实例，用于确定如何设置选择。

syncable = True

类型:

布尔值

指示此模型在 Web 浏览器中更新时是否应同步回 Bokeh 服务器。在处理经常更新的对象（我们不需要其更新的值）时，设置为 False 可能有助于减少网络流量。

注意

将此属性设置为 False 将阻止此对象上的任何 on_change() 回调触发。但是，任何 JS 端回调仍然有效。

tags = []

类型:

列表

一个可选的任意用户提供的值的列表，用于附加到此模型。

在查询文档以检索特定 Bokeh 模型时，此数据可能很有用。

>>> 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', ...)]

或者，这只是一个方便的方法，可以将任何必要的元数据附加到模型，这些元数据可以通过 CustomJS 回调等访问。

注意

不保证任何提供的标签的唯一性或其他条件，Bokeh 也不会出于任何原因直接使用这些标签。

apply_theme(property_values: dict[str, Any]) → None

应用一组主题值，这些值将用于代替默认值，但不会覆盖应用程序设置的值。

传入的字典可以原样保留并与其他实例共享以节省内存（因此调用者和 HasProps 实例都不应修改它）。

参数：

property_values (dict) – 要代替默认值使用的主题值

返回值：

无

classmethod clear_extensions() → None

清除任何当前定义的自定义扩展。

序列化调用将导致任何当前定义的自定义扩展包含在生成的文档中，无论是否使用它们。此方法可用于清除所有现有的自定义扩展定义。

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

这会创建原始模型的浅克隆，即任何可变容器或子模型都不会被复制。允许在克隆时覆盖特定属性。

classmethod dataspecs() → dict[str, DataSpec]

收集此类上所有 DataSpec 属性的名称。

此方法始终遍历类层次结构，并包含在任何父类上定义的属性。

返回值：

DataSpec 属性的名称

返回类型：

set[str]

classmethod descriptors() → list[PropertyDescriptor[Any]]

定义顺序的属性描述符列表。

destroy() → None

清理对文档和属性的引用。

equals(other: HasProps) → bool

模型的结构相等性。

参数：

other (HasProps) – 要比较的另一个实例

返回值：

如果属性在结构上相等，则为 True，否则为 False

js_link(attr: str, other: Model, other_attr: str, attr_selector: int | str | None = None) → None

使用 JavaScript 链接两个 Bokeh 模型属性。

这是一种简化方法，用于简化添加 CustomJS 回调，以便在另一个属性值发生更改时更新一个 Bokeh 模型属性。

参数：

• attr (str) – 此模型上 Bokeh 属性的名称

• other (Model) – 要链接到 self.attr 的 Bokeh 模型

• other_attr (str) – other 上要链接在一起的属性

• attr_selector (int | str) – 链接可订阅 attr 中项目的索引

版本 1.1 中添加。

引发:

ValueError –

示例

使用 js_link 的此代码

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

等效于以下内容

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

此外，要使用 attr_selector 将范围滑块的左侧连接到绘图的 x_range

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

等效于

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: JSChangeCallback) → None

将 CustomJS 回调附加到任意 BokehJS 模型事件。

在 BokehJS 端，模型属性的更改事件采用 "change:property_name" 的形式。为了方便起见，如果传递给此方法的事件名称也是模型上某个属性的名称，则会自动在其前面加上 "change:"

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

但是，除了属性更改事件之外，还有其他一些有用的事件可以响应。例如，要在一个回调函数中运行数据流式传输到 ColumnDataSource 的事件，请在源上使用 "stream" 事件

source.js_on_change('streaming', callback)

classmethod lookup(name: str, *, raises: bool = True) → PropertyDescriptor[Any] | None

在类中查找给定属性名称的 Bokeh 属性的 PropertyDescriptor。

参数：

• name (str) – 要搜索的属性的名称

• raises (bool) – 如果缺少属性，是否引发异常或返回 None

返回值：

名为 name 的属性的描述符

返回类型：

PropertyDescriptor

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

在此对象上添加一个回调，以便在 attr 发生更改时触发。

参数：

• attr (str) – 此对象上的属性名称

• *callbacks (callable) – 要注册的回调函数

返回值：

无

示例

widget.on_change('value', callback1, callback2, ..., callback_n)

on_event(event: str | type[Event], *callbacks: Callable[[Event], None] | Callable[[], None]) → None

当此模型上发生指定事件时运行回调函数

并非所有模型都支持所有事件。有关哪些模型能够触发事件的更多信息，请参阅bokeh.events中的特定事件。

classmethod parameters() → list[Parameter]

生成适合从 Glyph 派生的函数的 Python Parameter 值。

返回值：

list(Parameter)

classmethod properties(*, _with_props: bool = False) → set[str] | dict[str, Property[Any]]

收集此类上属性的名称。

警告

在 Bokeh 的未来版本中，此方法将返回一个字典，该字典将属性名称映射到属性对象。为了使此方法的当前用法面向未来，请将返回值包装在list中。

返回值：

属性名称

classmethod properties_with_refs() → dict[str, Property[Any]]

收集此类上所有也具有引用的属性的名称。

此方法始终遍历类层次结构，并包含在任何父类上定义的属性。

返回值：

具有引用的属性的名称

返回类型：

set[str]

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

收集一个将属性名称映射到其值的字典。

此方法始终遍历类层次结构，并包含在任何父类上定义的属性。

不可序列化的属性将被跳过，并且属性值将采用“序列化”格式，这可能与您通常从属性中读取的值略有不同；此方法的目的是返回无损重建对象实例所需的信息。

参数：

include_defaults (bool, 可选) – 是否包含自对象创建以来尚未显式设置的属性。（默认值：True）

返回值：

属性名称与其值的映射

返回类型：

字典

query_properties_with_values(query: Callable[[PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

使用谓词查询HasProps实例的属性值。

参数：

• query (可调用对象) – 一个可调用对象，它接受属性描述符并返回 True 或 False

• include_defaults (bool, 可选) – 是否包含用户未显式设置的属性（默认值：True）

返回值：

匹配属性的属性名称和值的映射

返回类型：

字典

references() → set[Model]

返回此对象引用的所有Models。

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

从此对象中删除回调函数

select(selector: SelectorType) → Iterable[Model]

查询此对象及其所有引用，以查找与给定选择器匹配的对象。

参数：

selector (类似 JSON)

返回值：

seq[Model]

select_one(selector: SelectorType) → Model | None

查询此对象及其所有引用，以查找与给定选择器匹配的对象。如果找到多个对象，则引发错误。返回单个匹配对象，如果未找到任何对象，则返回 None :param selector: :type selector: 类似 JSON

返回值：

模型

set_from_json(name: str, value: Any, *, setter: Setter | None = None) → None

从此对象中的 JSON 设置属性值。

参数：

• name (str) – 要设置的属性的名称

• value (JSON 值) – 要设置为属性的值

• setter (ClientSession 或 ServerSession 或 None, 可选) –

  这用于防止对 Bokeh 应用程序进行“回旋镖”更新。

  在 Bokeh 服务器应用程序的上下文中，属性的传入更新将用进行更新的会话进行注释。此值会通过更新触发的任何后续更改通知进行传播。会话可以将事件设置器与自身进行比较，并抑制任何源自自身的更新。

返回值：

无

set_select(selector: type[Model] | SelectorType, updates: dict[str, Any]) → None

使用指定的属性/值更新来更新与给定选择器匹配的对象。

参数：

• selector (类似 JSON)

• updates (dict)

返回值：

无

themed_values() → dict[str, Any] | None

获取任何主题提供的覆盖。

结果作为从属性名称到值的字典返回，如果主题未覆盖此实例的任何值，则返回 None。

返回值：

dict 或 None

to_serializable(serializer: Serializer) → ObjectRefRep

将此对象转换为可序列化表示形式。

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

unapply_theme() → None

移除任何主题值并恢复默认值。

返回值：

无

update(**kwargs: Any) → None

根据给定的关键字参数更新对象的属性。

返回值：

无

示例

以下是等效的

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)

property document: Document | None

此模型附加到的 Document（可以为 None）

class ServerSentDataSource(*args: Any, id: ID | None = None, **kwargs: Any)

基类: WebDataSource

一个可以接收服务器发送事件端点来填充列的数据源。

JSON 原型

{
  "adapter": null, 
  "data": {
    "type": "map"
  }, 
  "data_url": {
    "name": "unset", 
    "type": "symbol"
  }, 
  "default_values": {
    "type": "map"
  }, 
  "id": "p62842", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "max_size": null, 
  "mode": "replace", 
  "name": null, 
  "selected": {
    "attributes": {
      "indices": [], 
      "line_indices": []
    }, 
    "id": "p62843", 
    "name": "Selection", 
    "type": "object"
  }, 
  "selection_policy": {
    "id": "p62844", 
    "name": "UnionRenderers", 
    "type": "object"
  }, 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": []
}

adapter = None

类型:

Nullable(Instance(CustomJS))

一个 JavaScript 回调，用于将原始 JSON 响应适配到 Bokeh ColumnDataSource 格式。

如果提供，则此回调会在接收 JSON 数据后立即执行，但在将数据追加到或替换数据源中的数据之前执行。 CustomJS 回调将接收 AjaxDataSource 作为 cb_obj，并将接收原始 JSON 响应作为 cb_data.response。回调代码应返回一个适合 Bokeh ColumnDataSource 的 data 对象（即字符串列名称到数据数组的映射）。

data = {}

类型:

列数据

列名称到数据序列的映射。列可以是，例如，Python 列表或元组、NumPy 数组等。

还可以从 Pandas DataFrame 或 GroupBy 对象设置 .data 属性。在这些情况下，行为与将对象传递给 ColumnDataSource 初始化程序相同。

data_url = Undefined

类型:

Required(String)

要从中获取数据的 URL。

default_values = {}

类型:

Dict(String, Any)

定义每列的默认值。

当插入数据源中的行时使用，例如通过编辑工具，当未明确提供给定列的值时。如果缺少默认值，工具将默认使用其自己的配置，或者尝试让数据源推断一个合理的默认值。

max_size = None

类型:

Nullable(Int)

数据列的最大大小。如果新的获取会导致列大于 max_size，则会删除较早的数据以腾出空间。

mode = 'replace'

类型:

Enum(Enumeration(replace, append))

是将新数据追加到现有数据（最多 max_size），还是完全替换现有数据。

name = None

类型:

Nullable(String)

此模型的任意用户提供的名称。

在查询文档以检索特定 Bokeh 模型时，此名称可能很有用。

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

注意

不保证任何提供的名称的唯一性或其他条件，Bokeh 也不会出于任何原因直接使用该名称。

selected = Selection(id='p62869', ...)

类型:

只读

一个 Selection 实例，指示此 DataSource 上选定的索引。这是一个只读属性。您只能更改此对象的属性以更改选择（例如，selected.indices）。

selection_policy = UnionRenderers(id='p62873', ...)

类型:

Instance(SelectionPolicy)

一个 SelectionPolicy 实例，用于确定如何设置选择。

syncable = True

类型:

布尔值

指示此模型在 Web 浏览器中更新时是否应同步回 Bokeh 服务器。在处理经常更新的对象（我们不需要其更新的值）时，设置为 False 可能有助于减少网络流量。

注意

将此属性设置为 False 将阻止此对象上的任何 on_change() 回调触发。但是，任何 JS 端回调仍然有效。

tags = []

类型:

列表

一个可选的任意用户提供的值的列表，用于附加到此模型。

在查询文档以检索特定 Bokeh 模型时，此数据可能很有用。

>>> 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', ...)]

或者，这只是一个方便的方法，可以将任何必要的元数据附加到模型，这些元数据可以通过 CustomJS 回调等访问。

注意

不保证任何提供的标签的唯一性或其他条件，Bokeh 也不会出于任何原因直接使用这些标签。

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

将新的一列数据追加到数据源。

参数：

• data (seq) – 要添加的新数据

• name (str, optional) – 要使用的列名。如果未提供，则生成格式为“Series ####”的名称

返回值：

使用的列名

返回类型：

str

apply_theme(property_values: dict[str, Any]) → None

应用一组主题值，这些值将用于代替默认值，但不会覆盖应用程序设置的值。

传入的字典可以原样保留并与其他实例共享以节省内存（因此调用者和 HasProps 实例都不应修改它）。

参数：

property_values (dict) – 要代替默认值使用的主题值

返回值：

无

classmethod clear_extensions() → None

清除任何当前定义的自定义扩展。

序列化调用将导致任何当前定义的自定义扩展包含在生成的文档中，无论是否使用它们。此方法可用于清除所有现有的自定义扩展定义。

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

这会创建原始模型的浅克隆，即任何可变容器或子模型都不会被复制。允许在克隆时覆盖特定属性。

classmethod dataspecs() → dict[str, DataSpec]

收集此类上所有 DataSpec 属性的名称。

此方法始终遍历类层次结构，并包含在任何父类上定义的属性。

返回值：

DataSpec 属性的名称

返回类型：

set[str]

classmethod descriptors() → list[PropertyDescriptor[Any]]

定义顺序的属性描述符列表。

destroy() → None

清理对文档和属性的引用。

equals(other: HasProps) → bool

模型的结构相等性。

参数：

other (HasProps) – 要比较的另一个实例

返回值：

如果属性在结构上相等，则为 True，否则为 False

classmethod from_df(data: pd.DataFrame) → DataDict

创建一个包含 Pandas DataFrame 中列的 dict，适用于创建 ColumnDataSource。

参数：

data (DataFrame) – 要转换的数据

返回值：

dict[str, np.array]

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

创建一个包含 Pandas GroupBy 中列的 dict，适用于创建 ColumnDataSource。

生成的数据是针对组运行 describe 的结果。

参数：

data (Groupby) – 要转换的数据

返回值：

dict[str, np.array]

js_link(attr: str, other: Model, other_attr: str, attr_selector: int | str | None = None) → None

使用 JavaScript 链接两个 Bokeh 模型属性。

这是一种简化方法，用于简化添加 CustomJS 回调，以便在另一个属性值发生更改时更新一个 Bokeh 模型属性。

参数：

• attr (str) – 此模型上 Bokeh 属性的名称

• other (Model) – 要链接到 self.attr 的 Bokeh 模型

• other_attr (str) – other 上要链接在一起的属性

• attr_selector (int | str) – 链接可订阅 attr 中项目的索引

版本 1.1 中添加。

引发:

ValueError –

示例

使用 js_link 的此代码

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

等效于以下内容

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

此外，要使用 attr_selector 将范围滑块的左侧连接到绘图的 x_range

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

等效于

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: JSChangeCallback) → None

将 CustomJS 回调附加到任意 BokehJS 模型事件。

在 BokehJS 端，模型属性的更改事件采用 "change:property_name" 的形式。为了方便起见，如果传递给此方法的事件名称也是模型上某个属性的名称，则会自动在其前面加上 "change:"

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

但是，除了属性更改事件之外，还有其他一些有用的事件可以响应。例如，要在一个回调函数中运行数据流式传输到 ColumnDataSource 的事件，请在源上使用 "stream" 事件

source.js_on_change('streaming', callback)

classmethod lookup(name: str, *, raises: bool = True) → PropertyDescriptor[Any] | None

在类中查找给定属性名称的 Bokeh 属性的 PropertyDescriptor。

参数：

• name (str) – 要搜索的属性的名称

• raises (bool) – 如果缺少属性，是否引发异常或返回 None

返回值：

名为 name 的属性的描述符

返回类型：

PropertyDescriptor

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

在此对象上添加一个回调，以便在 attr 发生更改时触发。

参数：

• attr (str) – 此对象上的属性名称

• *callbacks (callable) – 要注册的回调函数

返回值：

无

示例

widget.on_change('value', callback1, callback2, ..., callback_n)

on_event(event: str | type[Event], *callbacks: Callable[[Event], None] | Callable[[], None]) → None

当此模型上发生指定事件时运行回调函数

并非所有模型都支持所有事件。有关哪些模型能够触发事件的更多信息，请参阅bokeh.events中的特定事件。

classmethod parameters() → list[Parameter]

生成适合从 Glyph 派生的函数的 Python Parameter 值。

返回值：

list(Parameter)

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

有效更新特定位置的数据源列

如果只需要更新ColumnDataSource中的一小部分数据，则可以使用此方法有效地仅更新该子集，而不是需要发送整个数据集。

此方法应传递一个字典，该字典将列名映射到描述要应用的补丁更改的元组列表。要完全替换列中的单个项目，元组应采用以下形式

(index, new_value)  # replace a single column value

# or

(slice, new_values) # replace several column values

索引或切片处的值将替换为相应的新的值。

对于其值为其他数组或列表的列（例如图像或补丁 Glyph），也可以修补“子区域”。在这种情况下，元组的第一个项目应为，其第一个元素是 CDS 补丁中数组项目的索引，其后续元素是数组项目中的整数索引或切片

# 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)

假设一个二维 NumPy 数组列表，上面的补丁大致等价于

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

data[2][:, 10] = new_data

可以接受的切片和数据类型有一些限制。

• 切片的负start、stop或step值将导致ValueError。

• 在切片中，start > stop将导致ValueError

• 在修补一维或二维子项时，子项必须是 NumPy 数组。

• 新值必须作为适当大小的**扁平化一维数组**提供。

参数：

patches (dict[str, list[tuple]]) – 每列的补丁列表

返回值：

无

引发:

ValueError –

示例

以下示例显示了如何修补整个列元素。在这种情况下，

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)

此操作后，source.data的值将为

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

有关更全面的示例，请参阅examples/server/app/patch_app.py。

classmethod properties(*, _with_props: bool = False) → set[str] | dict[str, Property[Any]]

收集此类上属性的名称。

警告

在 Bokeh 的未来版本中，此方法将返回一个字典，该字典将属性名称映射到属性对象。为了使此方法的当前用法面向未来，请将返回值包装在list中。

返回值：

属性名称

classmethod properties_with_refs() → dict[str, Property[Any]]

收集此类上所有也具有引用的属性的名称。

此方法始终遍历类层次结构，并包含在任何父类上定义的属性。

返回值：

具有引用的属性的名称

返回类型：

set[str]

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

收集一个将属性名称映射到其值的字典。

此方法始终遍历类层次结构，并包含在任何父类上定义的属性。

不可序列化的属性将被跳过，并且属性值将采用“序列化”格式，这可能与您通常从属性中读取的值略有不同；此方法的目的是返回无损重建对象实例所需的信息。

参数：

include_defaults (bool, 可选) – 是否包含自对象创建以来尚未显式设置的属性。（默认值：True）

返回值：

属性名称与其值的映射

返回类型：

字典

query_properties_with_values(query: Callable[[PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

使用谓词查询HasProps实例的属性值。

参数：

• query (可调用对象) – 一个可调用对象，它接受属性描述符并返回 True 或 False

• include_defaults (bool, 可选) – 是否包含用户未显式设置的属性（默认值：True）

返回值：

匹配属性的属性名称和值的映射

返回类型：

字典

references() → set[Model]

返回此对象引用的所有Models。

remove(name: str) → None

删除一列数据。

参数：

name (str) – 要删除的列的名称

返回值：

无

注意

如果列名不存在，则会发出警告。

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

从此对象中删除回调函数

select(selector: SelectorType) → Iterable[Model]

查询此对象及其所有引用，以查找与给定选择器匹配的对象。

参数：

selector (类似 JSON)

返回值：

seq[Model]

select_one(selector: SelectorType) → Model | None

查询此对象及其所有引用，以查找与给定选择器匹配的对象。如果找到多个对象，则引发错误。返回单个匹配对象，如果未找到任何对象，则返回 None :param selector: :type selector: 类似 JSON

返回值：

模型

set_from_json(name: str, value: Any, *, setter: Setter | None = None) → None

从此对象中的 JSON 设置属性值。

参数：

• name (str) – 要设置的属性的名称

• value (JSON 值) – 要设置为属性的值

• setter (ClientSession 或 ServerSession 或 None, 可选) –

  这用于防止对 Bokeh 应用程序进行“回旋镖”更新。

  在 Bokeh 服务器应用程序的上下文中，属性的传入更新将用进行更新的会话进行注释。此值会通过更新触发的任何后续更改通知进行传播。会话可以将事件设置器与自身进行比较，并抑制任何源自自身的更新。

返回值：

无

set_select(selector: type[Model] | SelectorType, updates: dict[str, Any]) → None

使用指定的属性/值更新来更新与给定选择器匹配的对象。

参数：

• selector (类似 JSON)

• updates (dict)

返回值：

无

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

有效地使用新的追加数据更新数据源列。

在需要更新数据列的情况下，此方法可以有效地仅发送新数据，而不是要求重新发送整个数据集。

参数：

• new_data (dict[str, seq]) –

  列名到要追加到每个列的新数据的序列的映射。

  数据源的所有列都必须出现在 new_data 中，并具有相同长度的追加数据。

• rollover (int, optional) – 最大列大小，超过此大小，列开头的数据将开始被丢弃。如果为 None，则列将无限增长（默认值：None）

返回值：

无

引发:

ValueError –

示例

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() → dict[str, Any] | None

获取任何主题提供的覆盖。

结果作为从属性名称到值的字典返回，如果主题未覆盖此实例的任何值，则返回 None。

返回值：

dict 或 None

to_df() → pd.DataFrame

将此数据源转换为 pandas DataFrame。

返回值：

DataFrame

to_serializable(serializer: Serializer) → ObjectRefRep

将此对象转换为可序列化表示形式。

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

unapply_theme() → None

移除任何主题值并恢复默认值。

返回值：

无

update(**kwargs: Any) → None

根据给定的关键字参数更新对象的属性。

返回值：

无

示例

以下是等效的

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)

property column_names: list[str]

此数据源中列名称的列表。

property document: Document | None

此模型附加到的 Document（可以为 None）

class WebDataSource(*args: Any, id: ID | None = None, **kwargs: Any)

基类：ColumnDataSource

可以从数据 URL 更新的 Web 列数据源的基类。

注意

此基类通常不适合单独实例化。

注意

这是一个抽象基类，用于帮助组织 Bokeh 模型类型的层次结构。**它本身没有用处，不能实例化。**

JSON 原型

{
  "adapter": null, 
  "data": {
    "type": "map"
  }, 
  "data_url": {
    "name": "unset", 
    "type": "symbol"
  }, 
  "default_values": {
    "type": "map"
  }, 
  "id": "p62880", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "max_size": null, 
  "mode": "replace", 
  "name": null, 
  "selected": {
    "attributes": {
      "indices": [], 
      "line_indices": []
    }, 
    "id": "p62881", 
    "name": "Selection", 
    "type": "object"
  }, 
  "selection_policy": {
    "id": "p62882", 
    "name": "UnionRenderers", 
    "type": "object"
  }, 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": []
}

adapter = None

类型:

Nullable(Instance(CustomJS))

一个 JavaScript 回调，用于将原始 JSON 响应适配到 Bokeh ColumnDataSource 格式。

如果提供，则此回调会在接收 JSON 数据后立即执行，但在将数据追加到或替换数据源中的数据之前执行。 CustomJS 回调将接收 AjaxDataSource 作为 cb_obj，并将接收原始 JSON 响应作为 cb_data.response。回调代码应返回一个适合 Bokeh ColumnDataSource 的 data 对象（即字符串列名称到数据数组的映射）。

data = {}

类型:

列数据

列名称到数据序列的映射。列可以是，例如，Python 列表或元组、NumPy 数组等。

还可以从 Pandas DataFrame 或 GroupBy 对象设置 .data 属性。在这些情况下，行为与将对象传递给 ColumnDataSource 初始化程序相同。

data_url = Undefined

类型:

Required(String)

要从中获取数据的 URL。

default_values = {}

类型:

Dict(String, Any)

定义每列的默认值。

当插入数据源中的行时使用，例如通过编辑工具，当未明确提供给定列的值时。如果缺少默认值，工具将默认使用其自己的配置，或者尝试让数据源推断一个合理的默认值。

max_size = None

类型:

Nullable(Int)

数据列的最大大小。如果新的获取会导致列大于 max_size，则会删除较早的数据以腾出空间。

mode = 'replace'

类型:

Enum(Enumeration(replace, append))

是将新数据追加到现有数据（最多 max_size），还是完全替换现有数据。

name = None

类型:

Nullable(String)

此模型的任意用户提供的名称。

在查询文档以检索特定 Bokeh 模型时，此名称可能很有用。

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

注意

不保证任何提供的名称的唯一性或其他条件，Bokeh 也不会出于任何原因直接使用该名称。

selected = Selection(id='p62907', ...)

类型:

只读

一个 Selection 实例，指示此 DataSource 上选定的索引。这是一个只读属性。您只能更改此对象的属性以更改选择（例如，selected.indices）。

selection_policy = UnionRenderers(id='p62911', ...)

类型:

Instance(SelectionPolicy)

一个 SelectionPolicy 实例，用于确定如何设置选择。

syncable = True

类型:

布尔值

指示此模型在 Web 浏览器中更新时是否应同步回 Bokeh 服务器。在处理经常更新的对象（我们不需要其更新的值）时，设置为 False 可能有助于减少网络流量。

注意

将此属性设置为 False 将阻止此对象上的任何 on_change() 回调触发。但是，任何 JS 端回调仍然有效。

tags = []

类型:

列表

一个可选的任意用户提供的值的列表，用于附加到此模型。

在查询文档以检索特定 Bokeh 模型时，此数据可能很有用。

>>> 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', ...)]

或者，这只是一个方便的方法，可以将任何必要的元数据附加到模型，这些元数据可以通过 CustomJS 回调等访问。

注意

不保证任何提供的标签的唯一性或其他条件，Bokeh 也不会出于任何原因直接使用这些标签。

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

将新的一列数据追加到数据源。

参数：

• data (seq) – 要添加的新数据

• name (str, optional) – 要使用的列名。如果未提供，则生成格式为“Series ####”的名称

返回值：

使用的列名

返回类型：

str

apply_theme(property_values: dict[str, Any]) → None

应用一组主题值，这些值将用于代替默认值，但不会覆盖应用程序设置的值。

传入的字典可以原样保留并与其他实例共享以节省内存（因此调用者和 HasProps 实例都不应修改它）。

参数：

property_values (dict) – 要代替默认值使用的主题值

返回值：

无

classmethod clear_extensions() → None

清除任何当前定义的自定义扩展。

序列化调用将导致任何当前定义的自定义扩展包含在生成的文档中，无论是否使用它们。此方法可用于清除所有现有的自定义扩展定义。

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

这会创建原始模型的浅克隆，即任何可变容器或子模型都不会被复制。允许在克隆时覆盖特定属性。

classmethod dataspecs() → dict[str, DataSpec]

收集此类上所有 DataSpec 属性的名称。

此方法始终遍历类层次结构，并包含在任何父类上定义的属性。

返回值：

DataSpec 属性的名称

返回类型：

set[str]

classmethod descriptors() → list[PropertyDescriptor[Any]]

定义顺序的属性描述符列表。

destroy() → None

清理对文档和属性的引用。

equals(other: HasProps) → bool

模型的结构相等性。

参数：

other (HasProps) – 要比较的另一个实例

返回值：

如果属性在结构上相等，则为 True，否则为 False

classmethod from_df(data: pd.DataFrame) → DataDict

创建一个包含 Pandas DataFrame 中列的 dict，适用于创建 ColumnDataSource。

参数：

data (DataFrame) – 要转换的数据

返回值：

dict[str, np.array]

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

创建一个包含 Pandas GroupBy 中列的 dict，适用于创建 ColumnDataSource。

生成的数据是针对组运行 describe 的结果。

参数：

data (Groupby) – 要转换的数据

返回值：

dict[str, np.array]

js_link(attr: str, other: Model, other_attr: str, attr_selector: int | str | None = None) → None

使用 JavaScript 链接两个 Bokeh 模型属性。

这是一种简化方法，用于简化添加 CustomJS 回调，以便在另一个属性值发生更改时更新一个 Bokeh 模型属性。

参数：

• attr (str) – 此模型上 Bokeh 属性的名称

• other (Model) – 要链接到 self.attr 的 Bokeh 模型

• other_attr (str) – other 上要链接在一起的属性

• attr_selector (int | str) – 链接可订阅 attr 中项目的索引

版本 1.1 中添加。

引发:

ValueError –

示例

使用 js_link 的此代码

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

等效于以下内容

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

此外，要使用 attr_selector 将范围滑块的左侧连接到绘图的 x_range

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

等效于

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: JSChangeCallback) → None

将 CustomJS 回调附加到任意 BokehJS 模型事件。

在 BokehJS 端，模型属性的更改事件采用 "change:property_name" 的形式。为了方便起见，如果传递给此方法的事件名称也是模型上某个属性的名称，则会自动在其前面加上 "change:"

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

但是，除了属性更改事件之外，还有其他一些有用的事件可以响应。例如，要在一个回调函数中运行数据流式传输到 ColumnDataSource 的事件，请在源上使用 "stream" 事件

source.js_on_change('streaming', callback)

classmethod lookup(name: str, *, raises: bool = True) → PropertyDescriptor[Any] | None

在类中查找给定属性名称的 Bokeh 属性的 PropertyDescriptor。

参数：

• name (str) – 要搜索的属性的名称

• raises (bool) – 如果缺少属性，是否引发异常或返回 None

返回值：

名为 name 的属性的描述符

返回类型：

PropertyDescriptor

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

在此对象上添加一个回调，以便在 attr 发生更改时触发。

参数：

• attr (str) – 此对象上的属性名称

• *callbacks (callable) – 要注册的回调函数

返回值：

无

示例

widget.on_change('value', callback1, callback2, ..., callback_n)

on_event(event: str | type[Event], *callbacks: Callable[[Event], None] | Callable[[], None]) → None

当此模型上发生指定事件时运行回调函数

并非所有模型都支持所有事件。有关哪些模型能够触发事件的更多信息，请参阅bokeh.events中的特定事件。

classmethod parameters() → list[Parameter]

生成适合从 Glyph 派生的函数的 Python Parameter 值。

返回值：

list(Parameter)

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

有效更新特定位置的数据源列

如果只需要更新ColumnDataSource中的一小部分数据，则可以使用此方法有效地仅更新该子集，而不是需要发送整个数据集。

此方法应传递一个字典，该字典将列名映射到描述要应用的补丁更改的元组列表。要完全替换列中的单个项目，元组应采用以下形式

(index, new_value)  # replace a single column value

# or

(slice, new_values) # replace several column values

索引或切片处的值将替换为相应的新的值。

对于其值为其他数组或列表的列（例如图像或补丁 Glyph），也可以修补“子区域”。在这种情况下，元组的第一个项目应为，其第一个元素是 CDS 补丁中数组项目的索引，其后续元素是数组项目中的整数索引或切片

# 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)

假设一个二维 NumPy 数组列表，上面的补丁大致等价于

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

data[2][:, 10] = new_data

可以接受的切片和数据类型有一些限制。

• 切片的负start、stop或step值将导致ValueError。

• 在切片中，start > stop将导致ValueError

• 在修补一维或二维子项时，子项必须是 NumPy 数组。

• 新值必须作为适当大小的**扁平化一维数组**提供。

参数：

patches (dict[str, list[tuple]]) – 每列的补丁列表

返回值：

无

引发:

ValueError –

示例

以下示例显示了如何修补整个列元素。在这种情况下，

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)

此操作后，source.data的值将为

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

有关更全面的示例，请参阅examples/server/app/patch_app.py。

classmethod properties(*, _with_props: bool = False) → set[str] | dict[str, Property[Any]]

收集此类上属性的名称。

警告

在 Bokeh 的未来版本中，此方法将返回一个字典，该字典将属性名称映射到属性对象。为了使此方法的当前用法面向未来，请将返回值包装在list中。

返回值：

属性名称

classmethod properties_with_refs() → dict[str, Property[Any]]

收集此类上所有也具有引用的属性的名称。

此方法始终遍历类层次结构，并包含在任何父类上定义的属性。

返回值：

具有引用的属性的名称

返回类型：

set[str]

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

收集一个将属性名称映射到其值的字典。

此方法始终遍历类层次结构，并包含在任何父类上定义的属性。

不可序列化的属性将被跳过，并且属性值将采用“序列化”格式，这可能与您通常从属性中读取的值略有不同；此方法的目的是返回无损重建对象实例所需的信息。

参数：

include_defaults (bool, 可选) – 是否包含自对象创建以来尚未显式设置的属性。（默认值：True）

返回值：

属性名称与其值的映射

返回类型：

字典

query_properties_with_values(query: Callable[[PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

使用谓词查询HasProps实例的属性值。

参数：

• query (可调用对象) – 一个可调用对象，它接受属性描述符并返回 True 或 False

• include_defaults (bool, 可选) – 是否包含用户未显式设置的属性（默认值：True）

返回值：

匹配属性的属性名称和值的映射

返回类型：

字典

references() → set[Model]

返回此对象引用的所有Models。

remove(name: str) → None

删除一列数据。

参数：

name (str) – 要删除的列的名称

返回值：

无

注意

如果列名不存在，则会发出警告。

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

从此对象中删除回调函数

select(selector: SelectorType) → Iterable[Model]

查询此对象及其所有引用，以查找与给定选择器匹配的对象。

参数：

selector (类似 JSON)

返回值：

seq[Model]

select_one(selector: SelectorType) → Model | None

查询此对象及其所有引用，以查找与给定选择器匹配的对象。如果找到多个对象，则引发错误。返回单个匹配对象，如果未找到任何对象，则返回 None :param selector: :type selector: 类似 JSON

返回值：

模型

set_from_json(name: str, value: Any, *, setter: Setter | None = None) → None

从此对象中的 JSON 设置属性值。

参数：

• name (str) – 要设置的属性的名称

• value (JSON 值) – 要设置为属性的值

• setter (ClientSession 或 ServerSession 或 None, 可选) –

  这用于防止对 Bokeh 应用程序进行“回旋镖”更新。

  在 Bokeh 服务器应用程序的上下文中，属性的传入更新将用进行更新的会话进行注释。此值会通过更新触发的任何后续更改通知进行传播。会话可以将事件设置器与自身进行比较，并抑制任何源自自身的更新。

返回值：

无

set_select(selector: type[Model] | SelectorType, updates: dict[str, Any]) → None

使用指定的属性/值更新来更新与给定选择器匹配的对象。

参数：

• selector (类似 JSON)

• updates (dict)

返回值：

无

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

有效地使用新的追加数据更新数据源列。

在需要更新数据列的情况下，此方法可以有效地仅发送新数据，而不是要求重新发送整个数据集。

参数：

• new_data (dict[str, seq]) –

  列名到要追加到每个列的新数据的序列的映射。

  数据源的所有列都必须出现在 new_data 中，并具有相同长度的追加数据。

• rollover (int, optional) – 最大列大小，超过此大小，列开头的数据将开始被丢弃。如果为 None，则列将无限增长（默认值：None）

返回值：

无

引发:

ValueError –

示例

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() → dict[str, Any] | None

获取任何主题提供的覆盖。

结果作为从属性名称到值的字典返回，如果主题未覆盖此实例的任何值，则返回 None。

返回值：

dict 或 None

to_df() → pd.DataFrame

将此数据源转换为 pandas DataFrame。

返回值：

DataFrame

to_serializable(serializer: Serializer) → ObjectRefRep

将此对象转换为可序列化表示形式。

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

unapply_theme() → None

移除任何主题值并恢复默认值。

返回值：

无

update(**kwargs: Any) → None

根据给定的关键字参数更新对象的属性。

返回值：

无

示例

以下是等效的

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)

property column_names: list[str]

此数据源中列名称的列表。

property document: Document | None

此模型附加到的 Document（可以为 None）