注解

用于各种可以添加到绘图中的注解的渲染器。

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

Bases: CustomDimensional

角度测量的单位。

JSON 原型

{
  "basis": {
    "entries": [
      [
        "\u00b0", 
        [
          1, 
          "^\\circ", 
          "degree"
        ]
      ], 
      [
        "'", 
        [
          0.016666666666666666, 
          "^\\prime", 
          "minute"
        ]
      ], 
      [
        "''", 
        [
          0.0002777777777777778, 
          "^{\\prime\\prime}", 
          "second"
        ]
      ]
    ], 
    "type": "map"
  }, 
  "exclude": [], 
  "id": "p52964", 
  "include": null, 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "name": null, 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": [], 
  "ticks": [
    1, 
    3, 
    6, 
    12, 
    60, 
    120, 
    240, 
    360
  ]
}

basis = {'°': (1, '^\\circ', 'degree'), "'": (0.016666666666666666, '^\\prime', 'minute'), "''": (0.0002777777777777778, '^{\\prime\\prime}', 'second')}

Type:

Required(Dict(String, Either(Tuple(Float, String), Tuple(Float, String, String))))

定义测量单位的基础。

这包括短单位名称与其对应的比例因子、TeX 名称和可选长名称之间的映射。例如，定义角度测量单位的基础是

basis = {
    "°":  (1,      "^\circ",           "degree"),
    "'":  (1/60,   "^\prime",          "minute"),
    "''": (1/3600, "^{\prime\prime}", "second"),
}

exclude = []

Type:

List

要避免的基础单位的子集。

include = None

Type:

Nullable(List)

基础中首选单位的可选子集。

name = None

Type:

Nullable(String)

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

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

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

注意

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

syncable = True

Type:

布尔值

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

注意

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

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

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

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

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

注意

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

ticks = [1, 3, 6, 12, 60, 120, 240, 360]

Type:

Required(List)

在非精确模式下选择的首选值。

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

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

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

参数:

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

返回值:

None

classmethod clear_extensions() → None

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

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

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

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

classmethod dataspecs() → dict[str, DataSpec]

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

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

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

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

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

参数:

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

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

返回值:

None

示例

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

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

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 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]]

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

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

返回值:

具有引用的属性的名称

Return type:

set[str]

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

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

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

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

参数:

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

返回值:

从属性名称到其值的映射

Return type:

dict

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

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

参数:

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

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

返回值:

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

Return type:

dict

references() → set[Model]

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

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

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

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

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

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

返回值:

Model

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

从 JSON 在此对象上设置属性值。

参数:

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

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

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

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

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

返回值:

None

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

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

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

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

返回值:

None

update(**kwargs: Any) → None

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

返回值:

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 Annotation(*args: Any, id: ID | None = None, **kwargs: Any)

基类：CompositeRenderer

所有注释模型的基本类。

注意

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

JSON 原型

{
  "context_menu": null, 
  "coordinates": null, 
  "css_classes": [], 
  "css_variables": {
    "type": "map"
  }, 
  "elements": [], 
  "group": null, 
  "html_attributes": {
    "type": "map"
  }, 
  "html_id": null, 
  "id": "p52972", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "level": "annotation", 
  "name": null, 
  "propagate_hover": false, 
  "renderers": [], 
  "styles": {
    "type": "map"
  }, 
  "stylesheets": [], 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": [], 
  "visible": true, 
  "x_range_name": "default", 
  "y_range_name": "default"
}

context_menu = None

Type:

Nullable(Instance(‘.models.ui.Menu’))

当用户右键单击组件时显示的菜单。

注意

右键单击时使用 shift 键显示原生上下文菜单。

css_classes = []

Type:

List

要添加到底层 DOM 元素的其他 CSS 类列表。

css_variables = {}

Type:

Dict(String, Either(String, Instance(Node)))

允许定义动态计算的 CSS 变量。

例如，这可以用于协调画布渲染器和/或视觉效果与基于 HTML 的 UI 元素之间的定位和样式设置。

此处定义的变量等效于在 CSS 样式表中的 :host { ... } 下设置相同的变量。

注意

此属性是实验性的，随时可能更改。

elements = []

Type:

List

附加到此渲染器的基于 DOM 的 UI 元素集合。

这可以包括浮动元素（如工具提示），从而允许在此渲染器及其 UI 元素之间建立父子关系。

注意

此属性等效于基于 DOM 的 UI 中的 Pane.elements。

group = None

Type:

Nullable(Instance(RendererGroup))

注意

此属性是实验性的，随时可能更改。

html_attributes = {}

Type:

Dict(String, String)

允许在底层 HTML 元素上配置 HTML 属性。

html_id = None

Type:

Nullable(String)

设置底层 HTML 元素的 id 属性。

这是常用 HTML id 属性的简写形式。或者，id 也可以在 html_attributes 字典中设置。html_id 优先。

level = 'annotation'

Type:

Enum(RenderLevel)

指定绘制此渲染器的层级。

name = None

Type:

Nullable(String)

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

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

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

注意

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

propagate_hover = False

Type:

布尔值

允许将悬停事件传播到父级渲染器、框架或画布。

注意

此属性是实验性的，随时可能更改。

renderers = []

Type:

List

附加到此渲染器的一组渲染器。

注意

此属性是实验性的，随时可能更改。

styles = {}

Type:

Either(Dict(String, Nullable(String)), Instance(Styles))

应用于底层 DOM 元素的内联 CSS 样式。

stylesheets = []

Type:

List

用于底层 DOM 元素的其他样式表。

请注意，所有 Bokeh 组件都使用 shadow DOM，因此任何包含的样式表都必须反映这一点，例如，使用 :host CSS 伪选择器来访问根 DOM 元素。

syncable = True

Type:

布尔值

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

注意

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

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

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

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

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

注意

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

visible = True

Type:

布尔值

渲染器是否可见。

x_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）x 轴范围。如果未设置，则使用默认 x 轴范围。

y_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）y 轴范围。如果未设置，则使用默认 y 轴范围。

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

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

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

参数:

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

返回值:

None

classmethod clear_extensions() → None

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

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

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

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

classmethod dataspecs() → dict[str, DataSpec]

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

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

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

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

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

参数:

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

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

返回值:

None

示例

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

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

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 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]]

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

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

返回值:

具有引用的属性的名称

Return type:

set[str]

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

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

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

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

参数:

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

返回值:

从属性名称到其值的映射

Return type:

dict

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

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

参数:

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

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

返回值:

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

Return type:

dict

references() → set[Model]

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

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

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

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

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

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

返回值:

Model

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

从 JSON 在此对象上设置属性值。

参数:

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

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

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

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

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

返回值:

None

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

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

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

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

返回值:

None

update(**kwargs: Any) → None

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

返回值:

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 Arrow(*args: Any, id: ID | None = None, **kwargs: Any)

Bases: DataAnnotation

将箭头渲染为注释。

有关绘制箭头的信息，请参阅 箭头。

JSON 原型

{
  "context_menu": null, 
  "coordinates": null, 
  "css_classes": [], 
  "css_variables": {
    "type": "map"
  }, 
  "elements": [], 
  "end": {
    "id": "p52995", 
    "name": "OpenHead", 
    "type": "object"
  }, 
  "end_units": "data", 
  "group": null, 
  "html_attributes": {
    "type": "map"
  }, 
  "html_id": null, 
  "id": "p52991", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "level": "annotation", 
  "line_alpha": {
    "type": "value", 
    "value": 1.0
  }, 
  "line_cap": {
    "type": "value", 
    "value": "butt"
  }, 
  "line_color": {
    "type": "value", 
    "value": "black"
  }, 
  "line_dash": {
    "type": "value", 
    "value": []
  }, 
  "line_dash_offset": {
    "type": "value", 
    "value": 0
  }, 
  "line_join": {
    "type": "value", 
    "value": "bevel"
  }, 
  "line_width": {
    "type": "value", 
    "value": 1
  }, 
  "name": null, 
  "propagate_hover": false, 
  "renderers": [], 
  "source": {
    "attributes": {
      "data": {
        "type": "map"
      }, 
      "selected": {
        "attributes": {
          "indices": [], 
          "line_indices": []
        }, 
        "id": "p52993", 
        "name": "Selection", 
        "type": "object"
      }, 
      "selection_policy": {
        "id": "p52994", 
        "name": "UnionRenderers", 
        "type": "object"
      }
    }, 
    "id": "p52992", 
    "name": "ColumnDataSource", 
    "type": "object"
  }, 
  "start": null, 
  "start_units": "data", 
  "styles": {
    "type": "map"
  }, 
  "stylesheets": [], 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": [], 
  "visible": true, 
  "x_end": {
    "field": "x_end", 
    "type": "field"
  }, 
  "x_range_name": "default", 
  "x_start": {
    "field": "x_start", 
    "type": "field"
  }, 
  "y_end": {
    "field": "y_end", 
    "type": "field"
  }, 
  "y_range_name": "default", 
  "y_start": {
    "field": "y_start", 
    "type": "field"
  }
}

context_menu = None

Type:

Nullable(Instance(‘.models.ui.Menu’))

当用户右键单击组件时显示的菜单。

注意

右键单击时使用 shift 键显示原生上下文菜单。

css_classes = []

Type:

List

要添加到底层 DOM 元素的其他 CSS 类列表。

css_variables = {}

Type:

Dict(String, Either(String, Instance(Node)))

允许定义动态计算的 CSS 变量。

例如，这可以用于协调画布渲染器和/或视觉效果与基于 HTML 的 UI 元素之间的定位和样式设置。

此处定义的变量等效于在 CSS 样式表中的 :host { ... } 下设置相同的变量。

注意

此属性是实验性的，随时可能更改。

elements = []

Type:

List

附加到此渲染器的基于 DOM 的 UI 元素集合。

这可以包括浮动元素（如工具提示），从而允许在此渲染器及其 UI 元素之间建立父子关系。

注意

此属性等效于基于 DOM 的 UI 中的 Pane.elements。

end = OpenHead(id='p53021', ...)

Type:

Nullable(Instance(ArrowHead))

ArrowHead 的实例。

end_units = 'data'

Type:

Enum(CoordinateUnits)

end_x 和 end_y 属性的单位类型。默认解释为“数据空间”单位。

group = None

Type:

Nullable(Instance(RendererGroup))

注意

此属性是实验性的，随时可能更改。

html_attributes = {}

Type:

Dict(String, String)

允许在底层 HTML 元素上配置 HTML 属性。

html_id = None

Type:

Nullable(String)

设置底层 HTML 元素的 id 属性。

这是常用 HTML id 属性的简写形式。或者，id 也可以在 html_attributes 字典中设置。html_id 优先。

level = 'annotation'

Type:

Enum(RenderLevel)

指定绘制此渲染器的层级。

line_alpha = 1.0

Type:

AlphaSpec

箭头主体的线条 alpha 值。

line_cap = 'butt'

Type:

LineCapSpec

箭头主体的线帽值。

line_color = 'black'

Type:

ColorSpec

箭头主体的线条颜色值。

line_dash = []

Type:

DashPatternSpec

箭头主体的线条虚线值。

line_dash_offset = 0

Type:

IntSpec

箭头主体的线条虚线偏移值。

line_join = 'bevel'

Type:

LineJoinSpec

箭头主体的线条连接值。

line_width = 1

Type:

FloatSpec

箭头主体的线条宽度值。

name = None

Type:

Nullable(String)

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

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

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

注意

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

propagate_hover = False

Type:

布尔值

允许将悬停事件传播到父级渲染器、框架或画布。

注意

此属性是实验性的，随时可能更改。

renderers = []

Type:

List

附加到此渲染器的一组渲染器。

注意

此属性是实验性的，随时可能更改。

source = ColumnDataSource(id='p53102', ...)

Type:

Instance(DataSource)

用于在绘图上渲染注释的本地数据源。

start = None

Type:

Nullable(Instance(ArrowHead))

ArrowHead 的实例。

start_units = 'data'

Type:

Enum(CoordinateUnits)

start_x 和 start_y 属性的单位类型。默认解释为“数据空间”单位。

styles = {}

Type:

Either(Dict(String, Nullable(String)), Instance(Styles))

应用于底层 DOM 元素的内联 CSS 样式。

stylesheets = []

Type:

List

用于底层 DOM 元素的其他样式表。

请注意，所有 Bokeh 组件都使用 shadow DOM，因此任何包含的样式表都必须反映这一点，例如，使用 :host CSS 伪选择器来访问根 DOM 元素。

syncable = True

Type:

布尔值

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

注意

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

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

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

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

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

注意

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

visible = True

Type:

布尔值

渲染器是否可见。

x_end = Field(field='x_end', transform=Unspecified, units=Unspecified)

Type:

NumberSpec

用于定位箭头末端的 x 坐标。

x_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）x 轴范围。如果未设置，则使用默认 x 轴范围。

x_start = Field(field='x_start', transform=Unspecified, units=Unspecified)

Type:

NumberSpec

用于定位箭头起点的 x 坐标。

y_end = Field(field='y_end', transform=Unspecified, units=Unspecified)

Type:

NumberSpec

用于定位箭头末端的 y 坐标。

y_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）y 轴范围。如果未设置，则使用默认 y 轴范围。

y_start = Field(field='y_start', transform=Unspecified, units=Unspecified)

Type:

NumberSpec

用于定位箭头起点的 y 坐标。

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

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

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

参数:

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

返回值:

None

classmethod clear_extensions() → None

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

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

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

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

classmethod dataspecs() → dict[str, DataSpec]

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

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

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

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

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

参数:

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

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

返回值:

None

示例

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

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

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 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]]

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

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

返回值:

具有引用的属性的名称

Return type:

set[str]

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

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

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

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

参数:

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

返回值:

从属性名称到其值的映射

Return type:

dict

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

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

参数:

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

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

返回值:

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

Return type:

dict

references() → set[Model]

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

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

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

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

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

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

返回值:

Model

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

从 JSON 在此对象上设置属性值。

参数:

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

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

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

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

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

返回值:

None

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

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

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

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

返回值:

None

update(**kwargs: Any) → None

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

返回值:

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 ArrowHead(*args: Any, id: ID | None = None, **kwargs: Any)

Bases: Marking

箭头箭头的基类。

注意

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

JSON 原型

{
  "id": "p53170", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "name": null, 
  "size": {
    "type": "value", 
    "value": 25
  }, 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": []
}

name = None

Type:

Nullable(String)

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

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

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

注意

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

size = 25

Type:

NumberSpec

箭头箭头的大小，以像素为单位。

syncable = True

Type:

布尔值

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

注意

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

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

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

>>> r = plot.scatter([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) – 用于代替默认值的主题值

返回值:

None

classmethod clear_extensions() → None

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

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

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

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

classmethod dataspecs() → dict[str, DataSpec]

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

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

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

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

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

参数:

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

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

返回值:

None

示例

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

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

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 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]]

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

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

返回值:

具有引用的属性的名称

Return type:

set[str]

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

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

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

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

参数:

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

返回值:

从属性名称到其值的映射

Return type:

dict

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

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

参数:

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

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

返回值:

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

Return type:

dict

references() → set[Model]

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

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

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

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

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

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

返回值:

Model

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

从 JSON 在此对象上设置属性值。

参数:

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

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

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

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

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

返回值:

None

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

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

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

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

返回值:

None

update(**kwargs: Any) → None

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

返回值:

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 Band(*args: Any, id: ID | None = None, **kwargs: Any)

Bases: DataAnnotation

沿维度渲染填充区域带。

有关绘制带的信息，请参阅 带 (Bands)。

JSON 原型

{
  "base": {
    "field": "base", 
    "type": "field"
  }, 
  "context_menu": null, 
  "coordinates": null, 
  "css_classes": [], 
  "css_variables": {
    "type": "map"
  }, 
  "dimension": "height", 
  "elements": [], 
  "fill_alpha": 0.4, 
  "fill_color": "#fff9ba", 
  "group": null, 
  "hatch_alpha": 1.0, 
  "hatch_color": "black", 
  "hatch_extra": {
    "type": "map"
  }, 
  "hatch_pattern": null, 
  "hatch_scale": 12.0, 
  "hatch_weight": 1.0, 
  "html_attributes": {
    "type": "map"
  }, 
  "html_id": null, 
  "id": "p53175", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "level": "annotation", 
  "line_alpha": 0.3, 
  "line_cap": "butt", 
  "line_color": "#cccccc", 
  "line_dash": [], 
  "line_dash_offset": 0, 
  "line_join": "bevel", 
  "line_width": 1, 
  "lower": {
    "field": "lower", 
    "type": "field"
  }, 
  "name": null, 
  "propagate_hover": false, 
  "renderers": [], 
  "source": {
    "attributes": {
      "data": {
        "type": "map"
      }, 
      "selected": {
        "attributes": {
          "indices": [], 
          "line_indices": []
        }, 
        "id": "p53177", 
        "name": "Selection", 
        "type": "object"
      }, 
      "selection_policy": {
        "id": "p53178", 
        "name": "UnionRenderers", 
        "type": "object"
      }
    }, 
    "id": "p53176", 
    "name": "ColumnDataSource", 
    "type": "object"
  }, 
  "styles": {
    "type": "map"
  }, 
  "stylesheets": [], 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": [], 
  "upper": {
    "field": "upper", 
    "type": "field"
  }, 
  "visible": true, 
  "x_range_name": "default", 
  "y_range_name": "default"
}

base = Field(field='base', transform=Unspecified, units=Unspecified)

Type:

单位规格

上值和下值的正交坐标。

base_units = 'data'

Type:

NotSerialized(Enum(CoordinateUnits))

用于关联属性的单位：canvas、screen 或 data

context_menu = None

Type:

Nullable(Instance(‘.models.ui.Menu’))

当用户右键单击组件时显示的菜单。

注意

右键单击时使用 shift 键显示原生上下文菜单。

css_classes = []

Type:

List

要添加到底层 DOM 元素的其他 CSS 类列表。

css_variables = {}

Type:

Dict(String, Either(String, Instance(Node)))

允许定义动态计算的 CSS 变量。

例如，这可以用于协调画布渲染器和/或视觉效果与基于 HTML 的 UI 元素之间的定位和样式设置。

此处定义的变量等效于在 CSS 样式表中的 :host { ... } 下设置相同的变量。

注意

此属性是实验性的，随时可能更改。

dimension = 'height'

Type:

Enum(Dimension)

可以通过将此属性设置为 “height”（y 方向）或 “width”（x 方向）来指定带的方向。

elements = []

Type:

List

附加到此渲染器的基于 DOM 的 UI 元素集合。

这可以包括浮动元素（如工具提示），从而允许在此渲染器及其 UI 元素之间建立父子关系。

注意

此属性等效于基于 DOM 的 UI 中的 Pane.elements。

fill_alpha = 0.4

Type:

Alpha（透明度）

带的填充透明度值。

fill_color = '#fff9ba'

Type:

Nullable(Color)

带的填充颜色值。

group = None

Type:

Nullable(Instance(RendererGroup))

注意

此属性是实验性的，随时可能更改。

hatch_alpha = 1.0

Type:

Alpha（透明度）

带的阴影线透明度值。

hatch_color = 'black'

Type:

Nullable(Color)

带的阴影线颜色值。

hatch_extra = {}

Type:

Dict(String, Instance(Texture))

带的额外阴影线值。

hatch_pattern = None

Type:

Nullable(String)

带的阴影线图案值。

hatch_scale = 12.0

Type:

尺寸

带的阴影线比例值。

hatch_weight = 1.0

Type:

尺寸

带的阴影线粗细值。

html_attributes = {}

Type:

Dict(String, String)

允许在底层 HTML 元素上配置 HTML 属性。

html_id = None

Type:

Nullable(String)

设置底层 HTML 元素的 id 属性。

这是常用 HTML id 属性的简写形式。或者，id 也可以在 html_attributes 字典中设置。html_id 优先。

level = 'annotation'

Type:

Enum(RenderLevel)

指定绘制此渲染器的层级。

line_alpha = 0.3

Type:

Alpha（透明度）

带的线条透明度值。

line_cap = 'butt'

Type:

Enum(LineCap)

带的线帽值。

line_color = '#cccccc'

Type:

Nullable(Color)

带的线条颜色值。

line_dash = []

Type:

虚线模式

带的线条虚线值。

line_dash_offset = 0

Type:

整数

带的线条虚线偏移值。

line_join = 'bevel'

Type:

Enum(LineJoin)

带的线条连接值。

line_width = 1

Type:

浮点数

带的线宽值。

lower = Field(field='lower', transform=Unspecified, units=Unspecified)

Type:

单位规格

填充区域带下部分的坐标。

lower_units = 'data'

Type:

NotSerialized(Enum(CoordinateUnits))

用于关联属性的单位：canvas、screen 或 data

name = None

Type:

Nullable(String)

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

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

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

注意

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

propagate_hover = False

Type:

布尔值

允许将悬停事件传播到父级渲染器、框架或画布。

注意

此属性是实验性的，随时可能更改。

renderers = []

Type:

List

附加到此渲染器的一组渲染器。

注意

此属性是实验性的，随时可能更改。

source = ColumnDataSource(id='p53307', ...)

Type:

Instance(DataSource)

用于在绘图上渲染注释的本地数据源。

styles = {}

Type:

Either(Dict(String, Nullable(String)), Instance(Styles))

应用于底层 DOM 元素的内联 CSS 样式。

stylesheets = []

Type:

List

用于底层 DOM 元素的其他样式表。

请注意，所有 Bokeh 组件都使用 shadow DOM，因此任何包含的样式表都必须反映这一点，例如，使用 :host CSS 伪选择器来访问根 DOM 元素。

syncable = True

Type:

布尔值

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

注意

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

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

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

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

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

注意

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

upper = Field(field='upper', transform=Unspecified, units=Unspecified)

Type:

单位规格

填充区域带上部分的坐标。

upper_units = 'data'

Type:

NotSerialized(Enum(CoordinateUnits))

用于关联属性的单位：canvas、screen 或 data

visible = True

Type:

布尔值

渲染器是否可见。

x_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）x 轴范围。如果未设置，则使用默认 x 轴范围。

y_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）y 轴范围。如果未设置，则使用默认 y 轴范围。

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

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

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

参数:

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

返回值:

None

classmethod clear_extensions() → None

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

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

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

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

classmethod dataspecs() → dict[str, DataSpec]

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

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

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

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

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

参数:

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

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

返回值:

None

示例

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

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

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 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]]

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

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

返回值:

具有引用的属性的名称

Return type:

set[str]

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

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

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

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

参数:

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

返回值:

从属性名称到其值的映射

Return type:

dict

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

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

参数:

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

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

返回值:

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

Return type:

dict

references() → set[Model]

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

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

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

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

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

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

返回值:

Model

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

从 JSON 在此对象上设置属性值。

参数:

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

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

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

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

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

返回值:

None

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

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

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

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

返回值:

None

update(**kwargs: Any) → None

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

返回值:

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 BoxAnnotation(*args: Any, id: ID | None = None, **kwargs: Any)

基类： Annotation, AreaVisuals

将阴影矩形区域渲染为注释。

有关绘制框注释的信息，请参阅 框注释 。

JSON 原型

{
  "border_radius": 0, 
  "bottom": {
    "attributes": {
      "symbol": "bottom", 
      "target": "frame"
    }, 
    "id": "p53350", 
    "name": "Node", 
    "type": "object"
  }, 
  "bottom_limit": null, 
  "bottom_units": "data", 
  "context_menu": null, 
  "coordinates": null, 
  "css_classes": [], 
  "css_variables": {
    "type": "map"
  }, 
  "editable": false, 
  "elements": [], 
  "fill_alpha": 0.4, 
  "fill_color": "#fff9ba", 
  "group": null, 
  "handles": {
    "attributes": {
      "all": {
        "attributes": {
          "fill_color": "white", 
          "hover_fill_color": "lightgray"
        }, 
        "id": "p53351", 
        "name": "AreaVisuals", 
        "type": "object"
      }
    }, 
    "id": "p53352", 
    "name": "BoxInteractionHandles", 
    "type": "object"
  }, 
  "hatch_alpha": 1.0, 
  "hatch_color": "black", 
  "hatch_extra": {
    "type": "map"
  }, 
  "hatch_pattern": null, 
  "hatch_scale": 12.0, 
  "hatch_weight": 1.0, 
  "hover_fill_alpha": 0.4, 
  "hover_fill_color": null, 
  "hover_hatch_alpha": 1.0, 
  "hover_hatch_color": "black", 
  "hover_hatch_extra": {
    "type": "map"
  }, 
  "hover_hatch_pattern": null, 
  "hover_hatch_scale": 12.0, 
  "hover_hatch_weight": 1.0, 
  "hover_line_alpha": 0.3, 
  "hover_line_cap": "butt", 
  "hover_line_color": null, 
  "hover_line_dash": [], 
  "hover_line_dash_offset": 0, 
  "hover_line_join": "bevel", 
  "hover_line_width": 1, 
  "html_attributes": {
    "type": "map"
  }, 
  "html_id": null, 
  "id": "p53346", 
  "inverted": false, 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "left": {
    "attributes": {
      "symbol": "left", 
      "target": "frame"
    }, 
    "id": "p53347", 
    "name": "Node", 
    "type": "object"
  }, 
  "left_limit": null, 
  "left_units": "data", 
  "level": "annotation", 
  "line_alpha": 0.3, 
  "line_cap": "butt", 
  "line_color": "#cccccc", 
  "line_dash": [], 
  "line_dash_offset": 0, 
  "line_join": "bevel", 
  "line_width": 1, 
  "max_height": {
    "type": "number", 
    "value": "+inf"
  }, 
  "max_width": {
    "type": "number", 
    "value": "+inf"
  }, 
  "min_height": 0, 
  "min_width": 0, 
  "movable": "both", 
  "name": null, 
  "propagate_hover": false, 
  "renderers": [], 
  "resizable": "all", 
  "right": {
    "attributes": {
      "symbol": "right", 
      "target": "frame"
    }, 
    "id": "p53348", 
    "name": "Node", 
    "type": "object"
  }, 
  "right_limit": null, 
  "right_units": "data", 
  "styles": {
    "type": "map"
  }, 
  "stylesheets": [], 
  "subscribed_events": {
    "type": "set"
  }, 
  "symmetric": false, 
  "syncable": true, 
  "tags": [], 
  "top": {
    "attributes": {
      "symbol": "top", 
      "target": "frame"
    }, 
    "id": "p53349", 
    "name": "Node", 
    "type": "object"
  }, 
  "top_limit": null, 
  "top_units": "data", 
  "use_handles": false, 
  "visible": true, 
  "x_range_name": "default", 
  "y_range_name": "default"
}

border_radius = 0

Type:

Either(NonNegative, Tuple(NonNegative, NonNegative, NonNegative, NonNegative), Struct)

允许框具有圆角。

注意

此属性是实验性的，随时可能更改。

bottom = Node(id='p53367', ...)

Type:

Either(Either(Float, Datetime, Factor), Instance(Node))

框注释底边的 y 坐标。

bottom_limit = None

Type:

Nullable(Either(Either(Float, Datetime, Factor), Instance(Node)))

框移动的可选底部限制。

注意

此属性是实验性的，随时可能更改。

bottom_units = 'data'

Type:

Enum(CoordinateUnits)

底部属性的单位类型。默认解释为 数据单位 。如果 bottom 是一个节点，则这没有任何效果。

context_menu = None

Type:

Nullable(Instance(‘.models.ui.Menu’))

当用户右键单击组件时显示的菜单。

注意

右键单击时使用 shift 键显示原生上下文菜单。

css_classes = []

Type:

List

要添加到底层 DOM 元素的其他 CSS 类列表。

css_variables = {}

Type:

Dict(String, Either(String, Instance(Node)))

允许定义动态计算的 CSS 变量。

例如，这可以用于协调画布渲染器和/或视觉效果与基于 HTML 的 UI 元素之间的定位和样式设置。

此处定义的变量等效于在 CSS 样式表中的 :host { ... } 下设置相同的变量。

注意

此属性是实验性的，随时可能更改。

editable = False

Type:

布尔值

允许交互式修改此框的几何形状。

注意

此属性是实验性的，随时可能更改。

elements = []

Type:

List

附加到此渲染器的基于 DOM 的 UI 元素集合。

这可以包括浮动元素（如工具提示），从而允许在此渲染器及其 UI 元素之间建立父子关系。

注意

此属性等效于基于 DOM 的 UI 中的 Pane.elements。

fill_alpha = 0.4

Type:

Alpha（透明度）

框的填充 alpha 值。

fill_color = '#fff9ba'

Type:

Nullable(Color)

框的填充颜色值。

group = None

Type:

Nullable(Instance(RendererGroup))

注意

此属性是实验性的，随时可能更改。

handles = BoxInteractionHandles(id='p53446', ...)

Type:

Instance(BoxInteractionHandles)

配置交互手柄的外观。

手柄可以按特异性递增的级别批量配置，其中每个级别（如果已定义）都会覆盖更通用的设置

• all -> move, resize

• resize -> sides, corners

• sides -> left, right, top, bottom

• corners -> top_left, top_right, bottom_left, bottom_right

注意

此属性是实验性的，随时可能更改。

hatch_alpha = 1.0

Type:

Alpha（透明度）

框的阴影线 alpha 值。

hatch_color = 'black'

Type:

Nullable(Color)

框的阴影线颜色值。

hatch_extra = {}

Type:

Dict(String, Instance(Texture))

框的阴影线额外值。

hatch_pattern = None

Type:

Nullable(String)

框的阴影线图案值。

hatch_scale = 12.0

Type:

尺寸

框的阴影线比例值。

hatch_weight = 1.0

Type:

尺寸

框的阴影线粗细值。

hover_fill_alpha = 0.4

Type:

Alpha（透明度）

悬停在框上时框的填充 alpha 值。

hover_fill_color = None

Type:

Nullable(Color)

悬停在框上时框的填充颜色值。

hover_hatch_alpha = 1.0

Type:

Alpha（透明度）

悬停在框上时框的阴影线 alpha 值。

hover_hatch_color = 'black'

Type:

Nullable(Color)

悬停在框上时框的阴影线颜色值。

hover_hatch_extra = {}

Type:

Dict(String, Instance(Texture))

悬停在框上时，框的阴影线额外值。

hover_hatch_pattern = None

Type:

Nullable(String)

悬停在框上时，框的阴影线图案值。

hover_hatch_scale = 12.0

Type:

尺寸

悬停在框上时，框的阴影线比例值。

hover_hatch_weight = 1.0

Type:

尺寸

悬停在框上时，框的阴影线粗细值。

hover_line_alpha = 0.3

Type:

Alpha（透明度）

悬停在框上时，框的线条 alpha 值。

hover_line_cap = 'butt'

Type:

Enum(LineCap)

悬停在框上时，框的线条端帽值。

hover_line_color = None

Type:

Nullable(Color)

悬停在框上时，框的线条颜色值。

hover_line_dash = []

Type:

虚线模式

悬停在框上时，框的线条虚线值。

hover_line_dash_offset = 0

Type:

整数

悬停在框上时，框的线条虚线偏移值。

hover_line_join = 'bevel'

Type:

Enum(LineJoin)

悬停在框上时，框的线条连接值。

hover_line_width = 1

Type:

浮点数

悬停在框上时，框的线条宽度值。

html_attributes = {}

Type:

Dict(String, String)

允许在底层 HTML 元素上配置 HTML 属性。

html_id = None

Type:

Nullable(String)

设置底层 HTML 元素的 id 属性。

这是常用 HTML id 属性的简写形式。或者，id 也可以在 html_attributes 字典中设置。html_id 优先。

inverted = False

Type:

布尔值

反转框的几何形状，即对外侧而不是内侧应用填充和阴影线视觉效果。视觉效果应用于框与其父级之间，例如框架。

left = Node(id='p53622', ...)

Type:

Either(Either(Float, Datetime, Factor), Instance(Node))

框注释左边缘的 x 坐标。

left_limit = None

Type:

Nullable(Either(Either(Float, Datetime, Factor), Instance(Node)))

框移动的可选左侧限制。

注意

此属性是实验性的，随时可能更改。

left_units = 'data'

Type:

Enum(CoordinateUnits)

left 属性的单位类型。默认情况下解释为数据单位。如果 left 是节点，则此项无效。

level = 'annotation'

Type:

Enum(RenderLevel)

指定绘制此渲染器的层级。

line_alpha = 0.3

Type:

Alpha（透明度）

框的线条 alpha 值。

line_cap = 'butt'

Type:

Enum(LineCap)

框的线条端帽值。

line_color = '#cccccc'

Type:

Nullable(Color)

框的线条颜色值。

line_dash = []

Type:

虚线模式

框的线条虚线值。

line_dash_offset = 0

Type:

整数

框的线条虚线偏移值。

line_join = 'bevel'

Type:

Enum(LineJoin)

框的线条连接值。

line_width = 1

Type:

浮点数

框的线条宽度值。

max_height = inf

Type:

正值

允许设置框的最大高度。

注意

此属性是实验性的，随时可能更改。

max_width = inf

Type:

正值

允许设置框的最小高度。

注意

此属性是实验性的，随时可能更改。

min_height = 0

Type:

非负值

允许设置框的最大宽度。

注意

此属性是实验性的，随时可能更改。

min_width = 0

Type:

非负值

允许设置框的最小宽度。

注意

此属性是实验性的，随时可能更改。

movable = 'both'

Type:

Enum(Movable)

如果设置了 editable，则此属性允许配置框可以移动的方向。

注意

此属性是实验性的，随时可能更改。

name = None

Type:

Nullable(String)

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

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

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

注意

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

propagate_hover = False

Type:

布尔值

允许将悬停事件传播到父级渲染器、框架或画布。

注意

此属性是实验性的，随时可能更改。

renderers = []

Type:

List

附加到此渲染器的一组渲染器。

注意

此属性是实验性的，随时可能更改。

resizable = 'all'

Type:

Enum(Resizable)

如果设置了 editable，则此属性允许配置允许移动哪些边缘组合，从而允许限制框的大小调整。

注意

此属性是实验性的，随时可能更改。

right = Node(id='p53763', ...)

Type:

Either(Either(Float, Datetime, Factor), Instance(Node))

框注释右边缘的 x 坐标。

right_limit = None

Type:

Nullable(Either(Either(Float, Datetime, Factor), Instance(Node)))

框移动的可选右侧限制。

注意

此属性是实验性的，随时可能更改。

right_units = 'data'

Type:

Enum(CoordinateUnits)

right 属性的单位类型。默认情况下解释为数据单位。如果 right 是节点，则此项无效。

styles = {}

Type:

Either(Dict(String, Nullable(String)), Instance(Styles))

应用于底层 DOM 元素的内联 CSS 样式。

stylesheets = []

Type:

List

用于底层 DOM 元素的其他样式表。

请注意，所有 Bokeh 组件都使用 shadow DOM，因此任何包含的样式表都必须反映这一点，例如，使用 :host CSS 伪选择器来访问根 DOM 元素。

symmetric = False

Type:

布尔值

指示框是否可以围绕其中心或角调整大小。

注意

此属性是实验性的，随时可能更改。

syncable = True

Type:

布尔值

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

注意

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

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

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

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

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

注意

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

top = Node(id='p53820', ...)

Type:

Either(Either(Float, Datetime, Factor), Instance(Node))

框注释顶边缘的 y 坐标。

top_limit = None

Type:

Nullable(Either(Either(Float, Datetime, Factor), Instance(Node)))

框移动的可选顶部限制。

注意

此属性是实验性的，随时可能更改。

top_units = 'data'

Type:

Enum(CoordinateUnits)

top 属性的单位类型。默认情况下解释为数据单位。如果 top 是节点，则此项无效。

use_handles = False

Type:

布尔值

是否显示交互（移动、调整大小等）手柄。

如果不使用手柄，则整个注释、其边框和角都充当交互手柄。

注意

此属性是实验性的，随时可能更改。

visible = True

Type:

布尔值

渲染器是否可见。

x_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）x 轴范围。如果未设置，则使用默认 x 轴范围。

y_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）y 轴范围。如果未设置，则使用默认 y 轴范围。

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

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

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

参数:

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

返回值:

None

classmethod clear_extensions() → None

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

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

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

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

classmethod dataspecs() → dict[str, DataSpec]

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

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

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

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

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

参数:

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

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

返回值:

None

示例

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

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

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 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]]

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

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

返回值:

具有引用的属性的名称

Return type:

set[str]

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

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

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

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

参数:

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

返回值:

从属性名称到其值的映射

Return type:

dict

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

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

参数:

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

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

返回值:

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

Return type:

dict

references() → set[Model]

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

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

从此对象中删除回调

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

参数:

selector (JSON-like)

返回值:

seq[Model]

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

返回值:

Model

从 JSON 在此对象上设置属性值。

参数:

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

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

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

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

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

返回值:

None

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

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

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

返回值:

dict 或 None

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

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

返回值:

None

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

返回值:

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 (可以为 None)

基类: Model

定义了框状注释的交互句柄。

JSON 原型

{
  "all": {
    "name": "unset", 
    "type": "symbol"
  }, 
  "bottom": null, 
  "bottom_left": null, 
  "bottom_right": null, 
  "corners": null, 
  "id": "p53863", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "left": null, 
  "move": null, 
  "name": null, 
  "resize": null, 
  "right": null, 
  "sides": null, 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": [], 
  "top": null, 
  "top_left": null, 
  "top_right": null
}

Type:

Nullable(String)

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

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

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

注意

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

Type:

布尔值

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

注意

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

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

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

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

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

注意

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

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

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

参数:

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

返回值:

None

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

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

复制一个 HasProps 对象。

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

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

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

返回值:

DataSpec 属性的名称

Return type:

set[str]

属性描述符列表，按定义顺序排列。

清理对文档和属性的引用

模型的结构相等性。

参数:

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

返回值:

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

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

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

参数:

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

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

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

• attr_selector (int | str) – 用于链接可下标 attr 中项目的索引

Added in version 1.1

Raises:

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)

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]"
    )
)

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

给定属性名称，查找类上 Bokeh 属性的 PropertyDescriptor。

参数:

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

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

返回值:

名为 name 的属性的描述符

Return type:

PropertyDescriptor

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

参数:

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

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

返回值:

None

示例

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

在此 Model 上指定的事件发生时运行回调

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

生成适用于从 glyph 派生的函数的 Python Parameter 值。

返回值:

list(Parameter)

收集此类上的属性名称。

警告

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

返回值:

属性名称

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

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

返回值:

具有引用的属性的名称

Return type:

set[str]

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

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

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

参数:

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

返回值:

从属性名称到其值的映射

Return type:

dict

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

参数:

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

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

返回值:

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

Return type:

dict

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

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

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

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

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

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

返回值:

Model

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

从 JSON 在此对象上设置属性值。

参数:

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

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

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

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

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

返回值:

None

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

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

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

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

返回值:

None

update(**kwargs: Any) → None

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

返回值:

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 ColorBar(*args: Any, id: ID | None = None, **kwargs: Any)

Bases: BaseColorBar

渲染基于颜色映射器的颜色栏。

有关绘制颜色栏的信息，请参阅颜色栏。

JSON 原型

{
  "background_fill_alpha": 0.95, 
  "background_fill_color": "#ffffff", 
  "background_hatch_alpha": 1.0, 
  "background_hatch_color": "black", 
  "background_hatch_extra": {
    "type": "map"
  }, 
  "background_hatch_pattern": null, 
  "background_hatch_scale": 12.0, 
  "background_hatch_weight": 1.0, 
  "bar_line_alpha": 1.0, 
  "bar_line_cap": "butt", 
  "bar_line_color": null, 
  "bar_line_dash": [], 
  "bar_line_dash_offset": 0, 
  "bar_line_join": "bevel", 
  "bar_line_width": 1, 
  "border_line_alpha": 1.0, 
  "border_line_cap": "butt", 
  "border_line_color": null, 
  "border_line_dash": [], 
  "border_line_dash_offset": 0, 
  "border_line_join": "bevel", 
  "border_line_width": 1, 
  "color_mapper": {
    "name": "unset", 
    "type": "symbol"
  }, 
  "context_menu": null, 
  "coordinates": null, 
  "css_classes": [], 
  "css_variables": {
    "type": "map"
  }, 
  "display_high": null, 
  "display_low": null, 
  "elements": [], 
  "formatter": "auto", 
  "group": null, 
  "height": "auto", 
  "html_attributes": {
    "type": "map"
  }, 
  "html_id": null, 
  "id": "p53867", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "label_standoff": 5, 
  "level": "annotation", 
  "location": "top_right", 
  "major_label_overrides": {
    "type": "map"
  }, 
  "major_label_policy": {
    "id": "p53868", 
    "name": "NoOverlap", 
    "type": "object"
  }, 
  "major_label_text_align": "left", 
  "major_label_text_alpha": 1.0, 
  "major_label_text_baseline": "bottom", 
  "major_label_text_color": "#444444", 
  "major_label_text_font": "helvetica", 
  "major_label_text_font_size": "11px", 
  "major_label_text_font_style": "normal", 
  "major_label_text_line_height": 1.2, 
  "major_label_text_outline_color": null, 
  "major_tick_in": 5, 
  "major_tick_line_alpha": 1.0, 
  "major_tick_line_cap": "butt", 
  "major_tick_line_color": "#ffffff", 
  "major_tick_line_dash": [], 
  "major_tick_line_dash_offset": 0, 
  "major_tick_line_join": "bevel", 
  "major_tick_line_width": 1, 
  "major_tick_out": 0, 
  "margin": 30, 
  "minor_tick_in": 0, 
  "minor_tick_line_alpha": 1.0, 
  "minor_tick_line_cap": "butt", 
  "minor_tick_line_color": null, 
  "minor_tick_line_dash": [], 
  "minor_tick_line_dash_offset": 0, 
  "minor_tick_line_join": "bevel", 
  "minor_tick_line_width": 1, 
  "minor_tick_out": 0, 
  "name": null, 
  "orientation": "auto", 
  "padding": 10, 
  "propagate_hover": false, 
  "renderers": [], 
  "scale_alpha": 1.0, 
  "styles": {
    "type": "map"
  }, 
  "stylesheets": [], 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": [], 
  "ticker": "auto", 
  "title": null, 
  "title_standoff": 2, 
  "title_text_align": "left", 
  "title_text_alpha": 1.0, 
  "title_text_baseline": "bottom", 
  "title_text_color": "#444444", 
  "title_text_font": "helvetica", 
  "title_text_font_size": "13px", 
  "title_text_font_style": "italic", 
  "title_text_line_height": 1.2, 
  "title_text_outline_color": null, 
  "visible": true, 
  "width": "auto", 
  "x_range_name": "default", 
  "y_range_name": "default"
}

background_fill_alpha = 0.95

Type:

Alpha（透明度）

颜色栏背景样式的填充 alpha 值。

background_fill_color = '#ffffff'

Type:

Nullable(Color)

颜色栏背景样式的填充颜色。

background_hatch_alpha = 1.0

Type:

Alpha（透明度）

颜色栏背景样式的阴影线 alpha 值。

background_hatch_color = 'black'

Type:

Nullable(Color)

颜色栏背景样式的阴影线颜色。

background_hatch_extra = {}

Type:

Dict(String, Instance(Texture))

颜色栏背景样式的额外阴影线属性。

background_hatch_pattern = None

Type:

Nullable(String)

颜色栏背景样式的阴影线图案。

background_hatch_scale = 12.0

Type:

尺寸

颜色栏背景样式的阴影线比例。

background_hatch_weight = 1.0

Type:

尺寸

颜色栏背景样式的阴影线粗细。

bar_line_alpha = 1.0

Type:

Alpha（透明度）

颜色刻度栏轮廓的线条 alpha 值。

bar_line_cap = 'butt'

Type:

Enum(LineCap)

颜色刻度栏轮廓的线帽样式。

bar_line_color = None

Type:

Nullable(Color)

颜色刻度栏轮廓的线条颜色。

bar_line_dash = []

Type:

虚线模式

颜色刻度栏轮廓的线段虚线模式。

bar_line_dash_offset = 0

Type:

整数

颜色刻度栏轮廓的线段虚线偏移。

bar_line_join = 'bevel'

Type:

Enum(LineJoin)

颜色刻度栏轮廓的线段连接样式。

bar_line_width = 1

Type:

浮点数

颜色刻度栏轮廓的线条宽度。

border_line_alpha = 1.0

Type:

Alpha（透明度）

颜色栏边框轮廓的线条 alpha 值。

border_line_cap = 'butt'

Type:

Enum(LineCap)

颜色栏边框轮廓的线帽样式。

border_line_color = None

Type:

Nullable(Color)

颜色栏边框轮廓的线条颜色。

border_line_dash = []

Type:

虚线模式

颜色栏边框轮廓的线段虚线模式。

border_line_dash_offset = 0

Type:

整数

颜色栏边框轮廓的线段虚线偏移。

border_line_join = 'bevel'

Type:

Enum(LineJoin)

颜色栏边框轮廓的线段连接样式。

border_line_width = 1

Type:

浮点数

颜色栏边框轮廓的线条宽度。

color_mapper = Undefined

Type:

Instance(ColorMapper)

一个包含要渲染的调色板的颜色映射器。

警告

如果未设置 ColorMapper 的 low 和 high 属性，则不会渲染刻度和刻度标签。此外，如果将 LogTicker 传递给 ticker 参数，并且 color_mapper 的 low 和 high 值的对数中的一个或两个为非数值（即 low=0），则不会渲染刻度和刻度标签。

context_menu = None

Type:

Nullable(Instance(‘.models.ui.Menu’))

当用户右键单击组件时显示的菜单。

注意

右键单击时使用 shift 键显示原生上下文菜单。

css_classes = []

Type:

List

要添加到底层 DOM 元素的其他 CSS 类列表。

css_variables = {}

Type:

Dict(String, Either(String, Instance(Node)))

允许定义动态计算的 CSS 变量。

例如，这可以用于协调画布渲染器和/或视觉效果与基于 HTML 的 UI 元素之间的定位和样式设置。

此处定义的变量等效于在 CSS 样式表中的 :host { ... } 下设置相同的变量。

注意

此属性是实验性的，随时可能更改。

display_high = None

Type:

Nullable(Float)

要在颜色栏中显示的最高值。包含此值的整个颜色条目都会显示出来。

display_low = None

Type:

Nullable(Float)

要在颜色栏中显示的最低值。包含此值的整个颜色条目都会显示出来。

elements = []

Type:

List

附加到此渲染器的基于 DOM 的 UI 元素集合。

这可以包括浮动元素（如工具提示），从而允许在此渲染器及其 UI 元素之间建立父子关系。

注意

此属性等效于基于 DOM 的 UI 中的 Pane.elements。

formatter = 'auto'

Type:

Either(Instance(TickFormatter), Auto)

用于格式化刻度视觉外观的 TickFormatter。

group = None

Type:

Nullable(Instance(RendererGroup))

注意

此属性是实验性的，随时可能更改。

height = 'auto'

Type:

Either(Auto, Int)

颜色刻度应占据的高度（以像素为单位）。

html_attributes = {}

Type:

Dict(String, String)

允许在底层 HTML 元素上配置 HTML 属性。

html_id = None

Type:

Nullable(String)

设置底层 HTML 元素的 id 属性。

这是常用 HTML id 属性的简写形式。或者，id 也可以在 html_attributes 字典中设置。html_id 优先。

label_standoff = 5

Type:

整数

将刻度标签与颜色栏分隔开的距离（以像素为单位）。

level = 'annotation'

Type:

Enum(RenderLevel)

指定绘制此渲染器的层级。

location = 'top_right'

Type:

Either(Enum(Anchor), Tuple(Float, Float))

颜色栏应绘制自身的位置。它可以是 bokeh.core.enums.Anchor 的枚举值之一，也可以是 (x, y) 元组，指示屏幕坐标中的绝对位置（从左下角开始的像素）。

警告

如果颜色栏放置在侧面板中，则位置可能必须设置为 (0,0)。

major_label_overrides = {}

Type:

Dict(Either(Float, String), TextLike)

为覆盖正常格式的特定刻度位置提供显式刻度标签值。

major_label_policy = NoOverlap(id='p53947', ...)

Type:

Instance(LabelingPolicy)

允许过滤掉标签，例如，整理标签以避免重叠。

major_label_text_align = 'left'

Type:

Enum(TextAlign)

主刻度标签的文本对齐方式。

major_label_text_alpha = 1.0

Type:

Alpha（透明度）

主刻度标签的文本 alpha 值。

major_label_text_baseline = 'bottom'

Type:

Enum(TextBaseline)

主刻度标签的文本基线。

major_label_text_color = '#444444'

Type:

Nullable(Color)

主刻度标签的文本颜色。

major_label_text_font = 'helvetica'

Type:

String

主刻度标签的文本字体。

major_label_text_font_size = '11px'

Type:

FontSize

主刻度标签的文本字体大小。

major_label_text_font_style = 'normal'

Type:

Enum(FontStyle)

主刻度标签的文本字体样式。

major_label_text_line_height = 1.2

Type:

浮点数

主要刻度标签的文本行高。

major_label_text_outline_color = None

Type:

Nullable(Color)

主要刻度标签的文本轮廓颜色。

major_tick_in = 5

Type:

整数

主要刻度线延伸到主绘图区域的距离（以像素为单位）。

major_tick_line_alpha = 1.0

Type:

Alpha（透明度）

主要刻度线的线条 alpha 值。

major_tick_line_cap = 'butt'

Type:

Enum(LineCap)

主要刻度线的线帽样式。

major_tick_line_color = '#ffffff'

Type:

Nullable(Color)

主要刻度线的线条颜色。

major_tick_line_dash = []

Type:

虚线模式

主要刻度线的线段虚线模式。

major_tick_line_dash_offset = 0

Type:

整数

主要刻度线的线段虚线偏移。

major_tick_line_join = 'bevel'

Type:

Enum(LineJoin)

主要刻度线的线段连接样式。

major_tick_line_width = 1

Type:

浮点数

主要刻度线的线宽。

major_tick_out = 0

Type:

整数

主要刻度线延伸出主绘图区域的距离（以像素为单位）。

margin = 30

Type:

整数

色条外部周围的边距量（以像素为单位）。

minor_tick_in = 0

Type:

整数

次要刻度线延伸到主绘图区域的距离（以像素为单位）。

minor_tick_line_alpha = 1.0

Type:

Alpha（透明度）

次要刻度线的线条 alpha 值。

minor_tick_line_cap = 'butt'

Type:

Enum(LineCap)

次要刻度线的线帽样式。

minor_tick_line_color = None

Type:

Nullable(Color)

次要刻度线的线条颜色。

minor_tick_line_dash = []

Type:

虚线模式

次要刻度线的线段虚线模式。

minor_tick_line_dash_offset = 0

Type:

整数

次要刻度线的线段虚线偏移。

minor_tick_line_join = 'bevel'

Type:

Enum(LineJoin)

次要刻度线的线段连接样式。

minor_tick_line_width = 1

Type:

浮点数

次要刻度线的线宽。

minor_tick_out = 0

Type:

整数

主要刻度线延伸出主绘图区域的距离（以像素为单位）。

name = None

Type:

Nullable(String)

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

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

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

注意

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

orientation = 'auto'

Type:

Either(Enum(Orientation), Auto)

色条应垂直还是水平方向。

padding = 10

Type:

整数

颜色刻度与色条边框之间的内边距量（以像素为单位）。

propagate_hover = False

Type:

布尔值

允许将悬停事件传播到父级渲染器、框架或画布。

注意

此属性是实验性的，随时可能更改。

renderers = []

Type:

List

附加到此渲染器的一组渲染器。

注意

此属性是实验性的，随时可能更改。

scale_alpha = 1.0

Type:

浮点数

渲染颜色刻度时使用的 alpha 值。

styles = {}

Type:

Either(Dict(String, Nullable(String)), Instance(Styles))

应用于底层 DOM 元素的内联 CSS 样式。

stylesheets = []

Type:

List

用于底层 DOM 元素的其他样式表。

请注意，所有 Bokeh 组件都使用 shadow DOM，因此任何包含的样式表都必须反映这一点，例如，使用 :host CSS 伪选择器来访问根 DOM 元素。

syncable = True

Type:

布尔值

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

注意

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

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

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

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

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

注意

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

ticker = 'auto'

Type:

Either(Instance(Ticker), Auto)

用于计算轴组件位置的 Ticker。

title = None

Type:

Nullable(TextLike)

要渲染的标题文本。

title_standoff = 2

Type:

整数

标题与色条之间的距离（以像素为单位）。

title_text_align = 'left'

Type:

Enum(TextAlign)

标题文本的文本对齐值。

title_text_alpha = 1.0

Type:

Alpha（透明度）

标题文本的文本 alpha 值。

title_text_baseline = 'bottom'

Type:

Enum(TextBaseline)

标题文本的文本基线值。

title_text_color = '#444444'

Type:

Nullable(Color)

标题文本的文本颜色值。

title_text_font = 'helvetica'

Type:

String

标题文本的文本字体值。

title_text_font_size = '13px'

Type:

FontSize

标题文本的文本字体大小值。

title_text_font_style = 'italic'

Type:

Enum(FontStyle)

标题文本的文本字体样式值。

title_text_line_height = 1.2

Type:

浮点数

标题文本的文本行高值。

title_text_outline_color = None

Type:

Nullable(Color)

标题文本的文本轮廓颜色值。

visible = True

Type:

布尔值

渲染器是否可见。

width = 'auto'

Type:

Either(Auto, Int)

颜色刻度应占用的宽度（以像素为单位）。

x_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）x 轴范围。如果未设置，则使用默认 x 轴范围。

y_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）y 轴范围。如果未设置，则使用默认 y 轴范围。

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

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

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

参数:

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

返回值:

None

classmethod clear_extensions() → None

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

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

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

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

classmethod dataspecs() → dict[str, DataSpec]

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

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

返回值:

DataSpec 属性的名称

Return type:

set[str]

classmethod descriptors() → list[PropertyDescriptor]

属性描述符列表，按定义顺序排列。

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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]

给定属性名称，查找类上 Bokeh 属性的 PropertyDescriptor。

参数:

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

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

返回值:

名为 name 的属性的描述符

Return type:

PropertyDescriptor

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

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

参数:

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

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

返回值:

None

示例

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

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

在此 Model 上指定的事件发生时运行回调

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

classmethod parameters() → list[Parameter]

生成适用于从 glyph 派生的函数的 Python Parameter 值。

返回值:

list(Parameter)

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

收集此类上的属性名称。

警告

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

返回值:

属性名称

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

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

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

返回值:

具有引用的属性的名称

Return type:

set[str]

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

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

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

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

参数:

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

返回值:

从属性名称到其值的映射

Return type:

dict

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

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

参数:

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

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

返回值:

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

Return type:

dict

references() → set[Model]

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

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

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

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

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

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

返回值:

Model

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

从 JSON 在此对象上设置属性值。

参数:

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

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

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

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

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

返回值:

None

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

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

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

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

返回值:

None

update(**kwargs: Any) → None

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

返回值:

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 ContourColorBar(*args: Any, id: ID | None = None, **kwargs: Any)

Bases: BaseColorBar

用于轮廓的颜色条。

支持显示轮廓图可能具有的阴影图案和线条样式，以及通常的填充样式。

请勿手动创建这些对象，而应使用 ContourRenderer.color_bar。

JSON 原型

{
  "background_fill_alpha": 0.95, 
  "background_fill_color": "#ffffff", 
  "background_hatch_alpha": 1.0, 
  "background_hatch_color": "black", 
  "background_hatch_extra": {
    "type": "map"
  }, 
  "background_hatch_pattern": null, 
  "background_hatch_scale": 12.0, 
  "background_hatch_weight": 1.0, 
  "bar_line_alpha": 1.0, 
  "bar_line_cap": "butt", 
  "bar_line_color": null, 
  "bar_line_dash": [], 
  "bar_line_dash_offset": 0, 
  "bar_line_join": "bevel", 
  "bar_line_width": 1, 
  "border_line_alpha": 1.0, 
  "border_line_cap": "butt", 
  "border_line_color": null, 
  "border_line_dash": [], 
  "border_line_dash_offset": 0, 
  "border_line_join": "bevel", 
  "border_line_width": 1, 
  "context_menu": null, 
  "coordinates": null, 
  "css_classes": [], 
  "css_variables": {
    "type": "map"
  }, 
  "elements": [], 
  "fill_renderer": {
    "name": "unset", 
    "type": "symbol"
  }, 
  "formatter": "auto", 
  "group": null, 
  "height": "auto", 
  "html_attributes": {
    "type": "map"
  }, 
  "html_id": null, 
  "id": "p54056", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "label_standoff": 5, 
  "level": "annotation", 
  "levels": [], 
  "line_renderer": {
    "name": "unset", 
    "type": "symbol"
  }, 
  "location": "top_right", 
  "major_label_overrides": {
    "type": "map"
  }, 
  "major_label_policy": {
    "id": "p54057", 
    "name": "NoOverlap", 
    "type": "object"
  }, 
  "major_label_text_align": "left", 
  "major_label_text_alpha": 1.0, 
  "major_label_text_baseline": "bottom", 
  "major_label_text_color": "#444444", 
  "major_label_text_font": "helvetica", 
  "major_label_text_font_size": "11px", 
  "major_label_text_font_style": "normal", 
  "major_label_text_line_height": 1.2, 
  "major_label_text_outline_color": null, 
  "major_tick_in": 5, 
  "major_tick_line_alpha": 1.0, 
  "major_tick_line_cap": "butt", 
  "major_tick_line_color": "#ffffff", 
  "major_tick_line_dash": [], 
  "major_tick_line_dash_offset": 0, 
  "major_tick_line_join": "bevel", 
  "major_tick_line_width": 1, 
  "major_tick_out": 0, 
  "margin": 30, 
  "minor_tick_in": 0, 
  "minor_tick_line_alpha": 1.0, 
  "minor_tick_line_cap": "butt", 
  "minor_tick_line_color": null, 
  "minor_tick_line_dash": [], 
  "minor_tick_line_dash_offset": 0, 
  "minor_tick_line_join": "bevel", 
  "minor_tick_line_width": 1, 
  "minor_tick_out": 0, 
  "name": null, 
  "orientation": "auto", 
  "padding": 10, 
  "propagate_hover": false, 
  "renderers": [], 
  "scale_alpha": 1.0, 
  "styles": {
    "type": "map"
  }, 
  "stylesheets": [], 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": [], 
  "ticker": "auto", 
  "title": null, 
  "title_standoff": 2, 
  "title_text_align": "left", 
  "title_text_alpha": 1.0, 
  "title_text_baseline": "bottom", 
  "title_text_color": "#444444", 
  "title_text_font": "helvetica", 
  "title_text_font_size": "13px", 
  "title_text_font_style": "italic", 
  "title_text_line_height": 1.2, 
  "title_text_outline_color": null, 
  "visible": true, 
  "width": "auto", 
  "x_range_name": "default", 
  "y_range_name": "default"
}

background_fill_alpha = 0.95

Type:

Alpha（透明度）

颜色栏背景样式的填充 alpha 值。

background_fill_color = '#ffffff'

Type:

Nullable(Color)

颜色栏背景样式的填充颜色。

background_hatch_alpha = 1.0

Type:

Alpha（透明度）

颜色栏背景样式的阴影线 alpha 值。

background_hatch_color = 'black'

Type:

Nullable(Color)

颜色栏背景样式的阴影线颜色。

background_hatch_extra = {}

Type:

Dict(String, Instance(Texture))

颜色栏背景样式的额外阴影线属性。

background_hatch_pattern = None

Type:

Nullable(String)

颜色栏背景样式的阴影线图案。

background_hatch_scale = 12.0

Type:

尺寸

颜色栏背景样式的阴影线比例。

background_hatch_weight = 1.0

Type:

尺寸

颜色栏背景样式的阴影线粗细。

bar_line_alpha = 1.0

Type:

Alpha（透明度）

颜色刻度栏轮廓的线条 alpha 值。

bar_line_cap = 'butt'

Type:

Enum(LineCap)

颜色刻度栏轮廓的线帽样式。

bar_line_color = None

Type:

Nullable(Color)

颜色刻度栏轮廓的线条颜色。

bar_line_dash = []

Type:

虚线模式

颜色刻度栏轮廓的线段虚线模式。

bar_line_dash_offset = 0

Type:

整数

颜色刻度栏轮廓的线段虚线偏移。

bar_line_join = 'bevel'

Type:

Enum(LineJoin)

颜色刻度栏轮廓的线段连接样式。

bar_line_width = 1

Type:

浮点数

颜色刻度栏轮廓的线条宽度。

border_line_alpha = 1.0

Type:

Alpha（透明度）

颜色栏边框轮廓的线条 alpha 值。

border_line_cap = 'butt'

Type:

Enum(LineCap)

颜色栏边框轮廓的线帽样式。

border_line_color = None

Type:

Nullable(Color)

颜色栏边框轮廓的线条颜色。

border_line_dash = []

Type:

虚线模式

颜色栏边框轮廓的线段虚线模式。

border_line_dash_offset = 0

Type:

整数

颜色栏边框轮廓的线段虚线偏移。

border_line_join = 'bevel'

Type:

Enum(LineJoin)

颜色栏边框轮廓的线段连接样式。

border_line_width = 1

Type:

浮点数

颜色栏边框轮廓的线条宽度。

context_menu = None

Type:

Nullable(Instance(‘.models.ui.Menu’))

当用户右键单击组件时显示的菜单。

注意

右键单击时使用 shift 键显示原生上下文菜单。

css_classes = []

Type:

List

要添加到底层 DOM 元素的其他 CSS 类列表。

css_variables = {}

Type:

Dict(String, Either(String, Instance(Node)))

允许定义动态计算的 CSS 变量。

例如，这可以用于协调画布渲染器和/或视觉效果与基于 HTML 的 UI 元素之间的定位和样式设置。

此处定义的变量等效于在 CSS 样式表中的 :host { ... } 下设置相同的变量。

注意

此属性是实验性的，随时可能更改。

elements = []

Type:

List

附加到此渲染器的基于 DOM 的 UI 元素集合。

这可以包括浮动元素（如工具提示），从而允许在此渲染器及其 UI 元素之间建立父子关系。

注意

此属性等效于基于 DOM 的 UI 中的 Pane.elements。

fill_renderer = Undefined

Type:

Instance(GlyphRenderer)

用于填充轮廓多边形的字形渲染器。

formatter = 'auto'

Type:

Either(Instance(TickFormatter), Auto)

用于格式化刻度视觉外观的 TickFormatter。

group = None

Type:

Nullable(Instance(RendererGroup))

注意

此属性是实验性的，随时可能更改。

height = 'auto'

Type:

Either(Auto, Int)

颜色刻度应占据的高度（以像素为单位）。

html_attributes = {}

Type:

Dict(String, String)

允许在底层 HTML 元素上配置 HTML 属性。

html_id = None

Type:

Nullable(String)

设置底层 HTML 元素的 id 属性。

这是常用 HTML id 属性的简写形式。或者，id 也可以在 html_attributes 字典中设置。html_id 优先。

label_standoff = 5

Type:

整数

将刻度标签与颜色栏分隔开的距离（以像素为单位）。

level = 'annotation'

Type:

Enum(RenderLevel)

指定绘制此渲染器的层级。

levels = []

Type:

Seq(Float)

计算轮廓的级别。

line_renderer = Undefined

Type:

Instance(GlyphRenderer)

用于轮廓线的字形渲染器。

location = 'top_right'

Type:

Either(Enum(Anchor), Tuple(Float, Float))

颜色栏应绘制自身的位置。它可以是 bokeh.core.enums.Anchor 的枚举值之一，也可以是 (x, y) 元组，指示屏幕坐标中的绝对位置（从左下角开始的像素）。

警告

如果颜色栏放置在侧面板中，则位置可能必须设置为 (0,0)。

major_label_overrides = {}

Type:

Dict(Either(Float, String), TextLike)

为覆盖正常格式的特定刻度位置提供显式刻度标签值。

major_label_policy = NoOverlap(id='p54136', ...)

Type:

Instance(LabelingPolicy)

允许过滤掉标签，例如，整理标签以避免重叠。

major_label_text_align = 'left'

Type:

Enum(TextAlign)

主刻度标签的文本对齐方式。

major_label_text_alpha = 1.0

Type:

Alpha（透明度）

主刻度标签的文本 alpha 值。

major_label_text_baseline = 'bottom'

Type:

Enum(TextBaseline)

主刻度标签的文本基线。

major_label_text_color = '#444444'

Type:

Nullable(Color)

主刻度标签的文本颜色。

major_label_text_font = 'helvetica'

Type:

String

主刻度标签的文本字体。

major_label_text_font_size = '11px'

Type:

FontSize

主刻度标签的文本字体大小。

major_label_text_font_style = 'normal'

Type:

Enum(FontStyle)

主刻度标签的文本字体样式。

major_label_text_line_height = 1.2

Type:

浮点数

主要刻度标签的文本行高。

major_label_text_outline_color = None

Type:

Nullable(Color)

主要刻度标签的文本轮廓颜色。

major_tick_in = 5

Type:

整数

主要刻度线延伸到主绘图区域的距离（以像素为单位）。

major_tick_line_alpha = 1.0

Type:

Alpha（透明度）

主要刻度线的线条 alpha 值。

major_tick_line_cap = 'butt'

Type:

Enum(LineCap)

主要刻度线的线帽样式。

major_tick_line_color = '#ffffff'

Type:

Nullable(Color)

主要刻度线的线条颜色。

major_tick_line_dash = []

Type:

虚线模式

主要刻度线的线段虚线模式。

major_tick_line_dash_offset = 0

Type:

整数

主要刻度线的线段虚线偏移。

major_tick_line_join = 'bevel'

Type:

Enum(LineJoin)

主要刻度线的线段连接样式。

major_tick_line_width = 1

Type:

浮点数

主要刻度线的线宽。

major_tick_out = 0

Type:

整数

主要刻度线延伸出主绘图区域的距离（以像素为单位）。

margin = 30

Type:

整数

色条外部周围的边距量（以像素为单位）。

minor_tick_in = 0

Type:

整数

次要刻度线延伸到主绘图区域的距离（以像素为单位）。

minor_tick_line_alpha = 1.0

Type:

Alpha（透明度）

次要刻度线的线条 alpha 值。

minor_tick_line_cap = 'butt'

Type:

Enum(LineCap)

次要刻度线的线帽样式。

minor_tick_line_color = None

Type:

Nullable(Color)

次要刻度线的线条颜色。

minor_tick_line_dash = []

Type:

虚线模式

次要刻度线的线段虚线模式。

minor_tick_line_dash_offset = 0

Type:

整数

次要刻度线的线段虚线偏移。

minor_tick_line_join = 'bevel'

Type:

Enum(LineJoin)

次要刻度线的线段连接样式。

minor_tick_line_width = 1

Type:

浮点数

次要刻度线的线宽。

minor_tick_out = 0

Type:

整数

主要刻度线延伸出主绘图区域的距离（以像素为单位）。

name = None

Type:

Nullable(String)

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

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

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

注意

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

orientation = 'auto'

Type:

Either(Enum(Orientation), Auto)

色条应垂直还是水平方向。

padding = 10

Type:

整数

颜色刻度与色条边框之间的内边距量（以像素为单位）。

propagate_hover = False

Type:

布尔值

允许将悬停事件传播到父级渲染器、框架或画布。

注意

此属性是实验性的，随时可能更改。

renderers = []

Type:

List

附加到此渲染器的一组渲染器。

注意

此属性是实验性的，随时可能更改。

scale_alpha = 1.0

Type:

浮点数

渲染颜色刻度时使用的 alpha 值。

styles = {}

Type:

Either(Dict(String, Nullable(String)), Instance(Styles))

应用于底层 DOM 元素的内联 CSS 样式。

stylesheets = []

Type:

List

用于底层 DOM 元素的其他样式表。

请注意，所有 Bokeh 组件都使用 shadow DOM，因此任何包含的样式表都必须反映这一点，例如，使用 :host CSS 伪选择器来访问根 DOM 元素。

syncable = True

Type:

布尔值

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

注意

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

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

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

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

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

注意

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

ticker = 'auto'

Type:

Either(Instance(Ticker), Auto)

用于计算轴组件位置的 Ticker。

title = None

Type:

Nullable(TextLike)

要渲染的标题文本。

title_standoff = 2

Type:

整数

标题与色条之间的距离（以像素为单位）。

title_text_align = 'left'

Type:

Enum(TextAlign)

标题文本的文本对齐值。

title_text_alpha = 1.0

Type:

Alpha（透明度）

标题文本的文本 alpha 值。

title_text_baseline = 'bottom'

Type:

Enum(TextBaseline)

标题文本的文本基线值。

title_text_color = '#444444'

Type:

Nullable(Color)

标题文本的文本颜色值。

title_text_font = 'helvetica'

Type:

String

标题文本的文本字体值。

title_text_font_size = '13px'

Type:

FontSize

标题文本的文本字体大小值。

title_text_font_style = 'italic'

Type:

Enum(FontStyle)

标题文本的文本字体样式值。

title_text_line_height = 1.2

Type:

浮点数

标题文本的文本行高值。

title_text_outline_color = None

Type:

Nullable(Color)

标题文本的文本轮廓颜色值。

visible = True

Type:

布尔值

渲染器是否可见。

width = 'auto'

Type:

Either(Auto, Int)

颜色刻度应占用的宽度（以像素为单位）。

x_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）x 轴范围。如果未设置，则使用默认 x 轴范围。

y_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）y 轴范围。如果未设置，则使用默认 y 轴范围。

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

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

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

参数:

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

返回值:

None

classmethod clear_extensions() → None

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

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

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

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

classmethod dataspecs() → dict[str, DataSpec]

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

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

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

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

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

参数:

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

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

返回值:

None

示例

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

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

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 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]]

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

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

返回值:

具有引用的属性的名称

Return type:

set[str]

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

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

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

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

参数:

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

返回值:

从属性名称到其值的映射

Return type:

dict

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

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

参数:

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

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

返回值:

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

Return type:

dict

references() → set[Model]

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

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

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

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

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

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

返回值:

Model

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

从 JSON 在此对象上设置属性值。

参数:

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

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

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

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

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

返回值:

None

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

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

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

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

返回值:

None

update(**kwargs: Any) → None

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

返回值:

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 HTMLAnnotation(*args: Any, id: ID | None = None, **kwargs: Any)

Bases: Annotation

HTML-based 注释的基类。

注意

所有继承自此基类的注释都可以附加到画布上，但不会渲染到画布上，因此它们不会出现在保存的绘图中。只有 export_png() 函数可以保留 HTML 注释。

注意

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

JSON 原型

{
  "context_menu": null, 
  "coordinates": null, 
  "css_classes": [], 
  "css_variables": {
    "type": "map"
  }, 
  "elements": [], 
  "group": null, 
  "html_attributes": {
    "type": "map"
  }, 
  "html_id": null, 
  "id": "p54245", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "level": "annotation", 
  "name": null, 
  "propagate_hover": false, 
  "renderers": [], 
  "styles": {
    "type": "map"
  }, 
  "stylesheets": [], 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": [], 
  "visible": true, 
  "x_range_name": "default", 
  "y_range_name": "default"
}

context_menu = None

Type:

Nullable(Instance(‘.models.ui.Menu’))

当用户右键单击组件时显示的菜单。

注意

右键单击时使用 shift 键显示原生上下文菜单。

css_classes = []

Type:

List

要添加到底层 DOM 元素的其他 CSS 类列表。

css_variables = {}

Type:

Dict(String, Either(String, Instance(Node)))

允许定义动态计算的 CSS 变量。

例如，这可以用于协调画布渲染器和/或视觉效果与基于 HTML 的 UI 元素之间的定位和样式设置。

此处定义的变量等效于在 CSS 样式表中的 :host { ... } 下设置相同的变量。

注意

此属性是实验性的，随时可能更改。

elements = []

Type:

List

附加到此渲染器的基于 DOM 的 UI 元素集合。

这可以包括浮动元素（如工具提示），从而允许在此渲染器及其 UI 元素之间建立父子关系。

注意

此属性等效于基于 DOM 的 UI 中的 Pane.elements。

group = None

Type:

Nullable(Instance(RendererGroup))

注意

此属性是实验性的，随时可能更改。

html_attributes = {}

Type:

Dict(String, String)

允许在底层 HTML 元素上配置 HTML 属性。

html_id = None

Type:

Nullable(String)

设置底层 HTML 元素的 id 属性。

这是常用 HTML id 属性的简写形式。或者，id 也可以在 html_attributes 字典中设置。html_id 优先。

level = 'annotation'

Type:

Enum(RenderLevel)

指定绘制此渲染器的层级。

name = None

Type:

Nullable(String)

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

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

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

注意

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

propagate_hover = False

Type:

布尔值

允许将悬停事件传播到父级渲染器、框架或画布。

注意

此属性是实验性的，随时可能更改。

renderers = []

Type:

List

附加到此渲染器的一组渲染器。

注意

此属性是实验性的，随时可能更改。

styles = {}

Type:

Either(Dict(String, Nullable(String)), Instance(Styles))

应用于底层 DOM 元素的内联 CSS 样式。

stylesheets = []

Type:

List

用于底层 DOM 元素的其他样式表。

请注意，所有 Bokeh 组件都使用 shadow DOM，因此任何包含的样式表都必须反映这一点，例如，使用 :host CSS 伪选择器来访问根 DOM 元素。

syncable = True

Type:

布尔值

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

注意

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

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

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

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

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

注意

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

visible = True

Type:

布尔值

渲染器是否可见。

x_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）x 轴范围。如果未设置，则使用默认 x 轴范围。

y_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）y 轴范围。如果未设置，则使用默认 y 轴范围。

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

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

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

参数:

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

返回值:

None

classmethod clear_extensions() → None

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

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

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

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

classmethod dataspecs() → dict[str, DataSpec]

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

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

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

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

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

参数:

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

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

返回值:

None

示例

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

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

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 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]]

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

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

返回值:

具有引用的属性的名称

Return type:

set[str]

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

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

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

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

参数:

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

返回值:

从属性名称到其值的映射

Return type:

dict

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

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

参数:

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

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

返回值:

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

Return type:

dict

references() → set[Model]

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

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

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

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

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

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

返回值:

Model

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

从 JSON 在此对象上设置属性值。

参数:

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

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

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

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

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

返回值:

None

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

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

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

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

返回值:

None

update(**kwargs: Any) → None

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

返回值:

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 HTMLLabel(*args: Any, id: ID | None = None, **kwargs: Any)

Bases: HTMLTextAnnotation

Render a single HTML label as an annotation.

Label will render a single text label at given x and y coordinates, which can be in either screen (pixel) space, or data (axis range) space.

The label can also be configured with a screen space offset from x and y, by using the x_offset and y_offset properties.

Additionally, the label can be rotated with the angle property.

There are also standard text, fill, and line properties to control the appearance of the text, its background, as well as the rectangular bounding box border.

See Labels for information on plotting labels.

JSON 原型

{
  "angle": 0, 
  "angle_units": "rad", 
  "background_fill_alpha": 1.0, 
  "background_fill_color": null, 
  "background_hatch_alpha": 1.0, 
  "background_hatch_color": null, 
  "background_hatch_extra": {
    "type": "map"
  }, 
  "background_hatch_pattern": null, 
  "background_hatch_scale": 12.0, 
  "background_hatch_weight": 1.0, 
  "border_line_alpha": 1.0, 
  "border_line_cap": "butt", 
  "border_line_color": null, 
  "border_line_dash": [], 
  "border_line_dash_offset": 0, 
  "border_line_join": "bevel", 
  "border_line_width": 1, 
  "border_radius": 0, 
  "context_menu": null, 
  "coordinates": null, 
  "css_classes": [], 
  "css_variables": {
    "type": "map"
  }, 
  "elements": [], 
  "group": null, 
  "html_attributes": {
    "type": "map"
  }, 
  "html_id": null, 
  "id": "p54264", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "level": "annotation", 
  "name": null, 
  "padding": 0, 
  "propagate_hover": false, 
  "renderers": [], 
  "styles": {
    "type": "map"
  }, 
  "stylesheets": [], 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": [], 
  "text": "", 
  "text_align": "left", 
  "text_alpha": 1.0, 
  "text_baseline": "bottom", 
  "text_color": "#444444", 
  "text_font": "helvetica", 
  "text_font_size": "16px", 
  "text_font_style": "normal", 
  "text_line_height": 1.2, 
  "text_outline_color": null, 
  "visible": true, 
  "x": {
    "name": "unset", 
    "type": "symbol"
  }, 
  "x_offset": 0, 
  "x_range_name": "default", 
  "x_units": "data", 
  "y": {
    "name": "unset", 
    "type": "symbol"
  }, 
  "y_offset": 0, 
  "y_range_name": "default", 
  "y_units": "data"
}

angle = 0

Type:

角度

文本旋转的角度，从水平方向测量。

angle_units = 'rad'

Type:

Enum(AngleUnits)

单位的可接受值是 "rad" 和 "deg"

background_fill_alpha = 1.0

Type:

Alpha（透明度）

文本边框的填充 alpha 值。

background_fill_color = None

Type:

Nullable(Color)

文本边框的填充颜色值。

background_hatch_alpha = 1.0

Type:

Alpha（透明度）

文本边框的阴影线 alpha 值。

background_hatch_color = None

Type:

Nullable(Color)

文本边框的阴影线颜色值。

background_hatch_extra = {}

Type:

Dict(String, Instance(Texture))

文本边框的阴影线额外值。

background_hatch_pattern = None

Type:

Nullable(String)

文本边框的阴影线图案值。

background_hatch_scale = 12.0

Type:

尺寸

文本边框的阴影线比例值。

background_hatch_weight = 1.0

Type:

尺寸

文本边框的阴影线粗细值。

border_line_alpha = 1.0

Type:

Alpha（透明度）

文本边框的线条 alpha 值。

border_line_cap = 'butt'

Type:

Enum(LineCap)

文本边框的线条端帽值。

border_line_color = None

Type:

Nullable(Color)

文本边框的线条颜色值。

border_line_dash = []

Type:

虚线模式

文本边框的线条虚线值。

border_line_dash_offset = 0

Type:

整数

文本边框的线条虚线偏移值。

border_line_join = 'bevel'

Type:

Enum(LineJoin)

文本边框的线条连接值。

border_line_width = 1

Type:

浮点数

文本边框的线条宽度值。

border_radius = 0

Type:

Either(NonNegative, Tuple(NonNegative, NonNegative, NonNegative, NonNegative), Struct)

允许标签的框具有圆角。为了获得最佳效果，应与 padding 结合使用。

注意

此属性是实验性的，随时可能更改。

context_menu = None

Type:

Nullable(Instance(‘.models.ui.Menu’))

当用户右键单击组件时显示的菜单。

注意

右键单击时使用 shift 键显示原生上下文菜单。

css_classes = []

Type:

List

要添加到底层 DOM 元素的其他 CSS 类列表。

css_variables = {}

Type:

Dict(String, Either(String, Instance(Node)))

允许定义动态计算的 CSS 变量。

例如，这可以用于协调画布渲染器和/或视觉效果与基于 HTML 的 UI 元素之间的定位和样式设置。

此处定义的变量等效于在 CSS 样式表中的 :host { ... } 下设置相同的变量。

注意

此属性是实验性的，随时可能更改。

elements = []

Type:

List

附加到此渲染器的基于 DOM 的 UI 元素集合。

这可以包括浮动元素（如工具提示），从而允许在此渲染器及其 UI 元素之间建立父子关系。

注意

此属性等效于基于 DOM 的 UI 中的 Pane.elements。

group = None

Type:

Nullable(Instance(RendererGroup))

注意

此属性是实验性的，随时可能更改。

html_attributes = {}

Type:

Dict(String, String)

允许在底层 HTML 元素上配置 HTML 属性。

html_id = None

Type:

Nullable(String)

设置底层 HTML 元素的 id 属性。

这是常用 HTML id 属性的简写形式。或者，id 也可以在 html_attributes 字典中设置。html_id 优先。

level = 'annotation'

Type:

Enum(RenderLevel)

指定绘制此渲染器的层级。

name = None

Type:

Nullable(String)

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

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

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

注意

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

padding = 0

Type:

Either(NonNegative, Tuple(NonNegative, NonNegative), Struct, Tuple(NonNegative, NonNegative, NonNegative, NonNegative), Struct)

标签文本与其边框之间额外的空间。

注意

此属性是实验性的，随时可能更改。

propagate_hover = False

Type:

布尔值

允许将悬停事件传播到父级渲染器、框架或画布。

注意

此属性是实验性的，随时可能更改。

renderers = []

Type:

List

附加到此渲染器的一组渲染器。

注意

此属性是实验性的，随时可能更改。

styles = {}

Type:

Either(Dict(String, Nullable(String)), Instance(Styles))

应用于底层 DOM 元素的内联 CSS 样式。

stylesheets = []

Type:

List

用于底层 DOM 元素的其他样式表。

请注意，所有 Bokeh 组件都使用 shadow DOM，因此任何包含的样式表都必须反映这一点，例如，使用 :host CSS 伪选择器来访问根 DOM 元素。

syncable = True

Type:

布尔值

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

注意

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

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

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

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

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

注意

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

text = ''

Type:

String

要渲染的文本值。

text_align = 'left'

Type:

Enum(TextAlign)

文本的文本对齐值。

text_alpha = 1.0

Type:

Alpha（透明度）

文本的文本 alpha 值。

text_baseline = 'bottom'

Type:

Enum(TextBaseline)

文本的文本基线值。

text_color = '#444444'

Type:

Nullable(Color)

文本的文本颜色值。

text_font = 'helvetica'

Type:

String

文本的文本字体值。

text_font_size = '16px'

Type:

FontSize

文本的文本字体大小值。

text_font_style = 'normal'

Type:

Enum(FontStyle)

文本的文本字体样式值。

text_line_height = 1.2

Type:

浮点数

文本的文本行高值。

text_outline_color = None

Type:

Nullable(Color)

文本的文本轮廓颜色值。

visible = True

Type:

布尔值

渲染器是否可见。

x = Undefined

Type:

Required(Either(Float, Datetime, Factor))

屏幕坐标中用于定位文本锚点的 x 坐标。

x_offset = 0

Type:

浮点数

应用于 x 坐标的偏移值。

例如，如果希望将文本在 屏幕单位 中从给定的数据位置“浮动”固定距离，这将非常有用。

x_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）x 轴范围。如果未设置，则使用默认 x 轴范围。

x_units = 'data'

Type:

Enum(CoordinateUnits)

x 属性的单位类型。默认解释为 数据单位。

y = Undefined

Type:

Required(Either(Float, Datetime, Factor))

屏幕坐标中用于定位文本锚点的 y 坐标。

y_offset = 0

Type:

浮点数

应用于 y 坐标的偏移值。

例如，如果希望将文本在 屏幕单位 中从给定的数据位置“浮动”固定距离，这将非常有用。

y_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）y 轴范围。如果未设置，则使用默认 y 轴范围。

y_units = 'data'

Type:

Enum(CoordinateUnits)

y 属性的单位类型。默认解释为 数据单位。

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

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

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

参数:

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

返回值:

None

classmethod clear_extensions() → None

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

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

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

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

classmethod dataspecs() → dict[str, DataSpec]

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

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

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

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

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

参数:

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

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

返回值:

None

示例

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

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

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 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]]

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

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

返回值:

具有引用的属性的名称

Return type:

set[str]

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

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

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

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

参数:

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

返回值:

从属性名称到其值的映射

Return type:

dict

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

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

参数:

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

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

返回值:

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

Return type:

dict

references() → set[Model]

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

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

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

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

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

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

返回值:

Model

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

从 JSON 在此对象上设置属性值。

参数:

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

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

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

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

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

返回值:

None

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

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

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

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

返回值:

None

update(**kwargs: Any) → None

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

返回值:

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 HTMLLabelSet(*args: Any, id: ID | None = None, **kwargs: Any)

Bases: HTMLAnnotation, DataAnnotation

将多个文本标签渲染为注释。

LabelSet 将在给定的 x 和 y 坐标处渲染多个文本标签，这些坐标可以是屏幕（像素）空间或数据（轴范围）空间。在这种情况下（与单个 Label 模型相反），x 和 y 也可以是来自 ColumnDataSource 的列的名称，在这种情况下，标签将使用指定列的坐标值进行“向量化”。

标签还可以通过使用 x_offset 和 y_offset 属性，配置与 x 和 y 的屏幕空间偏移。

这些偏移可以通过提供数据源列的名称进行向量化。

There are also standard text, fill, and line properties to control the appearance of the text, its background, as well as the rectangular bounding box border.

此外，标签可以使用 angle 属性旋转（这也可能是列名）。

JSON 原型

{
  "angle": {
    "type": "value", 
    "value": 0
  }, 
  "background_fill_alpha": {
    "type": "value", 
    "value": 1.0
  }, 
  "background_fill_color": {
    "type": "value", 
    "value": null
  }, 
  "border_line_alpha": {
    "type": "value", 
    "value": 1.0
  }, 
  "border_line_cap": {
    "type": "value", 
    "value": "butt"
  }, 
  "border_line_color": {
    "type": "value", 
    "value": null
  }, 
  "border_line_dash": {
    "type": "value", 
    "value": []
  }, 
  "border_line_dash_offset": {
    "type": "value", 
    "value": 0
  }, 
  "border_line_join": {
    "type": "value", 
    "value": "bevel"
  }, 
  "border_line_width": {
    "type": "value", 
    "value": 1
  }, 
  "context_menu": null, 
  "coordinates": null, 
  "css_classes": [], 
  "css_variables": {
    "type": "map"
  }, 
  "elements": [], 
  "group": null, 
  "html_attributes": {
    "type": "map"
  }, 
  "html_id": null, 
  "id": "p54318", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "level": "annotation", 
  "name": null, 
  "propagate_hover": false, 
  "renderers": [], 
  "source": {
    "attributes": {
      "data": {
        "type": "map"
      }, 
      "selected": {
        "attributes": {
          "indices": [], 
          "line_indices": []
        }, 
        "id": "p54320", 
        "name": "Selection", 
        "type": "object"
      }, 
      "selection_policy": {
        "id": "p54321", 
        "name": "UnionRenderers", 
        "type": "object"
      }
    }, 
    "id": "p54319", 
    "name": "ColumnDataSource", 
    "type": "object"
  }, 
  "styles": {
    "type": "map"
  }, 
  "stylesheets": [], 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": [], 
  "text": {
    "field": "text", 
    "type": "field"
  }, 
  "text_align": {
    "type": "value", 
    "value": "left"
  }, 
  "text_alpha": {
    "type": "value", 
    "value": 1.0
  }, 
  "text_baseline": {
    "type": "value", 
    "value": "bottom"
  }, 
  "text_color": {
    "type": "value", 
    "value": "#444444"
  }, 
  "text_font": {
    "type": "value", 
    "value": "helvetica"
  }, 
  "text_font_size": {
    "type": "value", 
    "value": "16px"
  }, 
  "text_font_style": {
    "type": "value", 
    "value": "normal"
  }, 
  "text_line_height": {
    "type": "value", 
    "value": 1.2
  }, 
  "text_outline_color": {
    "type": "value", 
    "value": null
  }, 
  "visible": true, 
  "x": {
    "field": "x", 
    "type": "field"
  }, 
  "x_offset": {
    "type": "value", 
    "value": 0
  }, 
  "x_range_name": "default", 
  "x_units": "data", 
  "y": {
    "field": "y", 
    "type": "field"
  }, 
  "y_offset": {
    "type": "value", 
    "value": 0
  }, 
  "y_range_name": "default", 
  "y_units": "data"
}

angle = 0

Type:

AngleSpec

要旋转文本的角度，从水平方向测量。

angle_units = 'rad'

Type:

NotSerialized(Enum(AngleUnits))

用于关联属性的单位：deg、rad、grad 或 turn

background_fill_alpha = 1.0

Type:

AlphaSpec

文本边框的填充 alpha 值。

background_fill_color = None

Type:

ColorSpec

文本边框的填充颜色值。

border_line_alpha = 1.0

Type:

AlphaSpec

文本边框的线条 alpha 值。

border_line_cap = 'butt'

Type:

LineCapSpec

文本边框的线条端帽值。

border_line_color = None

Type:

ColorSpec

文本边框的线条颜色值。

border_line_dash = []

Type:

DashPatternSpec

文本边框的线条虚线值。

border_line_dash_offset = 0

Type:

IntSpec

文本边框的线条虚线偏移值。

border_line_join = 'bevel'

Type:

LineJoinSpec

文本边框的线条连接值。

border_line_width = 1

Type:

FloatSpec

文本边框的线条宽度值。

context_menu = None

Type:

Nullable(Instance(‘.models.ui.Menu’))

当用户右键单击组件时显示的菜单。

注意

右键单击时使用 shift 键显示原生上下文菜单。

css_classes = []

Type:

List

要添加到底层 DOM 元素的其他 CSS 类列表。

css_variables = {}

Type:

Dict(String, Either(String, Instance(Node)))

允许定义动态计算的 CSS 变量。

例如，这可以用于协调画布渲染器和/或视觉效果与基于 HTML 的 UI 元素之间的定位和样式设置。

此处定义的变量等效于在 CSS 样式表中的 :host { ... } 下设置相同的变量。

注意

此属性是实验性的，随时可能更改。

elements = []

Type:

List

附加到此渲染器的基于 DOM 的 UI 元素集合。

这可以包括浮动元素（如工具提示），从而允许在此渲染器及其 UI 元素之间建立父子关系。

注意

此属性等效于基于 DOM 的 UI 中的 Pane.elements。

group = None

Type:

Nullable(Instance(RendererGroup))

注意

此属性是实验性的，随时可能更改。

html_attributes = {}

Type:

Dict(String, String)

允许在底层 HTML 元素上配置 HTML 属性。

html_id = None

Type:

Nullable(String)

设置底层 HTML 元素的 id 属性。

这是常用 HTML id 属性的简写形式。或者，id 也可以在 html_attributes 字典中设置。html_id 优先。

level = 'annotation'

Type:

Enum(RenderLevel)

指定绘制此渲染器的层级。

name = None

Type:

Nullable(String)

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

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

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

注意

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

propagate_hover = False

Type:

布尔值

允许将悬停事件传播到父级渲染器、框架或画布。

注意

此属性是实验性的，随时可能更改。

renderers = []

Type:

List

附加到此渲染器的一组渲染器。

注意

此属性是实验性的，随时可能更改。

source = ColumnDataSource(id='p54414', ...)

Type:

Instance(DataSource)

用于在绘图上渲染注释的本地数据源。

styles = {}

Type:

Either(Dict(String, Nullable(String)), Instance(Styles))

应用于底层 DOM 元素的内联 CSS 样式。

stylesheets = []

Type:

List

用于底层 DOM 元素的其他样式表。

请注意，所有 Bokeh 组件都使用 shadow DOM，因此任何包含的样式表都必须反映这一点，例如，使用 :host CSS 伪选择器来访问根 DOM 元素。

syncable = True

Type:

布尔值

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

注意

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

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

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

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

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

注意

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

text = Field(field='text', transform=Unspecified, units=Unspecified)

Type:

NullStringSpec

要渲染的文本值。

text_align = 'left'

Type:

TextAlignSpec

文本的文本对齐值。

text_alpha = 1.0

Type:

AlphaSpec

文本的文本 alpha 值。

text_baseline = 'bottom'

Type:

TextBaselineSpec

文本的文本基线值。

text_color = '#444444'

Type:

ColorSpec

文本的文本颜色值。

text_font = Value(value='helvetica', transform=Unspecified, units=Unspecified)

Type:

StringSpec

文本的文本字体值。

text_font_size = Value(value='16px', transform=Unspecified, units=Unspecified)

Type:

FontSizeSpec

文本的文本字体大小值。

text_font_style = 'normal'

Type:

FontStyleSpec

文本的文本字体样式值。

text_line_height = 1.2

Type:

NumberSpec

文本的文本行高值。

text_outline_color = None

Type:

ColorSpec

文本的文本轮廓颜色值。

visible = True

Type:

布尔值

渲染器是否可见。

x = Field(field='x', transform=Unspecified, units=Unspecified)

Type:

NumberSpec

用于定位文本锚点的 x 坐标。

x_offset = 0

Type:

NumberSpec

应用于 x 坐标的偏移值。

例如，如果希望将文本在 屏幕单位 中从给定的数据位置“浮动”固定距离，这将非常有用。

x_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）x 轴范围。如果未设置，则使用默认 x 轴范围。

x_units = 'data'

Type:

Enum(CoordinateUnits)

xs 属性的单位类型。默认解释为数据单位。

y = Field(field='y', transform=Unspecified, units=Unspecified)

Type:

NumberSpec

用于定位文本锚点的 y 坐标。

y_offset = 0

Type:

NumberSpec

应用于 y 坐标的偏移值。

例如，如果希望将文本在 屏幕单位 中从给定的数据位置“浮动”固定距离，这将非常有用。

y_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）y 轴范围。如果未设置，则使用默认 y 轴范围。

y_units = 'data'

Type:

Enum(CoordinateUnits)

ys 属性的单位类型。默认解释为数据单位。

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

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

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

参数:

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

返回值:

None

classmethod clear_extensions() → None

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

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

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

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

classmethod dataspecs() → dict[str, DataSpec]

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

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

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

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

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

参数:

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

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

返回值:

None

示例

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

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

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 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]]

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

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

返回值:

具有引用的属性的名称

Return type:

set[str]

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

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

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

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

参数:

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

返回值:

从属性名称到其值的映射

Return type:

dict

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

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

参数:

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

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

返回值:

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

Return type:

dict

references() → set[Model]

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

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

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

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

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

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

返回值:

Model

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

从 JSON 在此对象上设置属性值。

参数:

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

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

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

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

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

返回值:

None

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

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

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

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

返回值:

None

update(**kwargs: Any) → None

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

返回值:

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 HTMLTitle(*args: Any, id: ID | None = None, **kwargs: Any)

Bases: HTMLTextAnnotation

将单个标题框渲染为注释。

有关绘制标题的信息，请参阅 标题。

JSON 原型

{
  "align": "left", 
  "background_fill_alpha": 1.0, 
  "background_fill_color": null, 
  "background_hatch_alpha": 1.0, 
  "background_hatch_color": null, 
  "background_hatch_extra": {
    "type": "map"
  }, 
  "background_hatch_pattern": null, 
  "background_hatch_scale": 12.0, 
  "background_hatch_weight": 1.0, 
  "border_line_alpha": 1.0, 
  "border_line_cap": "butt", 
  "border_line_color": null, 
  "border_line_dash": [], 
  "border_line_dash_offset": 0, 
  "border_line_join": "bevel", 
  "border_line_width": 1, 
  "border_radius": 0, 
  "context_menu": null, 
  "coordinates": null, 
  "css_classes": [], 
  "css_variables": {
    "type": "map"
  }, 
  "elements": [], 
  "group": null, 
  "html_attributes": {
    "type": "map"
  }, 
  "html_id": null, 
  "id": "p54509", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "level": "annotation", 
  "name": null, 
  "offset": 0, 
  "padding": 0, 
  "propagate_hover": false, 
  "renderers": [], 
  "standoff": 10, 
  "styles": {
    "type": "map"
  }, 
  "stylesheets": [], 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": [], 
  "text": "", 
  "text_alpha": 1.0, 
  "text_color": "#444444", 
  "text_font": "helvetica", 
  "text_font_size": "13px", 
  "text_font_style": "bold", 
  "text_line_height": 1.0, 
  "text_outline_color": null, 
  "vertical_align": "bottom", 
  "visible": true, 
  "x_range_name": "default", 
  "y_range_name": "default"
}

align = 'left'

Type:

Enum(TextAlign)

文本在其封闭空间内的对齐方式，沿着文本的方向。

background_fill_alpha = 1.0

Type:

Alpha（透明度）

文本边框的填充 alpha 值。

background_fill_color = None

Type:

Nullable(Color)

文本边框的填充颜色值。

background_hatch_alpha = 1.0

Type:

Alpha（透明度）

文本边框的阴影线 alpha 值。

background_hatch_color = None

Type:

Nullable(Color)

文本边框的阴影线颜色值。

background_hatch_extra = {}

Type:

Dict(String, Instance(Texture))

文本边框的阴影线额外值。

background_hatch_pattern = None

Type:

Nullable(String)

文本边框的阴影线图案值。

background_hatch_scale = 12.0

Type:

尺寸

文本边框的阴影线比例值。

background_hatch_weight = 1.0

Type:

尺寸

文本边框的阴影线粗细值。

border_line_alpha = 1.0

Type:

Alpha（透明度）

文本边框的线条 alpha 值。

border_line_cap = 'butt'

Type:

Enum(LineCap)

文本边框的线条端帽值。

border_line_color = None

Type:

Nullable(Color)

文本边框的线条颜色值。

border_line_dash = []

Type:

虚线模式

文本边框的线条虚线值。

border_line_dash_offset = 0

Type:

整数

文本边框的线条虚线偏移值。

border_line_join = 'bevel'

Type:

Enum(LineJoin)

文本边框的线条连接值。

border_line_width = 1

Type:

浮点数

文本边框的线条宽度值。

border_radius = 0

Type:

Either(NonNegative, Tuple(NonNegative, NonNegative, NonNegative, NonNegative), Struct)

允许标签的框具有圆角。为了获得最佳效果，应与 padding 结合使用。

注意

此属性是实验性的，随时可能更改。

context_menu = None

Type:

Nullable(Instance(‘.models.ui.Menu’))

当用户右键单击组件时显示的菜单。

注意

右键单击时使用 shift 键显示原生上下文菜单。

css_classes = []

Type:

List

要添加到底层 DOM 元素的其他 CSS 类列表。

css_variables = {}

Type:

Dict(String, Either(String, Instance(Node)))

允许定义动态计算的 CSS 变量。

例如，这可以用于协调画布渲染器和/或视觉效果与基于 HTML 的 UI 元素之间的定位和样式设置。

此处定义的变量等效于在 CSS 样式表中的 :host { ... } 下设置相同的变量。

注意

此属性是实验性的，随时可能更改。

elements = []

Type:

List

附加到此渲染器的基于 DOM 的 UI 元素集合。

这可以包括浮动元素（如工具提示），从而允许在此渲染器及其 UI 元素之间建立父子关系。

注意

此属性等效于基于 DOM 的 UI 中的 Pane.elements。

group = None

Type:

Nullable(Instance(RendererGroup))

注意

此属性是实验性的，随时可能更改。

html_attributes = {}

Type:

Dict(String, String)

允许在底层 HTML 元素上配置 HTML 属性。

html_id = None

Type:

Nullable(String)

设置底层 HTML 元素的 id 属性。

这是常用 HTML id 属性的简写形式。或者，id 也可以在 html_attributes 字典中设置。html_id 优先。

level = 'annotation'

Type:

Enum(RenderLevel)

指定绘制此渲染器的层级。

name = None

Type:

Nullable(String)

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

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

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

注意

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

offset = 0

Type:

浮点数

以像素为单位偏移文本（可以是正数或负数）。根据标题的位置在不同方向上移动文本

• 上方：向右移动标题

• 右侧：向下移动标题

• 下方：向右移动标题

• 左侧：向上移动标题

padding = 0

Type:

Either(NonNegative, Tuple(NonNegative, NonNegative), Struct, Tuple(NonNegative, NonNegative, NonNegative, NonNegative), Struct)

标签文本与其边框之间额外的空间。

注意

此属性是实验性的，随时可能更改。

propagate_hover = False

Type:

布尔值

允许将悬停事件传播到父级渲染器、框架或画布。

注意

此属性是实验性的，随时可能更改。

renderers = []

Type:

List

附加到此渲染器的一组渲染器。

注意

此属性是实验性的，随时可能更改。

standoff = 10

Type:

浮点数

styles = {}

Type:

Either(Dict(String, Nullable(String)), Instance(Styles))

应用于底层 DOM 元素的内联 CSS 样式。

stylesheets = []

Type:

List

用于底层 DOM 元素的其他样式表。

请注意，所有 Bokeh 组件都使用 shadow DOM，因此任何包含的样式表都必须反映这一点，例如，使用 :host CSS 伪选择器来访问根 DOM 元素。

syncable = True

Type:

布尔值

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

注意

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

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

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

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

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

注意

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

text = ''

Type:

String

要渲染的文本值。

text_alpha = 1.0

Type:

Alpha（透明度）

用于填充文本的透明度值。

可接受的值是介于 0 和 1 之间的浮点数（0 为完全透明，1 为完全不透明）。

text_color = '#444444'

Type:

颜色

用于填充文本的颜色。

可接受的值包括：

• 任何 命名的 CSS 颜色，例如 'green'、'indigo'

• RGB(A) 十六进制字符串，例如，'#FF0000'、'#44444444'

• CSS4 颜色字符串，例如，'rgba(255, 0, 127, 0.6)'、'rgb(0 127 0 / 1.0)' 或 'hsl(60deg 100% 50% / 1.0)'

• 由介于 0 到 255 之间的整数组成的 3 元组 (r, g, b)

• 由 (r, g, b, a) 组成的 4 元组，其中 r、g、b 是介于 0 到 255 之间的整数，a 介于 0 和 1 之间

• 使用 0xRRGGBBAA 字节顺序模式的 32 位无符号整数

text_font = 'helvetica'

Type:

String

用于渲染文本的字体名称，例如，'times'、'helvetica'。

text_font_style = 'bold'

Type:

Enum(FontStyle)

用于渲染文本的样式。

可接受的值包括：

• 'normal' 正常文本

• 'italic' 斜体文本

• 'bold' 粗体文本

text_line_height = 1.0

Type:

浮点数

应该为标题分配多少额外空间。该值以数字形式提供，但应视为字体大小的百分比。默认值为 100%，这意味着不会使用额外的空间。

text_outline_color = None

Type:

Nullable(Color)

用于填充文本的颜色。

vertical_align = 'bottom'

Type:

Enum(VerticalAlign)

文本在其封闭空间内的对齐方式，横跨文本方向。

visible = True

Type:

布尔值

渲染器是否可见。

x_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）x 轴范围。如果未设置，则使用默认 x 轴范围。

y_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）y 轴范围。如果未设置，则使用默认 y 轴范围。

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

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

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

参数:

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

返回值:

None

classmethod clear_extensions() → None

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

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

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

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

classmethod dataspecs() → dict[str, DataSpec]

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

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

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

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

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

参数:

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

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

返回值:

None

示例

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

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

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 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]]

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

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

返回值:

具有引用的属性的名称

Return type:

set[str]

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

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

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

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

参数:

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

返回值:

从属性名称到其值的映射

Return type:

dict

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

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

参数:

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

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

返回值:

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

Return type:

dict

references() → set[Model]

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

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

从此对象中删除回调

描述：选择与选择器匹配的所有模型。

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

参数:

selector (JSON-like)

返回值:

seq[Model]

描述：选择与选择器匹配的第一个模型，如果没有模型匹配，则返回 None。

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

返回值:

Model

描述：从 JSON 数据设置属性值。

从 JSON 在此对象上设置属性值。

参数:

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

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

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

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

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

返回值:

None

描述：使用给定的更新字典设置与选择器匹配的模型的属性。

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

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

描述：返回当前主题的值的字典。

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

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

返回值:

dict 或 None

描述：将对象转换为可序列化的表示形式。

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

描述：触发属性更改的通知。

描述：取消应用当前主题。

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

返回值:

None

描述：批量设置多个属性。

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

返回值:

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)

描述：与此模型关联的文档，如果没有，则为 None。

此模型附加到的 Document (可以为 None)

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

Bases: CustomDimensional

英制长度单位。

JSON 原型

{
  "basis": {
    "entries": [
      [
        "in", 
        [
          0.08333333333333333, 
          "in", 
          "inch"
        ]
      ], 
      [
        "ft", 
        [
          1, 
          "ft", 
          "foot"
        ]
      ], 
      [
        "yd", 
        [
          3, 
          "yd", 
          "yard"
        ]
      ], 
      [
        "ch", 
        [
          66, 
          "ch", 
          "chain"
        ]
      ], 
      [
        "fur", 
        [
          660, 
          "fur", 
          "furlong"
        ]
      ], 
      [
        "mi", 
        [
          5280, 
          "mi", 
          "mile"
        ]
      ], 
      [
        "lea", 
        [
          15840, 
          "lea", 
          "league"
        ]
      ]
    ], 
    "type": "map"
  }, 
  "exclude": [], 
  "id": "p54556", 
  "include": null, 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "name": null, 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": [], 
  "ticks": [
    1, 
    3, 
    6, 
    12, 
    60
  ]
}

描述：英制单位的基础定义。

Type:

Required(Dict(String, Either(Tuple(Float, String), Tuple(Float, String, String))))

定义测量单位的基础。

这包括短单位名称与其对应的比例因子、TeX 名称和可选长名称之间的映射。例如，定义角度测量单位的基础是

basis = {
    "°":  (1,      "^\circ",           "degree"),
    "'":  (1/60,   "^\prime",          "minute"),
    "''": (1/3600, "^{\prime\prime}", "second"),
}

描述：要排除的属性名称列表。

Type:

List

要避免的基础单位的子集。

描述：要包含的特定属性名称集合 (默认全部包含)。

Type:

Nullable(List)

基础中首选单位的可选子集。

描述：此对象的名称。

Type:

Nullable(String)

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

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

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

注意

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

描述：此对象是否应同步到客户端。

Type:

布尔值

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

注意

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

描述：用户定义的标签，可以附加到此对象。

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

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

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

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

注意

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

描述：有用的刻度值列表。

Type:

Required(List)

在非精确模式下选择的首选值。

描述：从此主题应用属性值。

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

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

参数:

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

返回值:

None

描述：清除此类的所有扩展。

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

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

描述：返回此对象的副本。

复制一个 HasProps 对象。

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

描述：返回此类的所有数据规格属性。

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

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

返回值:

DataSpec 属性的名称

Return type:

set[str]

描述：返回此类的所有属性描述符。

属性描述符列表，按定义顺序排列。

描述：执行任何必要的清理。

清理对文档和属性的引用

描述：如果此对象在所有方面都等于另一个对象，则返回 True。

模型的结构相等性。

参数:

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

返回值:

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

描述：在 JavaScript 中，将此对象的属性链接到另一个模型的属性。

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

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

参数:

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

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

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

• attr_selector (int | str) – 用于链接可下标 attr 中项目的索引

Added in version 1.1

Raises:

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)

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]"
    )
)

描述：注册一个 JavaScript 回调，以在此对象的属性更改时执行。

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

描述：按名称查找属性描述符。

给定属性名称，查找类上 Bokeh 属性的 PropertyDescriptor。

参数:

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

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

返回值:

名为 name 的属性的描述符

Return type:

PropertyDescriptor

描述：为属性添加一个回调，以在属性更改时执行。

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

参数:

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

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

返回值:

None

示例

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

描述：为事件添加回调，以在事件触发时执行。

在此 Model 上指定的事件发生时运行回调

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

描述：返回此类的 __init__ 方法的所有参数。

生成适用于从 glyph 派生的函数的 Python Parameter 值。

返回值:

list(Parameter)

描述：获取此类的所有属性的集合。

收集此类上的属性名称。

警告

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

返回值:

属性名称

描述：获取此类的所有属性，这些属性的值是 HasProps 或 Model 的实例。

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

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

返回值:

具有引用的属性的名称

Return type:

set[str]

描述：获取此类的所有属性及其值，可选地包括默认值或未定义的值。

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

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

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

参数:

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

返回值:

从属性名称到其值的映射

Return type:

dict

描述：获取此类的属性及其值，并根据查询函数进行过滤，可选地包括默认值或未定义的值。

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

参数:

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

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

返回值:

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

Return type:

dict

描述：返回此对象引用的所有模型的集合。

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

描述：从此属性中删除先前添加的任何回调。

从此对象中删除回调

选择(选择器: SelectorType) → Iterable[模型]

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

参数:

selector (JSON-like)

返回值:

seq[Model]

选择一个(选择器: SelectorType) → 模型 | None

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

返回值:

Model

从_JSON_设置(名称: str, 值: Any, *, 设置器: Setter | None = None) → None

从 JSON 在此对象上设置属性值。

参数:

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

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

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

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

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

返回值:

None

设置_选择(选择器: type[模型] | SelectorType, 更新: dict[str, Any]) → None

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

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

主题化_值() → dict[str, Any] | None

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

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

返回值:

dict 或 None

序列化(序列化器: Serializer) → ObjectRefRep

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

触发(属性: str, 旧值: Any, 新值: Any, 提示: DocumentPatchedEvent | None = None, 设置器: Setter | None = None) → None

取消_应用_主题() → None

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

返回值:

None

更新(**kwargs: Any) → None

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

返回值:

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)

属性 文档: 文档 | None

此模型附加到的 Document (可以为 None)

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

基类: TextAnnotation

将单个文本标签渲染为注释。

Label will render a single text label at given x and y coordinates, which can be in either screen (pixel) space, or data (axis range) space.

The label can also be configured with a screen space offset from x and y, by using the x_offset and y_offset properties.

Additionally, the label can be rotated with the angle property.

There are also standard text, fill, and line properties to control the appearance of the text, its background, as well as the rectangular bounding box border.

See Labels for information on plotting labels.

JSON 原型

{
  "anchor": "auto", 
  "angle": 0, 
  "angle_units": "rad", 
  "background_fill_alpha": 1.0, 
  "background_fill_color": null, 
  "background_hatch_alpha": 1.0, 
  "background_hatch_color": "black", 
  "background_hatch_extra": {
    "type": "map"
  }, 
  "background_hatch_pattern": null, 
  "background_hatch_scale": 12.0, 
  "background_hatch_weight": 1.0, 
  "border_line_alpha": 1.0, 
  "border_line_cap": "butt", 
  "border_line_color": null, 
  "border_line_dash": [], 
  "border_line_dash_offset": 0, 
  "border_line_join": "bevel", 
  "border_line_width": 1, 
  "border_radius": 0, 
  "context_menu": null, 
  "coordinates": null, 
  "css_classes": [], 
  "css_variables": {
    "type": "map"
  }, 
  "direction": "anticlock", 
  "editable": false, 
  "elements": [], 
  "group": null, 
  "html_attributes": {
    "type": "map"
  }, 
  "html_id": null, 
  "id": "p54564", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "level": "annotation", 
  "name": null, 
  "padding": 0, 
  "propagate_hover": false, 
  "renderers": [], 
  "styles": {
    "type": "map"
  }, 
  "stylesheets": [], 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": [], 
  "text": "", 
  "text_align": "left", 
  "text_alpha": 1.0, 
  "text_baseline": "bottom", 
  "text_color": "#444444", 
  "text_font": "helvetica", 
  "text_font_size": "16px", 
  "text_font_style": "normal", 
  "text_line_height": 1.2, 
  "text_outline_color": null, 
  "visible": true, 
  "x": {
    "name": "unset", 
    "type": "symbol"
  }, 
  "x_offset": 0, 
  "x_range_name": "default", 
  "x_units": "data", 
  "y": {
    "name": "unset", 
    "type": "symbol"
  }, 
  "y_offset": 0, 
  "y_range_name": "default", 
  "y_units": "data"
}

锚点 = 'auto'

Type:

Either(Either(Enum(Anchor), Tuple(Either(Enum(Align), Enum(HAlign), Percent), Either(Enum(Align), Enum(VAlign), Percent))), Auto)

标签文本边界框内的位置，x 和 y 坐标将锚定到该位置。

注意

此属性是实验性的，随时可能更改。

角度 = 0

Type:

角度

文本旋转的角度，从水平方向测量。

角度_单位 = 'rad'

Type:

Enum(AngleUnits)

单位的可接受值是 "rad" 和 "deg"。

背景_填充_alpha = 1.0

Type:

Alpha（透明度）

文本边框的填充 alpha 值。

背景_填充_颜色 = None

Type:

Nullable(Color)

文本边框的填充颜色值。

背景_阴影_alpha = 1.0

Type:

Alpha（透明度）

文本边框的阴影线 alpha 值。

背景_阴影_颜色 = 'black'

Type:

Nullable(Color)

文本边框的阴影线颜色值。

背景_阴影_额外参数 = {}

Type:

Dict(String, Instance(Texture))

文本边框的阴影线额外值。

背景_阴影_图案 = None

Type:

Nullable(String)

文本边框的阴影线图案值。

背景_阴影_缩放 = 12.0

Type:

尺寸

文本边框的阴影线比例值。

背景_阴影_粗细 = 1.0

Type:

尺寸

文本边框的阴影线粗细值。

边框_线条_alpha = 1.0

Type:

Alpha（透明度）

文本边框的线条 alpha 值。

边框_线条_端帽 = 'butt'

Type:

Enum(LineCap)

文本边框的线条端帽值。

边框_线条_颜色 = None

Type:

Nullable(Color)

文本边框的线条颜色值。

边框_线条_虚线 = []

Type:

虚线模式

文本边框的线条虚线值。

边框_线条_虚线_偏移 = 0

Type:

整数

文本边框的线条虚线偏移值。

边框_线条_连接 = 'bevel'

Type:

Enum(LineJoin)

文本边框的线条连接值。

边框_线条_宽度 = 1

Type:

浮点数

文本边框的线条宽度值。

边框_半径 = 0

Type:

Either(NonNegative, Tuple(NonNegative, NonNegative, NonNegative, NonNegative), Struct)

允许标签的框具有圆角。为了获得最佳效果，应与 padding 结合使用。

注意

此属性是实验性的，随时可能更改。

上下文_菜单 = None

Type:

Nullable(Instance(‘.models.ui.Menu’))

当用户右键单击组件时显示的菜单。

注意

右键单击时使用 shift 键显示原生上下文菜单。

CSS_类 = []

Type:

List

要添加到底层 DOM 元素的其他 CSS 类列表。

CSS_变量 = {}

Type:

Dict(String, Either(String, Instance(Node)))

允许定义动态计算的 CSS 变量。

例如，这可以用于协调画布渲染器和/或视觉效果与基于 HTML 的 UI 元素之间的定位和样式设置。

此处定义的变量等效于在 CSS 样式表中的 :host { ... } 下设置相同的变量。

注意

此属性是实验性的，随时可能更改。

方向 = 'anticlock'

Type:

Enum(Direction)

标签角度的方向。

注意

此属性是实验性的，随时可能更改。

可编辑 = False

Type:

布尔值

允许交互式修改此标签的几何形状。

注意

此属性是实验性的，随时可能更改。

元素 = []

Type:

List

附加到此渲染器的基于 DOM 的 UI 元素集合。

这可以包括浮动元素（如工具提示），从而允许在此渲染器及其 UI 元素之间建立父子关系。

注意

此属性等效于基于 DOM 的 UI 中的 Pane.elements。

组 = None

Type:

Nullable(Instance(RendererGroup))

注意

此属性是实验性的，随时可能更改。

HTML_属性 = {}

Type:

Dict(String, String)

允许在底层 HTML 元素上配置 HTML 属性。

HTML_ID = None

Type:

Nullable(String)

设置底层 HTML 元素的 id 属性。

这是常用 HTML id 属性的简写形式。或者，id 也可以在 html_attributes 字典中设置。html_id 优先。

层级 = 'annotation'

Type:

Enum(RenderLevel)

指定绘制此渲染器的层级。

名称 = None

Type:

Nullable(String)

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

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

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

注意

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

内边距 = 0

Type:

Either(NonNegative, Tuple(NonNegative, NonNegative), Struct, Tuple(NonNegative, NonNegative, NonNegative, NonNegative), Struct)

标签文本与其边框之间额外的空间。

注意

此属性是实验性的，随时可能更改。

传递_悬停 = False

Type:

布尔值

允许将悬停事件传播到父级渲染器、框架或画布。

注意

此属性是实验性的，随时可能更改。

渲染器 = []

Type:

List

附加到此渲染器的一组渲染器。

注意

此属性是实验性的，随时可能更改。

样式 = {}

Type:

Either(Dict(String, Nullable(String)), Instance(Styles))

应用于底层 DOM 元素的内联 CSS 样式。

样式表 = []

Type:

List

用于底层 DOM 元素的其他样式表。

请注意，所有 Bokeh 组件都使用 shadow DOM，因此任何包含的样式表都必须反映这一点，例如，使用 :host CSS 伪选择器来访问根 DOM 元素。

可同步 = True

Type:

布尔值

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

注意

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

标签 = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

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

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

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

注意

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

文本 = ''

Type:

文本类型

要渲染的文本或 LaTeX 符号。

文本_对齐 = 'left'

Type:

Enum(TextAlign)

文本的文本对齐值。

文本_alpha = 1.0

Type:

Alpha（透明度）

文本的文本 alpha 值。

文本_基线 = 'bottom'

Type:

Enum(TextBaseline)

文本的文本基线值。

文本_颜色 = '#444444'

Type:

Nullable(Color)

文本的文本颜色值。

文本_字体 = 'helvetica'

Type:

String

文本的文本字体值。

文本_字体_大小 = '16px'

Type:

FontSize

文本的文本字体大小值。

文本_字体_样式 = 'normal'

Type:

Enum(FontStyle)

文本的文本字体样式值。

文本_行_高度 = 1.2

Type:

浮点数

文本的文本行高值。

文本_轮廓_颜色 = None

Type:

Nullable(Color)

文本的文本轮廓颜色值。

可见 = True

Type:

布尔值

渲染器是否可见。

x = Undefined

Type:

Required(Either(Either(Float, Datetime, Factor), Instance(Node)))

屏幕坐标中用于定位文本锚点的 x 坐标。

x_偏移 = 0

Type:

浮点数

应用于 x 坐标的偏移值。

例如，如果希望将文本在 屏幕单位 中从给定的数据位置“浮动”固定距离，这将非常有用。

x_范围_名称 = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）x 轴范围。如果未设置，则使用默认 x 轴范围。

x_单位 = 'data'

Type:

Enum(CoordinateUnits)

x 属性的单位类型。默认解释为数据单位。如果 x 是节点，则这没有任何效果。

y = Undefined

Type:

Required(Either(Either(Float, Datetime, Factor), Instance(Node)))

屏幕坐标中用于定位文本锚点的 y 坐标。

y_偏移 = 0

Type:

浮点数

应用于 y 坐标的偏移值。

例如，如果希望将文本在 屏幕单位 中从给定的数据位置“浮动”固定距离，这将非常有用。

y_范围_名称 = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）y 轴范围。如果未设置，则使用默认 y 轴范围。

y_单位 = 'data'

Type:

Enum(CoordinateUnits)

y 属性的单位类型。默认解释为数据单位。如果 y 是节点，则这没有任何效果。

应用_主题(属性_值: dict[str, Any]) → None

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

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

参数:

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

返回值:

None

类方法 清除_扩展() → None

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

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

克隆(**覆盖: Any) → Self

复制一个 HasProps 对象。

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

类方法 数据规格() → dict[str, DataSpec]

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

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

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

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

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

参数:

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

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

返回值:

None

示例

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

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

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 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]]

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

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

返回值:

具有引用的属性的名称

Return type:

set[str]

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

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

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

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

参数:

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

返回值:

从属性名称到其值的映射

Return type:

dict

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

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

参数:

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

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

返回值:

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

Return type:

dict

references() → set[Model]

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

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

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

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

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

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

返回值:

Model

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

从 JSON 在此对象上设置属性值。

参数:

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

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

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

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

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

返回值:

None

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

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

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

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

返回值:

None

update(**kwargs: Any) → None

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

返回值:

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 LabelSet(*args: Any, id: ID | None = None, **kwargs: Any)

Bases: DataAnnotation

将多个文本标签渲染为注释。

LabelSet 将在给定的 x 和 y 坐标处渲染多个文本标签，这些坐标可以是屏幕（像素）空间或数据（轴范围）空间。在这种情况下（与单个 Label 模型相反），x 和 y 也可以是来自 ColumnDataSource 的列的名称，在这种情况下，标签将使用指定列的坐标值进行“向量化”。

标签还可以通过使用 x_offset 和 y_offset 属性，配置与 x 和 y 的屏幕空间偏移。

这些偏移可以通过提供数据源列的名称进行向量化。

There are also standard text, fill, and line properties to control the appearance of the text, its background, as well as the rectangular bounding box border.

此外，标签可以使用 angle 属性旋转（这也可能是列名）。

JSON 原型

{
  "angle": {
    "type": "value", 
    "value": 0
  }, 
  "background_fill_alpha": {
    "type": "value", 
    "value": 1.0
  }, 
  "background_fill_color": {
    "type": "value", 
    "value": null
  }, 
  "background_hatch_alpha": {
    "type": "value", 
    "value": 1.0
  }, 
  "background_hatch_color": {
    "type": "value", 
    "value": "black"
  }, 
  "background_hatch_extra": {
    "type": "map"
  }, 
  "background_hatch_pattern": {
    "type": "value", 
    "value": null
  }, 
  "background_hatch_scale": {
    "type": "value", 
    "value": 12.0
  }, 
  "background_hatch_weight": {
    "type": "value", 
    "value": 1.0
  }, 
  "border_line_alpha": {
    "type": "value", 
    "value": 1.0
  }, 
  "border_line_cap": {
    "type": "value", 
    "value": "butt"
  }, 
  "border_line_color": {
    "type": "value", 
    "value": null
  }, 
  "border_line_dash": {
    "type": "value", 
    "value": []
  }, 
  "border_line_dash_offset": {
    "type": "value", 
    "value": 0
  }, 
  "border_line_join": {
    "type": "value", 
    "value": "bevel"
  }, 
  "border_line_width": {
    "type": "value", 
    "value": 1
  }, 
  "context_menu": null, 
  "coordinates": null, 
  "css_classes": [], 
  "css_variables": {
    "type": "map"
  }, 
  "elements": [], 
  "group": null, 
  "html_attributes": {
    "type": "map"
  }, 
  "html_id": null, 
  "id": "p54621", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "level": "annotation", 
  "name": null, 
  "propagate_hover": false, 
  "renderers": [], 
  "source": {
    "attributes": {
      "data": {
        "type": "map"
      }, 
      "selected": {
        "attributes": {
          "indices": [], 
          "line_indices": []
        }, 
        "id": "p54623", 
        "name": "Selection", 
        "type": "object"
      }, 
      "selection_policy": {
        "id": "p54624", 
        "name": "UnionRenderers", 
        "type": "object"
      }
    }, 
    "id": "p54622", 
    "name": "ColumnDataSource", 
    "type": "object"
  }, 
  "styles": {
    "type": "map"
  }, 
  "stylesheets": [], 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": [], 
  "text": {
    "field": "text", 
    "type": "field"
  }, 
  "text_align": {
    "type": "value", 
    "value": "left"
  }, 
  "text_alpha": {
    "type": "value", 
    "value": 1.0
  }, 
  "text_baseline": {
    "type": "value", 
    "value": "bottom"
  }, 
  "text_color": {
    "type": "value", 
    "value": "#444444"
  }, 
  "text_font": {
    "type": "value", 
    "value": "helvetica"
  }, 
  "text_font_size": {
    "type": "value", 
    "value": "16px"
  }, 
  "text_font_style": {
    "type": "value", 
    "value": "normal"
  }, 
  "text_line_height": {
    "type": "value", 
    "value": 1.2
  }, 
  "text_outline_color": {
    "type": "value", 
    "value": null
  }, 
  "visible": true, 
  "x": {
    "field": "x", 
    "type": "field"
  }, 
  "x_offset": {
    "type": "value", 
    "value": 0
  }, 
  "x_range_name": "default", 
  "x_units": "data", 
  "y": {
    "field": "y", 
    "type": "field"
  }, 
  "y_offset": {
    "type": "value", 
    "value": 0
  }, 
  "y_range_name": "default", 
  "y_units": "data"
}

angle = 0

Type:

AngleSpec

要旋转文本的角度，从水平方向测量。

angle_units = 'rad'

Type:

NotSerialized(Enum(AngleUnits))

用于关联属性的单位：deg、rad、grad 或 turn

background_fill_alpha = 1.0

Type:

AlphaSpec

文本边框的填充 alpha 值。

background_fill_color = None

Type:

ColorSpec

文本边框的填充颜色值。

background_hatch_alpha = 1.0

Type:

AlphaSpec

文本边框的阴影线 alpha 值。

background_hatch_color = 'black'

Type:

ColorSpec

文本边框的阴影线颜色值。

background_hatch_extra = {}

Type:

Dict(String, Instance(Texture))

文本边框的阴影线额外值。

background_hatch_pattern = None

Type:

HatchPatternSpec

文本边框的阴影线图案值。

background_hatch_scale = 12.0

Type:

FloatSpec

文本边框的阴影线比例值。

background_hatch_weight = 1.0

Type:

FloatSpec

文本边框的阴影线粗细值。

border_line_alpha = 1.0

Type:

AlphaSpec

文本边框的线条 alpha 值。

border_line_cap = '对接'

Type:

LineCapSpec

文本边框的线条端帽值。

border_line_color = None

Type:

ColorSpec

文本边框的线条颜色值。

border_line_dash = []

Type:

DashPatternSpec

文本边框的线条虚线值。

border_line_dash_offset = 0

Type:

IntSpec

文本边框的线条虚线偏移值。

border_line_join = '斜角'

Type:

LineJoinSpec

文本边框的线条连接值。

border_line_width = 1

Type:

FloatSpec

文本边框的线条宽度值。

context_menu = None

Type:

Nullable(Instance(‘.models.ui.Menu’))

当用户右键单击组件时显示的菜单。

注意

右键单击时使用 shift 键显示原生上下文菜单。

css_classes = []

Type:

List

要添加到底层 DOM 元素的其他 CSS 类列表。

css_variables = {}

Type:

Dict(String, Either(String, Instance(Node)))

允许定义动态计算的 CSS 变量。

例如，这可以用于协调画布渲染器和/或视觉效果与基于 HTML 的 UI 元素之间的定位和样式设置。

此处定义的变量等效于在 CSS 样式表中的 :host { ... } 下设置相同的变量。

注意

此属性是实验性的，随时可能更改。

elements = []

Type:

List

附加到此渲染器的基于 DOM 的 UI 元素集合。

这可以包括浮动元素（如工具提示），从而允许在此渲染器及其 UI 元素之间建立父子关系。

注意

此属性等效于基于 DOM 的 UI 中的 Pane.elements。

group = None

Type:

Nullable(Instance(RendererGroup))

注意

此属性是实验性的，随时可能更改。

html_attributes = {}

Type:

Dict(String, String)

允许在底层 HTML 元素上配置 HTML 属性。

html_id = None

Type:

Nullable(String)

设置底层 HTML 元素的 id 属性。

这是常用 HTML id 属性的简写形式。或者，id 也可以在 html_attributes 字典中设置。html_id 优先。

level = 'annotation'

Type:

Enum(RenderLevel)

指定绘制此渲染器的层级。

name = None

Type:

Nullable(String)

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

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

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

注意

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

propagate_hover = False

Type:

布尔值

允许将悬停事件传播到父级渲染器、框架或画布。

注意

此属性是实验性的，随时可能更改。

renderers = []

Type:

List

附加到此渲染器的一组渲染器。

注意

此属性是实验性的，随时可能更改。

source = ColumnDataSource(id='p54741', ...)

Type:

Instance(DataSource)

用于在绘图上渲染注释的本地数据源。

styles = {}

Type:

Either(Dict(String, Nullable(String)), Instance(Styles))

应用于底层 DOM 元素的内联 CSS 样式。

stylesheets = []

Type:

List

用于底层 DOM 元素的其他样式表。

请注意，所有 Bokeh 组件都使用 shadow DOM，因此任何包含的样式表都必须反映这一点，例如，使用 :host CSS 伪选择器来访问根 DOM 元素。

syncable = True

Type:

布尔值

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

注意

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

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

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

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

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

注意

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

text = Field(field='text', transform=Unspecified, units=Unspecified)

Type:

NullStringSpec

要渲染的文本值。

text_align = '左'

Type:

TextAlignSpec

文本的文本对齐值。

text_alpha = 1.0

Type:

AlphaSpec

文本的文本 alpha 值。

text_baseline = '底部'

Type:

TextBaselineSpec

文本的文本基线值。

text_color = '#444444'

Type:

ColorSpec

文本的文本颜色值。

text_font = Value(value='helvetica', transform=Unspecified, units=Unspecified)

Type:

StringSpec

文本的文本字体值。

text_font_size = Value(value='16px', transform=Unspecified, units=Unspecified)

Type:

FontSizeSpec

文本的文本字体大小值。

text_font_style = '正常'

Type:

FontStyleSpec

文本的文本字体样式值。

text_line_height = 1.2

Type:

NumberSpec

文本的文本行高值。

text_outline_color = None

Type:

ColorSpec

文本的文本轮廓颜色值。

visible = True

Type:

布尔值

渲染器是否可见。

x = Field(field='x', transform=Unspecified, units=Unspecified)

Type:

NumberSpec

用于定位文本锚点的 x 坐标。

x_offset = 0

Type:

NumberSpec

应用于 x 坐标的偏移值。

例如，如果希望将文本在 屏幕单位 中从给定的数据位置“浮动”固定距离，这将非常有用。

x_range_name = '默认'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）x 轴范围。如果未设置，则使用默认 x 轴范围。

x_units = '数据'

Type:

Enum(CoordinateUnits)

xs 属性的单位类型。默认解释为数据单位。

y = Field(field='y', transform=Unspecified, units=Unspecified)

Type:

NumberSpec

用于定位文本锚点的 y 坐标。

y_offset = 0

Type:

NumberSpec

应用于 y 坐标的偏移值。

例如，如果希望将文本在 屏幕单位 中从给定的数据位置“浮动”固定距离，这将非常有用。

y_range_name = '默认'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）y 轴范围。如果未设置，则使用默认 y 轴范围。

y_units = '数据'

Type:

Enum(CoordinateUnits)

ys 属性的单位类型。默认解释为数据单位。

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

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

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

参数:

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

返回值:

None

classmethod clear_extensions() → None

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

序列化调用将导致任何当前定义的自定义扩展包含在生成的文档中，无论是否被使用。此方法可用于清除所有现有的自定义扩展定义。

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

这将创建原始模型的浅克隆，即任何可变容器或子模型都不会被复制。允许在克隆时覆盖特定属性。

classmethod dataspecs() → dict)[str, DataSpec]

收集此类上所有 DataSpec 属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

on_change(attr: str, *callbacks: PropertyCallback) → None

在此对象上添加回调，以便在 attr 更改时触发。

参数:

• attr (str) – 此对象上的属性名称

• *callbacks (callable) – 要注册的回调函数

返回值:

None

示例

widget.on_change('value', callback1, callback2, ..., callback_n)

on_event(event: str | type)[Event], *callbacks: Callable[[Event], None]] | Callable[[], None]]) → None

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 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]]

收集此类上所有也具有引用的属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

具有引用的属性的名称

Return type:

set[str]

properties_with_values(*, include_defaults: bool = True, include_undefined: bool = False) → dict)[str, Any]

收集一个字典，将属性名称映射到它们的值。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

不可序列化的属性将被跳过，并且属性值采用“序列化”格式，这可能与您通常从属性中读取的值略有不同；此方法的目的是返回无损地重构对象实例所需的信息。

参数:

include_defaults (bool, 可选) – 是否包含自对象创建以来尚未显式设置的属性。（默认值：True）

返回值:

从属性名称到其值的映射

Return type:

dict

query_properties_with_values(query: Callable)[]PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) → dict)[str, Any]

使用谓词查询 HasProps 实例的属性值。

参数:

• query (callable) – 一个可调用对象，它接受属性描述符并返回 True 或 False

• include_defaults (bool, 可选) – 是否包含用户尚未显式设置的属性（默认值：True）

返回值:

匹配属性的属性名称和值的映射

Return type:

dict

references() → set)[Model]

返回此对象引用的所有 Models。

remove_on_change(attr: str, *callbacks: Callable[[str, Any, Any], None]) → None

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

查询此对象及其所有引用，以查找与给定选择器匹配的对象。

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

查询此对象及其所有引用，以查找与给定选择器匹配的对象。如果找到多个对象，则引发错误。返回单个匹配对象，如果未找到任何对象，则返回 None :param selector: :type selector: JSON-like

返回值:

Model

set_from_json(name: str, value: Any, *, setter: Setter | None = None) → None

从 JSON 在此对象上设置属性值。

参数:

• name (str) – 要设置的属性的名称

• value (JSON-value) – 要设置为属性的值

• setter (ClientSession 或 ServerSession 或 None, 可选) –

  这用于防止对 Bokeh 应用程序的“回旋镖”更新。

  在 Bokeh 服务器应用程序的上下文中，传入的属性更新将使用正在执行更新的会话进行注释。此值会通过更新触发的任何后续更改通知进行传播。会话可以将事件 setter 与自身进行比较，并抑制任何源自自身的更新。

返回值:

None

set_select(selector: type[Model] | SelectorType, updates: dict[str, Any]) → None

使用指定的属性/值更新来更新与给定选择器匹配的对象。

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

删除任何主题值并恢复默认值。

返回值:

None

update(**kwargs: Any) → None

从给定的关键字参数更新对象的属性。

返回值:

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 Legend(*args: Any, id: ID | None = None, **kwargs: Any)

Bases: Annotation

为绘图渲染信息图例。

有关绘制图例的信息，请参阅图例。

JSON 原型

{
  "background_fill_alpha": 0.95, 
  "background_fill_color": "#ffffff", 
  "background_hatch_alpha": 1.0, 
  "background_hatch_color": "black", 
  "background_hatch_extra": {
    "type": "map"
  }, 
  "background_hatch_pattern": null, 
  "background_hatch_scale": 12.0, 
  "background_hatch_weight": 1.0, 
  "border_line_alpha": 0.5, 
  "border_line_cap": "butt", 
  "border_line_color": "#e5e5e5", 
  "border_line_dash": [], 
  "border_line_dash_offset": 0, 
  "border_line_join": "bevel", 
  "border_line_width": 1, 
  "border_radius": 0, 
  "click_policy": "none", 
  "context_menu": null, 
  "coordinates": null, 
  "css_classes": [], 
  "css_variables": {
    "type": "map"
  }, 
  "elements": [], 
  "glyph_height": 20, 
  "glyph_width": 20, 
  "group": null, 
  "html_attributes": {
    "type": "map"
  }, 
  "html_id": null, 
  "id": "p54836", 
  "inactive_fill_alpha": 0.7, 
  "inactive_fill_color": "white", 
  "inactive_hatch_alpha": 1.0, 
  "inactive_hatch_color": "black", 
  "inactive_hatch_extra": {
    "type": "map"
  }, 
  "inactive_hatch_pattern": null, 
  "inactive_hatch_scale": 12.0, 
  "inactive_hatch_weight": 1.0, 
  "item_background_fill_alpha": 0.8, 
  "item_background_fill_color": "#f1f1f1", 
  "item_background_hatch_alpha": 1.0, 
  "item_background_hatch_color": "black", 
  "item_background_hatch_extra": {
    "type": "map"
  }, 
  "item_background_hatch_pattern": null, 
  "item_background_hatch_scale": 12.0, 
  "item_background_hatch_weight": 1.0, 
  "item_background_policy": "none", 
  "items": [], 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "label_height": "auto", 
  "label_standoff": 5, 
  "label_text_align": "left", 
  "label_text_alpha": 1.0, 
  "label_text_baseline": "middle", 
  "label_text_color": "#444444", 
  "label_text_font": "helvetica", 
  "label_text_font_size": "13px", 
  "label_text_font_style": "normal", 
  "label_text_line_height": 1.2, 
  "label_text_outline_color": null, 
  "label_width": 20, 
  "level": "annotation", 
  "location": "top_right", 
  "margin": 10, 
  "name": null, 
  "ncols": "auto", 
  "nrows": "auto", 
  "orientation": "vertical", 
  "padding": 10, 
  "propagate_hover": false, 
  "renderers": [], 
  "spacing": 3, 
  "styles": {
    "type": "map"
  }, 
  "stylesheets": [], 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": [], 
  "title": null, 
  "title_location": "above", 
  "title_standoff": 5, 
  "title_text_align": "left", 
  "title_text_alpha": 1.0, 
  "title_text_baseline": "bottom", 
  "title_text_color": "#444444", 
  "title_text_font": "helvetica", 
  "title_text_font_size": "13px", 
  "title_text_font_style": "italic", 
  "title_text_line_height": 1.2, 
  "title_text_outline_color": null, 
  "visible": true, 
  "x_range_name": "default", 
  "y_range_name": "default"
}

background_fill_alpha = 0.95

Type:

Alpha（透明度）

图例背景样式的填充 alpha 值。

background_fill_color = '#ffffff'

Type:

Nullable(Color)

图例背景样式的填充颜色。

background_hatch_alpha = 1.0

Type:

Alpha（透明度）

图例背景样式的阴影线 alpha 值。

background_hatch_color = 'black'

Type:

Nullable(Color)

图例背景样式的阴影线颜色。

background_hatch_extra = {}

Type:

Dict(String, Instance(Texture))

图例背景样式的额外阴影线属性。

background_hatch_pattern = None

Type:

Nullable(String)

图例背景样式的阴影线图案。

background_hatch_scale = 12.0

Type:

尺寸

图例背景样式的阴影线比例。

background_hatch_weight = 1.0

Type:

尺寸

图例背景样式的阴影线粗细。

border_line_alpha = 0.5

Type:

Alpha（透明度）

图例边框轮廓的线条 alpha 值。

border_line_cap = 'butt'

Type:

Enum(LineCap)

图例边框轮廓的线条端帽样式。

border_line_color = '#e5e5e5'

Type:

Nullable(Color)

图例边框轮廓的线条颜色。

border_line_dash = []

Type:

虚线模式

图例边框轮廓的线条虚线模式。

border_line_dash_offset = 0

Type:

整数

图例边框轮廓的线条虚线偏移量。

border_line_join = 'bevel'

Type:

Enum(LineJoin)

图例边框轮廓的线条连接样式。

border_line_width = 1

Type:

浮点数

图例边框轮廓的线条宽度。

border_radius = 0

Type:

Either(NonNegative, Tuple(NonNegative, NonNegative, NonNegative, NonNegative), Struct)

允许框具有圆角。

click_policy = 'none'

Type:

Enum(LegendClickPolicy)

定义单击图例项目时发生的情况。

context_menu = None

Type:

Nullable(Instance(‘.models.ui.Menu’))

当用户右键单击组件时显示的菜单。

注意

右键单击时使用 shift 键显示原生上下文菜单。

css_classes = []

Type:

List

要添加到底层 DOM 元素的其他 CSS 类列表。

css_variables = {}

Type:

Dict(String, Either(String, Instance(Node)))

允许定义动态计算的 CSS 变量。

例如，这可以用于协调画布渲染器和/或视觉效果与基于 HTML 的 UI 元素之间的定位和样式设置。

此处定义的变量等效于在 CSS 样式表中的 :host { ... } 下设置相同的变量。

注意

此属性是实验性的，随时可能更改。

elements = []

Type:

List

附加到此渲染器的基于 DOM 的 UI 元素集合。

这可以包括浮动元素（如工具提示），从而允许在此渲染器及其 UI 元素之间建立父子关系。

注意

此属性等效于基于 DOM 的 UI 中的 Pane.elements。

glyph_height = 20

Type:

整数

渲染的图例字形应占用的高度（以像素为单位）。

glyph_width = 20

Type:

整数

渲染的图例字形应占用的宽度（以像素为单位）。

group = None

Type:

Nullable(Instance(RendererGroup))

注意

此属性是实验性的，随时可能更改。

html_attributes = {}

Type:

Dict(String, String)

允许在底层 HTML 元素上配置 HTML 属性。

html_id = None

Type:

Nullable(String)

设置底层 HTML 元素的 id 属性。

这是常用 HTML id 属性的简写形式。或者，id 也可以在 html_attributes 字典中设置。html_id 优先。

inactive_fill_alpha = 0.7

Type:

Alpha（透明度）

当图例项目处于非活动状态时，图例项目样式的填充 alpha 值。 这些控制项目上的叠加层，当相应的字形处于非活动状态时（例如，通过使其半透明），可用于遮盖项目。

inactive_fill_color = 'white'

Type:

Nullable(Color)

当图例项目处于非活动状态时，图例项目样式的填充颜色。 这些控制项目上的叠加层，当相应的字形处于非活动状态时（例如，通过使其半透明），可用于遮盖项目。

inactive_hatch_alpha = 1.0

Type:

Alpha（透明度）

当图例项目处于非活动状态时，图例项目样式的阴影线 alpha 值。 这些控制项目上的叠加层，当相应的字形处于非活动状态时（例如，通过使其半透明），可用于遮盖项目。

inactive_hatch_color = 'black'

Type:

Nullable(Color)

当图例项目处于非活动状态时，图例项目样式的阴影线颜色。 这些控制项目上的叠加层，当相应的字形处于非活动状态时（例如，通过使其半透明），可用于遮盖项目。

inactive_hatch_extra = {}

Type:

Dict(String, Instance(Texture))

当图例项目处于非活动状态时，图例项目样式的额外阴影线属性。 这些控制项目上的叠加层，当相应的字形处于非活动状态时（例如，通过使其半透明），可用于遮盖项目。

inactive_hatch_pattern = None

Type:

Nullable(String)

当图例项目处于非活动状态时，图例项目样式的阴影线图案。 这些控制项目上的叠加层，当相应的字形处于非活动状态时（例如，通过使其半透明），可用于遮盖项目。

inactive_hatch_scale = 12.0

Type:

尺寸

当图例项目处于非活动状态时，图例项目样式的阴影线比例。 这些控制项目上的叠加层，当相应的字形处于非活动状态时（例如，通过使其半透明），可用于遮盖项目。

inactive_hatch_weight = 1.0

Type:

尺寸

当图例项目处于非活动状态时，图例项目样式的阴影线粗细。 这些控制项目上的叠加层，当相应的字形处于非活动状态时（例如，通过使其半透明），可用于遮盖项目。

item_background_fill_alpha = 0.8

Type:

Alpha（透明度）

图例项目背景样式的填充 alpha 值。

item_background_fill_color = '#f1f1f1'

Type:

Nullable(Color)

图例项目背景样式的填充颜色。

item_background_hatch_alpha = 1.0

Type:

Alpha（透明度）

图例项目背景样式的阴影线 alpha 值。

item_background_hatch_color = 'black'

Type:

Nullable(Color)

图例项目背景样式的阴影线颜色。

item_background_hatch_extra = {}

Type:

Dict(String, Instance(Texture))

图例项目背景样式的额外阴影线属性。

item_background_hatch_pattern = None

Type:

Nullable(String)

图例项目背景样式的阴影线图案。

item_background_hatch_scale = 12.0

Type:

尺寸

图例项目背景样式的阴影线比例。

item_background_hatch_weight = 1.0

Type:

尺寸

图例项目背景样式的阴影线粗细。

item_background_policy = 'none'

Type:

Enum(AlternationPolicy)

如果配置了 item_background_fill，则定义要设置样式的项目。

items = []

Type:

List

要在图例中渲染的 LegendItem 实例列表。

可以显式指定，例如

legend = Legend(items=[
    LegendItem(label="sin(x)",   renderers=[r0, r1]),
    LegendItem(label="2*sin(x)", renderers=[r2]),
    LegendItem(label="3*sin(x)", renderers=[r3, r4])
])

但为了方便起见，也可以更紧凑地以元组列表的形式给出

legend = Legend(items=[
    ("sin(x)",   [r0, r1]),
    ("2*sin(x)", [r2]),
    ("3*sin(x)", [r3, r4])
])

其中每个元组的形式为：(label, renderers)。

label_height = 'auto'

Type:

Either(Auto, Int)

图例标签应占用的区域的最小高度（以像素为单位）。

label_standoff = 5

Type:

整数

将标签与其关联的字形分隔开的距离（以像素为单位）。

label_text_align = 'left'

Type:

Enum(TextAlign)

图例标签的文本对齐方式。

label_text_alpha = 1.0

Type:

Alpha（透明度）

图例标签的文本 alpha 值。

label_text_baseline = 'middle'

Type:

Enum(TextBaseline)

图例标签的文本基线。

label_text_color = '#444444'

Type:

Nullable(Color)

图例标签的文本颜色。

label_text_font = 'helvetica'

Type:

String

图例标签的文本字体。

label_text_font_size = '13px'

Type:

FontSize

图例标签的文本字体大小。

label_text_font_style = 'normal'

Type:

Enum(FontStyle)

图例标签的文本字体样式。

label_text_line_height = 1.2

Type:

浮点数

图例标签的文本行高。

label_text_outline_color = None

Type:

Nullable(Color)

图例标签的文本轮廓颜色。

label_width = 20

Type:

整数

图例标签应占用的区域的最小宽度（以像素为单位）。

level = 'annotation'

Type:

Enum(RenderLevel)

指定绘制此渲染器的层级。

location = 'top_right'

Type:

Either(Enum(Anchor), Tuple(Float, Float))

图例应绘制自身的位置。 它可以是 LegendLocation 的枚举值之一，也可以是 (x, y) 元组，指示屏幕坐标中的绝对位置（从左下角开始的像素）。

margin = 10

Type:

整数

图例周围的边距量。

name = None

Type:

Nullable(String)

此模型的一个任意的、用户提供的名称。

当查询文档以检索特定的 Bokeh 模型时，此名称可能很有用。

>>> plot.scatter([1,2,3], [4,5,6], name="temp")
>>> plot.select(name="temp")
[GlyphRenderer(id='399d53f5-73e9-44d9-9527-544b761c7705', ...)]

注意

对于提供的任何名称，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用该名称。

ncols = 'auto'

Type:

Either(Positive, Auto)

图例布局中的列数。 默认情况下，如果方向为垂直，则为一列；否则为图例中项目的数量。 ncols 优先于水平方向的 nrows。

nrows = 'auto'

Type:

Either(Positive, Auto)

图例布局中的行数。 默认情况下，如果方向为水平，则为一行；否则为图例中项目的数量。 nrows 优先于垂直方向的 ncols。

orientation = 'vertical'

Type:

Enum(Orientation)

图例条目在绘制时应垂直还是水平放置。

padding = 10

Type:

Either(NonNegative, Tuple(NonNegative, NonNegative), Struct, Tuple(NonNegative, NonNegative, NonNegative, NonNegative), Struct)

图例内容与其边框之间的内边距量。

仅在边框可见时适用。

propagate_hover = False

Type:

布尔值

允许将悬停事件传播到父级渲染器、框架或画布。

注意

此属性是实验性的，随时可能更改。

renderers = []

Type:

List

附加到此渲染器的一组渲染器。

注意

此属性是实验性的，随时可能更改。

spacing = 3

Type:

整数

图例条目之间的间距量（以像素为单位）。

styles = {}

Type:

Either(Dict(String, Nullable(String)), Instance(Styles))

应用于底层 DOM 元素的内联 CSS 样式。

stylesheets = []

Type:

List

用于底层 DOM 元素的其他样式表。

请注意，所有 Bokeh 组件都使用 shadow DOM，因此任何包含的样式表都必须反映这一点，例如，使用 :host CSS 伪选择器来访问根 DOM 元素。

syncable = True

Type:

布尔值

指示此模型在 Web 浏览器中更新时是否应同步回 Bokeh 服务器。当处理频繁更新的对象而我们不需要其更新值时，设置为 False 可能有助于减少网络流量。

注意

将此属性设置为 False 将阻止此对象上的任何 on_change() 回调被触发。但是，任何 JS 端的回调仍然有效。

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

当查询文档以检索特定的 Bokeh 模型时，此数据可能很有用

>>> r = plot.scatter([1,2,3], [4,5,6])
>>> r.tags = ["foo", 10]
>>> plot.select(tags=['foo', 10])
[GlyphRenderer(id='1de4c3df-a83d-480a-899b-fb263d3d5dd9', ...)]

或者只是将任何必要的元数据附加到可以通过 CustomJS 回调等访问的模型的一种便捷方式。

注意

对于提供的任何标签，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用这些标签。

title = None

Type:

Nullable(String)

要渲染的标题文本。

title_location = 'above'

Type:

Enum(Location)

指定图例标题将位于哪一侧。左侧或右侧的标题将相应旋转。

title_standoff = 5

Type:

整数

标题与图例之间的距离（以像素为单位）。

title_text_align = 'left'

Type:

Enum(TextAlign)

标题文本的文本对齐值。

title_text_alpha = 1.0

Type:

Alpha（透明度）

标题文本的文本 alpha 值。

title_text_baseline = 'bottom'

Type:

Enum(TextBaseline)

标题文本的文本基线值。

title_text_color = '#444444'

Type:

Nullable(Color)

标题文本的文本颜色值。

title_text_font = 'helvetica'

Type:

String

标题文本的文本字体值。

title_text_font_size = '13px'

Type:

FontSize

标题文本的文本字体大小值。

title_text_font_style = 'italic'

Type:

Enum(FontStyle)

标题文本的文本字体样式值。

title_text_line_height = 1.2

Type:

浮点数

标题文本的文本行高值。

title_text_outline_color = None

Type:

Nullable(Color)

标题文本的文本轮廓颜色值。

visible = True

Type:

布尔值

渲染器是否可见。

x_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）x 轴范围。如果未设置，则使用默认 x 轴范围。

y_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）y 轴范围。如果未设置，则使用默认 y 轴范围。

apply_theme(property_values: dict[str, Any]) → None

应用一组主题值，这些值将代替默认值使用，但不会覆盖应用程序设置的值。

传入的字典可以保持原样并与其他实例共享以节省内存（因此调用者和 HasProps 实例都不应修改它）。

参数:

property_values (dict) – 用于代替默认值的主题值

返回值:

None

classmethod clear_extensions() → None

清除任何当前定义的自定义扩展。

序列化调用将导致任何当前定义的自定义扩展包含在生成的文档中，无论是否被使用。此方法可用于清除所有现有的自定义扩展定义。

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

这将创建原始模型的浅克隆，即任何可变容器或子模型都不会被复制。允许在克隆时覆盖特定属性。

classmethod dataspecs() → dict[str, DataSpec]

收集此类上所有 DataSpec 属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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)

js_on_click(handler: JsEventCallback) → None

为图例项目点击设置 JavaScript 处理程序。

classmethod lookup(name: str, *, raises: bool = True) → PropertyDescriptor[Any] | None

给定属性名称，查找类上 Bokeh 属性的 PropertyDescriptor。

参数:

• name (str) – 要搜索的属性的名称

• raises (bool) – 如果缺少，是否引发异常或返回 None

返回值:

名为 name 的属性的描述符

Return type:

PropertyDescriptor

on_change(attr: str, *callbacks: PropertyCallback) → None

在此对象上添加回调，以便在 attr 更改时触发。

参数:

• attr (str) – 此对象上的属性名称

• *callbacks (callable) – 要注册的回调函数

返回值:

None

示例

widget.on_change('value', callback1, callback2, ..., callback_n)

on_click(handler: PyEventCallback) → None

为图例项目点击设置处理程序。

on_event(event: str | type[Event], *callbacks: Callable[[Event], None] | Callable[[], None]) → None

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 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]]

收集此类上所有也具有引用的属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

具有引用的属性的名称

Return type:

set[str]

properties_with_values(*, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

收集一个字典，将属性名称映射到它们的值。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

不可序列化的属性将被跳过，并且属性值采用“序列化”格式，这可能与您通常从属性中读取的值略有不同；此方法的目的是返回无损地重构对象实例所需的信息。

参数:

include_defaults (bool, 可选) – 是否包含自对象创建以来尚未显式设置的属性。（默认值：True）

返回值:

从属性名称到其值的映射

Return type:

dict

query_properties_with_values(query: Callable[[PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

使用谓词查询 HasProps 实例的属性值。

参数:

• query (callable) – 一个可调用对象，它接受属性描述符并返回 True 或 False

• include_defaults (bool, 可选) – 是否包含用户尚未显式设置的属性（默认值：True）

返回值:

匹配属性的属性名称和值的映射

Return type:

dict

references() → set[Model]

返回此对象引用的所有 Models。

remove_on_change(attr: str, *callbacks: Callable[[str, Any, Any], None]) → None

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

查询此对象及其所有引用，以查找与给定选择器匹配的对象。

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

查询此对象及其所有引用，以查找与给定选择器匹配的对象。如果找到多个对象，则引发错误。返回单个匹配对象，如果未找到任何对象，则返回 None :param selector: :type selector: JSON-like

返回值:

Model

set_from_json(name: str, value: Any, *, setter: Setter | None = None) → None

从 JSON 在此对象上设置属性值。

参数:

• name (str) – 要设置的属性的名称

• value (JSON-value) – 要设置为属性的值

• setter (ClientSession 或 ServerSession 或 None, 可选) –

  这用于防止对 Bokeh 应用程序的“回旋镖”更新。

  在 Bokeh 服务器应用程序的上下文中，传入的属性更新将使用正在执行更新的会话进行注释。此值会通过更新触发的任何后续更改通知进行传播。会话可以将事件 setter 与自身进行比较，并抑制任何源自自身的更新。

返回值:

None

set_select(selector: type[Model] | SelectorType, updates: dict[str, Any]) → None

使用指定的属性/值更新来更新与给定选择器匹配的对象。

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

删除任何主题值并恢复默认值。

返回值:

None

update(**kwargs: Any) → None

从给定的关键字参数更新对象的属性。

返回值:

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)

类 LegendItem(*args: Any, id: ID | None = None, **kwargs: Any)

基类: Model

JSON 原型

{
  "id": "p54923", 
  "index": null, 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "label": {
    "type": "value", 
    "value": null
  }, 
  "name": null, 
  "renderers": [], 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": [], 
  "visible": true
}

index = None

Type:

Nullable(Int)

用于绘制代表性项目的列数据索引。

如果为 None (默认值)，则 Bokeh 将自动选择要使用的索引。 如果标签未引用数据列名称，则这通常是数据源中的第一个数据点。 否则，如果标签确实引用了列名，则图例将具有“groupby”行为，并将从列中的每个“组”中选择和显示代表点。

如果设置为数字，则 Bokeh 将在所有情况下都使用该数字作为索引。

label = None

Type:

NullStringSpec

此图例的标签。 可以是字符串，也可以是 ColumnDataSource 的列。 如果 label 是一个字段，则它必须在渲染器的 data_source 中。

name = None

Type:

Nullable(String)

此模型的一个任意的、用户提供的名称。

当查询文档以检索特定的 Bokeh 模型时，此名称可能很有用。

>>> plot.scatter([1,2,3], [4,5,6], name="temp")
>>> plot.select(name="temp")
[GlyphRenderer(id='399d53f5-73e9-44d9-9527-544b761c7705', ...)]

注意

对于提供的任何名称，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用该名称。

renderers = []

Type:

List

要在图例中绘制的字形渲染器列表。 如果 label 是一个字段，则渲染器的所有 data_source 必须相同。

syncable = True

Type:

布尔值

指示此模型在 Web 浏览器中更新时是否应同步回 Bokeh 服务器。当处理频繁更新的对象而我们不需要其更新值时，设置为 False 可能有助于减少网络流量。

注意

将此属性设置为 False 将阻止此对象上的任何 on_change() 回调被触发。但是，任何 JS 端的回调仍然有效。

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

当查询文档以检索特定的 Bokeh 模型时，此数据可能很有用

>>> r = plot.scatter([1,2,3], [4,5,6])
>>> r.tags = ["foo", 10]
>>> plot.select(tags=['foo', 10])
[GlyphRenderer(id='1de4c3df-a83d-480a-899b-fb263d3d5dd9', ...)]

或者只是将任何必要的元数据附加到可以通过 CustomJS 回调等访问的模型的一种便捷方式。

注意

对于提供的任何标签，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用这些标签。

visible = True

Type:

布尔值

图例项目是否应显示。 请参阅用户指南中的 隐藏图例项目。

apply_theme(property_values: dict[str, Any]) → None

应用一组主题值，这些值将代替默认值使用，但不会覆盖应用程序设置的值。

传入的字典可以保持原样并与其他实例共享以节省内存（因此调用者和 HasProps 实例都不应修改它）。

参数:

property_values (dict) – 用于代替默认值的主题值

返回值:

None

classmethod clear_extensions() → None

清除任何当前定义的自定义扩展。

序列化调用将导致任何当前定义的自定义扩展包含在生成的文档中，无论是否被使用。此方法可用于清除所有现有的自定义扩展定义。

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

这将创建原始模型的浅克隆，即任何可变容器或子模型都不会被复制。允许在克隆时覆盖特定属性。

classmethod dataspecs() → dict>[str, DataSpec]

收集此类上所有 DataSpec 属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

on_change(attr: str, *callbacks: PropertyCallback) → None

在此对象上添加回调，以便在 attr 更改时触发。

参数:

• attr (str) – 此对象上的属性名称

• *callbacks (callable) – 要注册的回调函数

返回值:

None

示例

widget.on_change('value', callback1, callback2, ..., callback_n)

on_event(event: str | type[Event], *callbacks: Callable[[Event], None] | Callable[[], None]) → None

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 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]]

收集此类上所有也具有引用的属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

具有引用的属性的名称

Return type:

set[str]

properties_with_values(*, include_defaults: bool = True, include_undefined: bool = False) → dict>[str, Any]

收集一个字典，将属性名称映射到它们的值。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

不可序列化的属性将被跳过，并且属性值采用“序列化”格式，这可能与您通常从属性中读取的值略有不同；此方法的目的是返回无损地重构对象实例所需的信息。

参数:

include_defaults (bool, 可选) – 是否包含自对象创建以来尚未显式设置的属性。（默认值：True）

返回值:

从属性名称到其值的映射

Return type:

dict

query_properties_with_values(query: Callable>[[PropertyDescriptor>[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) → dict>[str, Any]

使用谓词查询 HasProps 实例的属性值。

参数:

• query (callable) – 一个可调用对象，它接受属性描述符并返回 True 或 False

• include_defaults (bool, 可选) – 是否包含用户尚未显式设置的属性（默认值：True）

返回值:

匹配属性的属性名称和值的映射

Return type:

dict

references() → set>[Model]

返回此对象引用的所有 Models。

remove_on_change(attr: str, *callbacks: Callable>[[str, Any, Any], None]) → None

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

查询此对象及其所有引用，以查找与给定选择器匹配的对象。

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

查询此对象及其所有引用，以查找与给定选择器匹配的对象。如果找到多个对象，则引发错误。返回单个匹配对象，如果未找到任何对象，则返回 None :param selector: :type selector: JSON-like

返回值:

Model

set_from_json(name: str, value: Any, *, setter: Setter | None = None) → None

从 JSON 在此对象上设置属性值。

参数:

• name (str) – 要设置的属性的名称

• value (JSON-value) – 要设置为属性的值

• setter (ClientSession 或 ServerSession 或 None, 可选) –

  这用于防止对 Bokeh 应用程序的“回旋镖”更新。

  在 Bokeh 服务器应用程序的上下文中，传入的属性更新将使用正在执行更新的会话进行注释。此值会通过更新触发的任何后续更改通知进行传播。会话可以将事件 setter 与自身进行比较，并抑制任何源自自身的更新。

返回值:

None

set_select(selector: type[Model] | SelectorType, updates: dict>[str, Any]) → None

使用指定的属性/值更新来更新与给定选择器匹配的对象。

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

删除任何主题值并恢复默认值。

返回值:

None

update(**kwargs: Any) → None

从给定的关键字参数更新对象的属性。

返回值:

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)

类 Metric(*args: Any, id: ID | None = None, **kwargs: Any)

基类：Dimensional

用于定义度量单位的模型。

JSON 原型

{
  "base_unit": {
    "name": "unset", 
    "type": "symbol"
  }, 
  "exclude": [], 
  "full_unit": null, 
  "id": "p54931", 
  "include": null, 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "name": null, 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": [], 
  "ticks": [
    1, 
    2, 
    5, 
    10, 
    15, 
    20, 
    25, 
    50, 
    75, 
    100, 
    125, 
    150, 
    200, 
    250, 
    500, 
    750
  ]
}

base_unit = Undefined

Type:

Required(String)

基本单位的短名称，例如 "m" 代表米或 "eV" 代表电子伏特。

exclude = []

Type:

List

要避免的基础单位的子集。

full_unit = None

Type:

Nullable(String)

基本单位的全称，例如 "meter" 或 "electronvolt"。

include = None

Type:

Nullable(List)

基础中首选单位的可选子集。

name = None

Type:

Nullable(String)

此模型的一个任意的、用户提供的名称。

当查询文档以检索特定的 Bokeh 模型时，此名称可能很有用。

>>> plot.scatter([1,2,3], [4,5,6], name="temp")
>>> plot.select(name="temp")
[GlyphRenderer(id='399d53f5-73e9-44d9-9527-544b761c7705', ...)]

注意

对于提供的任何名称，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用该名称。

syncable = True

Type:

布尔值

指示此模型在 Web 浏览器中更新时是否应同步回 Bokeh 服务器。当处理频繁更新的对象而我们不需要其更新值时，设置为 False 可能有助于减少网络流量。

注意

将此属性设置为 False 将阻止此对象上的任何 on_change() 回调被触发。但是，任何 JS 端的回调仍然有效。

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

当查询文档以检索特定的 Bokeh 模型时，此数据可能很有用

>>> r = plot.scatter([1,2,3], [4,5,6])
>>> r.tags = ["foo", 10]
>>> plot.select(tags=['foo', 10])
[GlyphRenderer(id='1de4c3df-a83d-480a-899b-fb263d3d5dd9', ...)]

或者只是将任何必要的元数据附加到可以通过 CustomJS 回调等访问的模型的一种便捷方式。

注意

对于提供的任何标签，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用这些标签。

ticks = [1, 2, 5, 10, 15, 20, 25, 50, 75, 100, 125, 150, 200, 250, 500, 750]

Type:

Required(List)

在非精确模式下选择的首选值。

apply_theme(property_values: dict[str, Any]) → None

应用一组主题值，这些值将代替默认值使用，但不会覆盖应用程序设置的值。

传入的字典可以保持原样并与其他实例共享以节省内存（因此调用者和 HasProps 实例都不应修改它）。

参数:

property_values (dict) – 用于代替默认值的主题值

返回值:

None

classmethod clear_extensions() → None

清除任何当前定义的自定义扩展。

序列化调用将导致任何当前定义的自定义扩展包含在生成的文档中，无论是否被使用。此方法可用于清除所有现有的自定义扩展定义。

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

这将创建原始模型的浅克隆，即任何可变容器或子模型都不会被复制。允许在克隆时覆盖特定属性。

classmethod dataspecs() → dict[str, DataSpec]

收集此类上所有 DataSpec 属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

on_change(attr: str, *callbacks: PropertyCallback) → None

在此对象上添加回调，以便在 attr 更改时触发。

参数:

• attr (str) – 此对象上的属性名称

• *callbacks (callable) – 要注册的回调函数

返回值:

None

示例

widget.on_change('value', callback1, callback2, ..., callback_n)

on_event(event: str | type[Event], *callbacks: Callable[[Event], None] | Callable[[], None]) → None

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 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]]

收集此类上所有也具有引用的属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

具有引用的属性的名称

Return type:

set[str]

properties_with_values(*, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

收集一个字典，将属性名称映射到它们的值。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

不可序列化的属性将被跳过，并且属性值采用“序列化”格式，这可能与您通常从属性中读取的值略有不同；此方法的目的是返回无损地重构对象实例所需的信息。

参数:

include_defaults (bool, 可选) – 是否包含自对象创建以来尚未显式设置的属性。（默认值：True）

返回值:

从属性名称到其值的映射

Return type:

dict

query_properties_with_values(query: Callable[[PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

使用谓词查询 HasProps 实例的属性值。

参数:

• query (callable) – 一个可调用对象，它接受属性描述符并返回 True 或 False

• include_defaults (bool, 可选) – 是否包含用户尚未显式设置的属性（默认值：True）

返回值:

匹配属性的属性名称和值的映射

Return type:

dict

references() → set[Model]

返回此对象引用的所有 Models。

remove_on_change(attr: str, *callbacks: Callable[[str, Any, Any], None]) → None

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

查询此对象及其所有引用，以查找与给定选择器匹配的对象。

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

查询此对象及其所有引用，以查找与给定选择器匹配的对象。如果找到多个对象，则引发错误。返回单个匹配对象，如果未找到任何对象，则返回 None :param selector: :type selector: JSON-like

返回值:

Model

set_from_json(name: str, value: Any, *, setter: Setter | None = None) → None

从 JSON 在此对象上设置属性值。

参数:

• name (str) – 要设置的属性的名称

• value (JSON-value) – 要设置为属性的值

• setter (ClientSession 或 ServerSession 或 None, 可选) –

  这用于防止对 Bokeh 应用程序的“回旋镖”更新。

  在 Bokeh 服务器应用程序的上下文中，传入的属性更新将使用正在执行更新的会话进行注释。此值会通过更新触发的任何后续更改通知进行传播。会话可以将事件 setter 与自身进行比较，并抑制任何源自自身的更新。

返回值:

None

set_select(selector: type[Model] | SelectorType, updates: dict[str, Any]) → None

使用指定的属性/值更新来更新与给定选择器匹配的对象。

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

删除任何主题值并恢复默认值。

返回值:

None

update(**kwargs: Any) → None

从给定的关键字参数更新对象的属性。

返回值:

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 MetricLength(*args: Any, id: ID | None = None, **kwargs: Any)

基类: Metric

长度测量的度量单位。

JSON 原型

{
  "base_unit": "m", 
  "exclude": [
    "dm", 
    "hm"
  ], 
  "full_unit": null, 
  "id": "p54940", 
  "include": null, 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "name": null, 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": [], 
  "ticks": [
    1, 
    2, 
    5, 
    10, 
    15, 
    20, 
    25, 
    50, 
    75, 
    100, 
    125, 
    150, 
    200, 
    250, 
    500, 
    750
  ]
}

base_unit = 'm'

Type:

Required(String)

基本单位的短名称，例如 "m" 代表米或 "eV" 代表电子伏特。

exclude = ['dm', 'hm']

Type:

List

要避免的基础单位的子集。

full_unit = None

Type:

Nullable(String)

基本单位的全称，例如 "meter" 或 "electronvolt"。

include = None

Type:

Nullable(List)

基础中首选单位的可选子集。

name = None

Type:

Nullable(String)

此模型的一个任意的、用户提供的名称。

当查询文档以检索特定的 Bokeh 模型时，此名称可能很有用。

>>> plot.scatter([1,2,3], [4,5,6], name="temp")
>>> plot.select(name="temp")
[GlyphRenderer(id='399d53f5-73e9-44d9-9527-544b761c7705', ...)]

注意

对于提供的任何名称，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用该名称。

syncable = True

Type:

布尔值

指示此模型在 Web 浏览器中更新时是否应同步回 Bokeh 服务器。当处理频繁更新的对象而我们不需要其更新值时，设置为 False 可能有助于减少网络流量。

注意

将此属性设置为 False 将阻止此对象上的任何 on_change() 回调被触发。但是，任何 JS 端的回调仍然有效。

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

当查询文档以检索特定的 Bokeh 模型时，此数据可能很有用

>>> r = plot.scatter([1,2,3], [4,5,6])
>>> r.tags = ["foo", 10]
>>> plot.select(tags=['foo', 10])
[GlyphRenderer(id='1de4c3df-a83d-480a-899b-fb263d3d5dd9', ...)]

或者只是将任何必要的元数据附加到可以通过 CustomJS 回调等访问的模型的一种便捷方式。

注意

对于提供的任何标签，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用这些标签。

ticks = [1, 2, 5, 10, 15, 20, 25, 50, 75, 100, 125, 150, 200, 250, 500, 750]

Type:

Required(List)

在非精确模式下选择的首选值。

apply_theme(property_values: dict[str, Any]) → None

应用一组主题值，这些值将代替默认值使用，但不会覆盖应用程序设置的值。

传入的字典可以保持原样并与其他实例共享以节省内存（因此调用者和 HasProps 实例都不应修改它）。

参数:

property_values (dict) – 用于代替默认值的主题值

返回值:

None

classmethod clear_extensions() → None

清除任何当前定义的自定义扩展。

序列化调用将导致任何当前定义的自定义扩展包含在生成的文档中，无论是否被使用。此方法可用于清除所有现有的自定义扩展定义。

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

这将创建原始模型的浅克隆，即任何可变容器或子模型都不会被复制。允许在克隆时覆盖特定属性。

classmethod dataspecs() → dict[str, DataSpec]

收集此类上所有 DataSpec 属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

on_change(attr: str, *callbacks: PropertyCallback) → None

在此对象上添加回调，以便在 attr 更改时触发。

参数:

• attr (str) – 此对象上的属性名称

• *callbacks (callable) – 要注册的回调函数

返回值:

None

示例

widget.on_change('value', callback1, callback2, ..., callback_n)

on_event(event: str | type[Event], *callbacks: Callable[[Event], None] | Callable[[], None]) → None

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 bokeh.events 中的特定事件。

classmethod parameters() → list[Parameter]

生成适用于从 glyph 派生的函数的 Python Parameter 值。

返回值:

list(Parameter)

classmethod properties(*, _with_props: bool = False) → set[str] |

警告

在 Bokeh 的未来版本中，此方法将返回一个字典，将属性名称映射到属性对象。为了使当前对此方法的使用具有前瞻性，请将返回值包装在 list 中。

返回值:

属性名称

classmethod properties_with_refs() → dict[str, Property[Any]]

收集此类上所有也具有引用的属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

具有引用的属性的名称

Return type:

set[str]

properties_with_values(*, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

收集一个字典，将属性名称映射到它们的值。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

不可序列化的属性将被跳过，并且属性值采用“序列化”格式，这可能与您通常从属性中读取的值略有不同；此方法的目的是返回无损地重构对象实例所需的信息。

参数:

include_defaults (bool, 可选) – 是否包含自对象创建以来尚未显式设置的属性。（默认值：True）

返回值:

从属性名称到其值的映射

Return type:

dict

query_properties_with_values(query: Callable[[PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

使用谓词查询 HasProps 实例的属性值。

参数:

• query (callable) – 一个可调用对象，它接受属性描述符并返回 True 或 False

• include_defaults (bool, 可选) – 是否包含用户尚未显式设置的属性（默认值：True）

返回值:

匹配属性的属性名称和值的映射

Return type:

dict

references() → set[Model]

返回此对象引用的所有 Models。

remove_on_change(attr: str, *callbacks: Callable[[str, Any, Any], None]) → None

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

查询此对象及其所有引用，以查找与给定选择器匹配的对象。

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

查询此对象及其所有引用，以查找与给定选择器匹配的对象。如果找到多个对象，则引发错误。返回单个匹配对象，如果未找到任何对象，则返回 None :param selector: :type selector: JSON-like

返回值:

Model

set_from_json(name: str, value: Any, *, setter: Setter | None = None) → None

从 JSON 在此对象上设置属性值。

参数:

• name (str) – 要设置的属性的名称

• value (JSON-value) – 要设置为属性的值

• setter (ClientSession 或 ServerSession 或 None, 可选) –

  这用于防止对 Bokeh 应用程序的“回旋镖”更新。

  在 Bokeh 服务器应用程序的上下文中，传入的属性更新将使用正在执行更新的会话进行注释。此值会通过更新触发的任何后续更改通知进行传播。会话可以将事件 setter 与自身进行比较，并抑制任何源自自身的更新。

返回值:

None

set_select(selector: type[Model] | SelectorType, updates: dict[str, Any]) → None

使用指定的属性/值更新来更新与给定选择器匹配的对象。

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

删除任何主题值并恢复默认值。

返回值:

None

update(**kwargs: Any) → None

从给定的关键字参数更新对象的属性。

返回值:

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 NormalHead(*args: Any, id: ID | None = None, **kwargs: Any)

基簎： ArrowHead

渲柒闭合实心箭头。

JSON 原型

{
  "fill_alpha": {
    "type": "value", 
    "value": 1.0
  }, 
  "fill_color": {
    "type": "value", 
    "value": "black"
  }, 
  "hatch_alpha": {
    "type": "value", 
    "value": 1.0
  }, 
  "hatch_color": {
    "type": "value", 
    "value": "black"
  }, 
  "hatch_extra": {
    "type": "map"
  }, 
  "hatch_pattern": {
    "type": "value", 
    "value": null
  }, 
  "hatch_scale": {
    "type": "value", 
    "value": 12.0
  }, 
  "hatch_weight": {
    "type": "value", 
    "value": 1.0
  }, 
  "id": "p54949", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "line_alpha": {
    "type": "value", 
    "value": 1.0
  }, 
  "line_cap": {
    "type": "value", 
    "value": "butt"
  }, 
  "line_color": {
    "type": "value", 
    "value": "black"
  }, 
  "line_dash": {
    "type": "value", 
    "value": []
  }, 
  "line_dash_offset": {
    "type": "value", 
    "value": 0
  }, 
  "line_join": {
    "type": "value", 
    "value": "bevel"
  }, 
  "line_width": {
    "type": "value", 
    "value": 1
  }, 
  "name": null, 
  "size": {
    "type": "value", 
    "value": 25
  }, 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": []
}

fill_alpha = 1.0

Type:

AlphaSpec

箭头内部的填充 alpha 值。

fill_color = 'black'

Type:

ColorSpec

箭头内部的填充颜色值。

hatch_alpha = 1.0

Type:

AlphaSpec

箭头内部的孵化纹理 alpha 值。

hatch_color = 'black'

Type:

ColorSpec

箭头内部的孵化纹理颜色值。

hatch_extra = {}

Type:

Dict(String, Instance(Texture))

箭头内部的孵化纹理额外值。

hatch_pattern = None

Type:

HatchPatternSpec

箭头内部的孵化纹理值。

hatch_scale = 12.0

Type:

FloatSpec

箭头内部的孵化纹理缩放值。

hatch_weight = 1.0

Type:

FloatSpec

箭头内部的孵化纹理粗细值。

line_alpha = 1.0

Type:

AlphaSpec

箭头轮廓的线条 alpha 值。

line_cap = 'butt'

Type:

LineCapSpec

箭头轮廓的线条端点值。

line_color = 'black'

Type:

ColorSpec

箭头轮廓的线条颜色值。

line_dash = []

Type:

DashPatternSpec

箭头轮廓的线条虚线值。

line_dash_offset = 0

Type:

IntSpec

箭头轮廓的线条虚线偏移值。

line_join = 'bevel'

Type:

LineJoinSpec

箭头轮廓的线条连接值。

line_width = 1

Type:

FloatSpec

箭头轮廓的线条宽度值。

name = None

Type:

Nullable(String)

此模型的一个任意的、用户提供的名称。

当查询文档以检索特定的 Bokeh 模型时，此名称可能很有用。

>>> plot.scatter([1,2,3], [4,5,6], name="temp")
>>> plot.select(name="temp")
[GlyphRenderer(id='399d53f5-73e9-44d9-9527-544b761c7705', ...)]

注意

对于提供的任何名称，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用该名称。

size = 25

Type:

NumberSpec

箭头箭头的大小，以像素为单位。

syncable = True

Type:

布尔值

指示此模型在 Web 浏览器中更新时是否应同步回 Bokeh 服务器。当处理频繁更新的对象而我们不需要其更新值时，设置为 False 可能有助于减少网络流量。

注意

将此属性设置为 False 将阻止此对象上的任何 on_change() 回调被触发。但是，任何 JS 端的回调仍然有效。

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

当查询文档以检索特定的 Bokeh 模型时，此数据可能很有用

>>> r = plot.scatter([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) – 用于代替默认值的主题值

返回值:

None

classmethod clear_extensions() → None

清除任何当前定义的自定义扩展。

序列化调用将导致任何当前定义的自定义扩展包含在生成的文档中，无论是否被使用。此方法可用于清除所有现有的自定义扩展定义。

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

这将创建原始模型的浅克隆，即任何可变容器或子模型都不会被复制。允许在克隆时覆盖特定属性。

classmethod dataspecs() → dict[str, DataSpec]

收集此类上所有 DataSpec 属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

on_change(attr: str, *callbacks: PropertyCallback) → None

在此对象上添加回调，以便在 attr 更改时触发。

参数:

• attr (str) – 此对象上的属性名称

• *callbacks (callable) – 要注册的回调函数

返回值:

None

示例

widget.on_change('value', callback1, callback2, ..., callback_n)

on_event(event: str | type[Event], *callbacks: Callable[[Event], None] | Callable[[], None]) → None

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 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]]

收集此类上所有也具有引用的属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

具有引用的属性的名称

Return type:

set[str]

properties_with_values(*, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

收集一个字典，将属性名称映射到它们的值。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

不可序列化的属性将被跳过，并且属性值采用“序列化”格式，这可能与您通常从属性中读取的值略有不同；此方法的目的是返回无损地重构对象实例所需的信息。

参数:

include_defaults (bool, 可选) – 是否包含自对象创建以来尚未显式设置的属性。（默认值：True）

返回值:

从属性名称到其值的映射

Return type:

dict

query_properties_with_values(query: Callable[[PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

使用谓词查询 HasProps 实例的属性值。

参数:

• query (callable) – 一个可调用对象，它接受属性描述符并返回 True 或 False

• include_defaults (bool, 可选) – 是否包含用户尚未显式设置的属性（默认值：True）

返回值:

匹配属性的属性名称和值的映射

Return type:

dict

references() → set[Model]

返回此对象引用的所有 Models。

remove_on_change(attr: str, *callbacks: Callable[[str, Any, Any], None]) → None

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

查询此对象及其所有引用，以查找与给定选择器匹配的对象。

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

查询此对象及其所有引用，以查找与给定选择器匹配的对象。如果找到多个对象，则引发错误。返回单个匹配对象，如果未找到任何对象，则返回 None :param selector: :type selector: JSON-like

返回值:

Model

set_from_json(name: str, value: Any, *, setter: Setter | None = None) → None

从 JSON 在此对象上设置属性值。

参数:

• name (str) – 要设置的属性的名称

• value (JSON-value) – 要设置为属性的值

• setter (ClientSession 或 ServerSession 或 None, 可选) –

  这用于防止对 Bokeh 应用程序的“回旋镖”更新。

  在 Bokeh 服务器应用程序的上下文中，传入的属性更新将使用正在执行更新的会话进行注释。此值会通过更新触发的任何后续更改通知进行传播。会话可以将事件 setter 与自身进行比较，并抑制任何源自自身的更新。

返回值:

None

set_select(selector: type[Model] | SelectorType, updates: dict[str, Any]) → None

使用指定的属性/值更新来更新与给定选择器匹配的对象。

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

删除任何主题值并恢复默认值。

返回值:

None

update(**kwargs: Any) → None

从给定的关键字参数更新对象的属性。

返回值:

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 OpenHead(*args: Any, id: ID | None = None, **kwargs: Any)

基簎： ArrowHead

渲染一个开放箭头的箭头头部。

JSON 原型

{
  "id": "p54969", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "line_alpha": {
    "type": "value", 
    "value": 1.0
  }, 
  "line_cap": {
    "type": "value", 
    "value": "butt"
  }, 
  "line_color": {
    "type": "value", 
    "value": "black"
  }, 
  "line_dash": {
    "type": "value", 
    "value": []
  }, 
  "line_dash_offset": {
    "type": "value", 
    "value": 0
  }, 
  "line_join": {
    "type": "value", 
    "value": "bevel"
  }, 
  "line_width": {
    "type": "value", 
    "value": 1
  }, 
  "name": null, 
  "size": {
    "type": "value", 
    "value": 25
  }, 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": []
}

line_alpha = 1.0

Type:

AlphaSpec

箭头轮廓的线条 alpha 值。

line_cap = 'butt'

Type:

LineCapSpec

箭头轮廓的线条端点值。

line_color = 'black'

Type:

ColorSpec

箭头轮廓的线条颜色值。

line_dash = []

Type:

DashPatternSpec

箭头轮廓的线条虚线值。

line_dash_offset = 0

Type:

IntSpec

箭头轮廓的线条虚线偏移值。

line_join = 'bevel'

Type:

LineJoinSpec

箭头轮廓的线条连接值。

line_width = 1

Type:

FloatSpec

箭头轮廓的线条宽度值。

name = None

Type:

Nullable(String)

此模型的一个任意的、用户提供的名称。

当查询文档以检索特定的 Bokeh 模型时，此名称可能很有用。

>>> plot.scatter([1,2,3], [4,5,6], name="temp")
>>> plot.select(name="temp")
[GlyphRenderer(id='399d53f5-73e9-44d9-9527-544b761c7705', ...)]

注意

对于提供的任何名称，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用该名称。

size = 25

Type:

NumberSpec

箭头箭头的大小，以像素为单位。

syncable = True

Type:

布尔值

指示此模型在 Web 浏览器中更新时是否应同步回 Bokeh 服务器。当处理频繁更新的对象而我们不需要其更新值时，设置为 False 可能有助于减少网络流量。

注意

将此属性设置为 False 将阻止此对象上的任何 on_change() 回调被触发。但是，任何 JS 端的回调仍然有效。

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

当查询文档以检索特定的 Bokeh 模型时，此数据可能很有用

>>> r = plot.scatter([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) – 用于代替默认值的主题值

返回值:

None

classmethod clear_extensions() → None

清除任何当前定义的自定义扩展。

序列化调用将导致任何当前定义的自定义扩展包含在生成的文档中，无论是否被使用。此方法可用于清除所有现有的自定义扩展定义。

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

这将创建原始模型的浅克隆，即任何可变容器或子模型都不会被复制。允许在克隆时覆盖特定属性。

classmethod dataspecs() → dict[str, DataSpec]

收集此类上所有 DataSpec 属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

on_change(attr: str, *callbacks: PropertyCallback) → None

在此对象上添加回调，以便在 attr 更改时触发。

参数:

• attr (str) – 此对象上的属性名称

• *callbacks (callable) – 要注册的回调函数

返回值:

None

示例

widget.on_change('value', callback1, callback2, ..., callback_n)

on_event(event: str | type[Event], *callbacks: Callable[[Event], None] | Callable[[], None]) → None

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 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]]

收集此类上所有也具有引用的属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

具有引用的属性的名称

Return type:

set[str]

properties_with_values(*, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

收集一个字典，将属性名称映射到它们的值。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

不可序列化的属性将被跳过，并且属性值采用“序列化”格式，这可能与您通常从属性中读取的值略有不同；此方法的目的是返回无损地重构对象实例所需的信息。

参数:

include_defaults (bool, 可选) – 是否包含自对象创建以来尚未显式设置的属性。（默认值：True）

返回值:

从属性名称到其值的映射

Return type:

dict

query_properties_with_values(query: Callable[[PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

使用谓词查询 HasProps 实例的属性值。

参数:

• query (callable) – 一个可调用对象，它接受属性描述符并返回 True 或 False

• include_defaults (bool, 可选) – 是否包含用户尚未显式设置的属性（默认值：True）

返回值:

匹配属性的属性名称和值的映射

Return type:

dict

references() → set[Model]

返回此对象引用的所有 Models。

remove_on_change(attr: str, *callbacks: Callable[[str, Any, Any], None]) → None

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

查询此对象及其所有引用，以查找与给定选择器匹配的对象。

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

查询此对象及其所有引用，以查找与给定选择器匹配的对象。如果找到多个对象，则引发错误。返回单个匹配对象，如果未找到任何对象，则返回 None :param selector: :type selector: JSON-like

返回值:

Model

set_from_json(name: str, value: Any, *, setter: Setter | None = None) → None

从 JSON 在此对象上设置属性值。

参数:

• name (str) – 要设置的属性的名称

• value (JSON-value) – 要设置为属性的值

• setter (ClientSession 或 ServerSession 或 None, 可选) –

  这用于防止对 Bokeh 应用程序的“回旋镖”更新。

  在 Bokeh 服务器应用程序的上下文中，传入的属性更新将使用正在执行更新的会话进行注释。此值会通过更新触发的任何后续更改通知进行传播。会话可以将事件 setter 与自身进行比较，并抑制任何源自自身的更新。

返回值:

None

set_select(selector: type[Model] | SelectorType, updates: dict[str, Any]) → None

使用指定的属性/值更新来更新与给定选择器匹配的对象。

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

删除任何主题值并恢复默认值。

返回值:

None

update(**kwargs: Any) → None

从给定的关键字参数更新对象的属性。

返回值:

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 PolyAnnotation(*args: Any, id: ID | None = None, **kwargs: Any)

Bases: Annotation

将阴影多边形区域渲染为注释。

有关绘制多边形注释的信息，请参阅多边形注释。

JSON 原型

{
  "context_menu": null, 
  "coordinates": null, 
  "css_classes": [], 
  "css_variables": {
    "type": "map"
  }, 
  "editable": false, 
  "elements": [], 
  "fill_alpha": 0.4, 
  "fill_color": "#fff9ba", 
  "group": null, 
  "hatch_alpha": 1.0, 
  "hatch_color": "black", 
  "hatch_extra": {
    "type": "map"
  }, 
  "hatch_pattern": null, 
  "hatch_scale": 12.0, 
  "hatch_weight": 1.0, 
  "hover_fill_alpha": 0.4, 
  "hover_fill_color": null, 
  "hover_hatch_alpha": 1.0, 
  "hover_hatch_color": "black", 
  "hover_hatch_extra": {
    "type": "map"
  }, 
  "hover_hatch_pattern": null, 
  "hover_hatch_scale": 12.0, 
  "hover_hatch_weight": 1.0, 
  "hover_line_alpha": 0.3, 
  "hover_line_cap": "butt", 
  "hover_line_color": null, 
  "hover_line_dash": [], 
  "hover_line_dash_offset": 0, 
  "hover_line_join": "bevel", 
  "hover_line_width": 1, 
  "html_attributes": {
    "type": "map"
  }, 
  "html_id": null, 
  "id": "p54981", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "level": "annotation", 
  "line_alpha": 0.3, 
  "line_cap": "butt", 
  "line_color": "#cccccc", 
  "line_dash": [], 
  "line_dash_offset": 0, 
  "line_join": "bevel", 
  "line_width": 1, 
  "name": null, 
  "propagate_hover": false, 
  "renderers": [], 
  "styles": {
    "type": "map"
  }, 
  "stylesheets": [], 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": [], 
  "visible": true, 
  "x_range_name": "default", 
  "xs": [], 
  "xs_units": "data", 
  "y_range_name": "default", 
  "ys": [], 
  "ys_units": "data"
}

context_menu = None

Type:

Nullable(Instance(‘.models.ui.Menu’))

当用户右键单击组件时显示的菜单。

注意

右键单击时使用 shift 键显示原生上下文菜单。

css_classes = []

Type:

List

要添加到底层 DOM 元素的其他 CSS 类列表。

css_variables = {}

Type:

Dict(String, Either(String, Instance(Node)))

允许定义动态计算的 CSS 变量。

例如，这可以用于协调画布渲染器和/或视觉效果与基于 HTML 的 UI 元素之间的定位和样式设置。

此处定义的变量等效于在 CSS 样式表中的 :host { ... } 下设置相同的变量。

注意

此属性是实验性的，随时可能更改。

editable = False

Type:

布尔值

允许交互式修改此多边形的几何形状。

注意

此属性是实验性的，随时可能更改。

elements = []

Type:

List

附加到此渲染器的基于 DOM 的 UI 元素集合。

这可以包括浮动元素（如工具提示），从而允许在此渲染器及其 UI 元素之间建立父子关系。

注意

此属性等效于基于 DOM 的 UI 中的 Pane.elements。

fill_alpha = 0.4

Type:

Alpha（透明度）

多边形填充 Alpha 值。

fill_color = '#fff9ba'

Type:

Nullable(Color)

多边形填充颜色值。

group = None

Type:

Nullable(Instance(RendererGroup))

注意

此属性是实验性的，随时可能更改。

hatch_alpha = 1.0

Type:

Alpha（透明度）

多边形阴影线 Alpha 值。

hatch_color = 'black'

Type:

Nullable(Color)

多边形阴影线颜色值。

hatch_extra = {}

Type:

Dict(String, Instance(Texture))

多边形阴影线额外值。

hatch_pattern = None

Type:

Nullable(String)

多边形阴影线图案值。

hatch_scale = 12.0

Type:

尺寸

多边形阴影线比例值。

hatch_weight = 1.0

Type:

尺寸

多边形阴影线粗细值。

hover_fill_alpha = 0.4

Type:

Alpha（透明度）

悬停时多边形填充 Alpha 值。

hover_fill_color = None

Type:

Nullable(Color)

悬停时多边形填充颜色值。

hover_hatch_alpha = 1.0

Type:

Alpha（透明度）

悬停时多边形阴影线 Alpha 值。

hover_hatch_color = 'black'

Type:

Nullable(Color)

悬停时多边形阴影线颜色值。

hover_hatch_extra = {}

Type:

Dict(String, Instance(Texture))

悬停时多边形阴影线额外值。

hover_hatch_pattern = None

Type:

Nullable(String)

悬停时多边形阴影线图案值。

hover_hatch_scale = 12.0

Type:

尺寸

悬停时多边形阴影线比例值。

hover_hatch_weight = 1.0

Type:

尺寸

悬停时多边形阴影线粗细值。

hover_line_alpha = 0.3

Type:

Alpha（透明度）

悬停时多边形线条 Alpha 值。

hover_line_cap = 'butt'

Type:

Enum(LineCap)

悬停时多边形线条端帽样式值。

hover_line_color = None

Type:

Nullable(Color)

悬停时多边形线条颜色值。

hover_line_dash = []

Type:

虚线模式

悬停时多边形线条虚线样式值。

hover_line_dash_offset = 0

Type:

整数

悬停时多边形线条虚线偏移值。

hover_line_join = 'bevel'

Type:

Enum(LineJoin)

悬停时多边形线条连接样式值。

hover_line_width = 1

Type:

浮点数

悬停时多边形线条宽度值。

html_attributes = {}

Type:

Dict(String, String)

允许在底层 HTML 元素上配置 HTML 属性。

html_id = None

Type:

Nullable(String)

设置底层 HTML 元素的 id 属性。

这是常用 HTML id 属性的简写形式。或者，id 也可以在 html_attributes 字典中设置。html_id 优先。

level = 'annotation'

Type:

Enum(RenderLevel)

指定绘制此渲染器的层级。

line_alpha = 0.3

Type:

Alpha（透明度）

多边形线条 Alpha 值。

line_cap = 'butt'

Type:

Enum(LineCap)

多边形线条端帽样式值。

line_color = '#cccccc'

Type:

Nullable(Color)

多边形线条颜色值。

line_dash = []

Type:

虚线模式

多边形线条虚线样式值。

line_dash_offset = 0

Type:

整数

多边形线条虚线偏移值。

line_join = 'bevel'

Type:

Enum(LineJoin)

多边形线条连接样式值。

line_width = 1

Type:

浮点数

多边形线条宽度值。

name = None

Type:

Nullable(String)

此模型的一个任意的、用户提供的名称。

当查询文档以检索特定的 Bokeh 模型时，此名称可能很有用。

>>> plot.scatter([1,2,3], [4,5,6], name="temp")
>>> plot.select(name="temp")
[GlyphRenderer(id='399d53f5-73e9-44d9-9527-544b761c7705', ...)]

注意

对于提供的任何名称，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用该名称。

propagate_hover = False

Type:

布尔值

允许将悬停事件传播到父级渲染器、框架或画布。

注意

此属性是实验性的，随时可能更改。

renderers = []

Type:

List

附加到此渲染器的一组渲染器。

注意

此属性是实验性的，随时可能更改。

styles = {}

Type:

Either(Dict(String, Nullable(String)), Instance(Styles))

应用于底层 DOM 元素的内联 CSS 样式。

stylesheets = []

Type:

List

用于底层 DOM 元素的其他样式表。

请注意，所有 Bokeh 组件都使用 shadow DOM，因此任何包含的样式表都必须反映这一点，例如，使用 :host CSS 伪选择器来访问根 DOM 元素。

syncable = True

Type:

布尔值

指示此模型在 Web 浏览器中更新时是否应同步回 Bokeh 服务器。当处理频繁更新的对象而我们不需要其更新值时，设置为 False 可能有助于减少网络流量。

注意

将此属性设置为 False 将阻止此对象上的任何 on_change() 回调被触发。但是，任何 JS 端的回调仍然有效。

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

当查询文档以检索特定的 Bokeh 模型时，此数据可能很有用

>>> r = plot.scatter([1,2,3], [4,5,6])
>>> r.tags = ["foo", 10]
>>> plot.select(tags=['foo', 10])
[GlyphRenderer(id='1de4c3df-a83d-480a-899b-fb263d3d5dd9', ...)]

或者只是将任何必要的元数据附加到可以通过 CustomJS 回调等访问的模型的一种便捷方式。

注意

对于提供的任何标签，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用这些标签。

visible = True

Type:

布尔值

渲染器是否可见。

x_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）x 轴范围。如果未设置，则使用默认 x 轴范围。

xs = []

Type:

Seq(Either(Float, Datetime, Factor))

绘制区域的X坐标。

xs_units = 'data'

Type:

Enum(CoordinateUnits)

xs 属性的单位类型。默认解释为数据单位。

y_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）y 轴范围。如果未设置，则使用默认 y 轴范围。

ys = []

Type:

Seq(Either(Float, Datetime, Factor))

绘制区域的Y坐标。

ys_units = 'data'

Type:

Enum(CoordinateUnits)

ys 属性的单位类型。默认解释为数据单位。

apply_theme(property_values: dict[str, Any]) → None

应用一组主题值，这些值将代替默认值使用，但不会覆盖应用程序设置的值。

传入的字典可以保持原样并与其他实例共享以节省内存（因此调用者和 HasProps 实例都不应修改它）。

参数:

property_values (dict) – 用于代替默认值的主题值

返回值:

None

classmethod clear_extensions() → None

清除任何当前定义的自定义扩展。

序列化调用将导致任何当前定义的自定义扩展包含在生成的文档中，无论是否被使用。此方法可用于清除所有现有的自定义扩展定义。

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

这将创建原始模型的浅克隆，即任何可变容器或子模型都不会被复制。允许在克隆时覆盖特定属性。

classmethod dataspecs() → dict[str, DataSpec]

收集此类上所有 DataSpec 属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

on_change(attr: str, *callbacks: PropertyCallback) → None

在此对象上添加回调，以便在 attr 更改时触发。

参数:

• attr (str) – 此对象上的属性名称

• *callbacks (callable) – 要注册的回调函数

返回值:

None

示例

widget.on_change('value', callback1, callback2, ..., callback_n)

on_event(event: str | type[Event], *callbacks: Callable[[Event], None] | Callable[[], None]) → None

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 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]]

收集此类上所有也具有引用的属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

具有引用的属性的名称

Return type:

set[str]

properties_with_values(*, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

收集一个字典，将属性名称映射到它们的值。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

不可序列化的属性将被跳过，并且属性值采用“序列化”格式，这可能与您通常从属性中读取的值略有不同；此方法的目的是返回无损地重构对象实例所需的信息。

参数:

include_defaults (bool, 可选) – 是否包含自对象创建以来尚未显式设置的属性。（默认值：True）

返回值:

从属性名称到其值的映射

Return type:

dict

query_properties_with_values(query: Callable[[PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

使用谓词查询 HasProps 实例的属性值。

参数:

• query (callable) – 一个可调用对象，它接受属性描述符并返回 True 或 False

• include_defaults (bool, 可选) – 是否包含用户尚未显式设置的属性（默认值：True）

返回值:

匹配属性的属性名称和值的映射

Return type:

dict

references() → set[Model]

返回此对象引用的所有 Models。

remove_on_change(attr: str, *callbacks: Callable[[str, Any, Any], None]) → None

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

查询此对象及其所有引用，以查找与给定选择器匹配的对象。

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

查询此对象及其所有引用，以查找与给定选择器匹配的对象。如果找到多个对象，则引发错误。返回单个匹配对象，如果未找到任何对象，则返回 None :param selector: :type selector: JSON-like

返回值:

Model

set_from_json(name: str, value: Any, *, setter: Setter | None = None) → None

从 JSON 在此对象上设置属性值。

参数:

• name (str) – 要设置的属性的名称

• value (JSON-value) – 要设置为属性的值

• setter (ClientSession 或 ServerSession 或 None, 可选) –

  这用于防止对 Bokeh 应用程序的“回旋镖”更新。

  在 Bokeh 服务器应用程序的上下文中，传入的属性更新将使用正在执行更新的会话进行注释。此值会通过更新触发的任何后续更改通知进行传播。会话可以将事件 setter 与自身进行比较，并抑制任何源自自身的更新。

返回值:

None

set_select(selector: type[Model] | SelectorType, updates: dict[str, Any]) → None

使用指定的属性/值更新来更新与给定选择器匹配的对象。

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

删除任何主题值并恢复默认值。

返回值:

None

update(**kwargs: Any) → None

从给定的关键字参数更新对象的属性。

返回值:

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 ReciprocalMetric(*args: Any, id: ID | None = None, **kwargs: Any)

基类: Metric

用于定义倒数度量单位的模型，例如 m^{-1}。

JSON 原型

{
  "base_unit": {
    "name": "unset", 
    "type": "symbol"
  }, 
  "exclude": [], 
  "full_unit": null, 
  "id": "p55035", 
  "include": null, 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "name": null, 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": [], 
  "ticks": [
    1, 
    2, 
    5, 
    10, 
    15, 
    20, 
    25, 
    50, 
    75, 
    100, 
    125, 
    150, 
    200, 
    250, 
    500, 
    750
  ]
}

base_unit = Undefined

Type:

Required(String)

基本单位的短名称，例如 "m" 代表米或 "eV" 代表电子伏特。

exclude = []

Type:

List

要避免的基础单位的子集。

full_unit = None

Type:

Nullable(String)

基本单位的全称，例如 "meter" 或 "electronvolt"。

include = None

Type:

Nullable(List)

基础中首选单位的可选子集。

name = None

Type:

Nullable(String)

此模型的一个任意的、用户提供的名称。

当查询文档以检索特定的 Bokeh 模型时，此名称可能很有用。

>>> plot.scatter([1,2,3], [4,5,6], name="temp")
>>> plot.select(name="temp")
[GlyphRenderer(id='399d53f5-73e9-44d9-9527-544b761c7705', ...)]

注意

对于提供的任何名称，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用该名称。

syncable = True

Type:

布尔值

指示此模型在 Web 浏览器中更新时是否应同步回 Bokeh 服务器。当处理频繁更新的对象而我们不需要其更新值时，设置为 False 可能有助于减少网络流量。

注意

将此属性设置为 False 将阻止此对象上的任何 on_change() 回调被触发。但是，任何 JS 端的回调仍然有效。

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

当查询文档以检索特定的 Bokeh 模型时，此数据可能很有用

>>> r = plot.scatter([1,2,3], [4,5,6])
>>> r.tags = ["foo", 10]
>>> plot.select(tags=['foo', 10])
[GlyphRenderer(id='1de4c3df-a83d-480a-899b-fb263d3d5dd9', ...)]

或者只是将任何必要的元数据附加到可以通过 CustomJS 回调等访问的模型的一种便捷方式。

注意

对于提供的任何标签，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用这些标签。

ticks = [1, 2, 5, 10, 15, 20, 25, 50, 75, 100, 125, 150, 200, 250, 500, 750]

Type:

Required(List)

在非精确模式下选择的首选值。

apply_theme(property_values: dict[str, Any]) → None

应用一组主题值，这些值将代替默认值使用，但不会覆盖应用程序设置的值。

传入的字典可以保持原样并与其他实例共享以节省内存（因此调用者和 HasProps 实例都不应修改它）。

参数:

property_values (dict) – 用于代替默认值的主题值

返回值:

None

classmethod clear_extensions() → None

清除任何当前定义的自定义扩展。

序列化调用将导致任何当前定义的自定义扩展包含在生成的文档中，无论是否被使用。此方法可用于清除所有现有的自定义扩展定义。

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

这将创建原始模型的浅克隆，即任何可变容器或子模型都不会被复制。允许在克隆时覆盖特定属性。

classmethod dataspecs() → dict[str, DataSpec]

收集此类上所有 DataSpec 属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

on_change(attr: str, *callbacks: PropertyCallback) → None

在此对象上添加回调，以便在 attr 更改时触发。

参数:

• attr (str) – 此对象上的属性名称

• *callbacks (callable) – 要注册的回调函数

返回值:

None

示例

widget.on_change('value', callback1, callback2, ..., callback_n)

on_event(event: str | type[Event], *callbacks: Callable[[Event], None] | Callable[[], None]) → None

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 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]]

收集此类上所有也具有引用的属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

具有引用的属性的名称

Return type:

set[str]

properties_with_values(*, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

收集一个字典，将属性名称映射到它们的值。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

不可序列化的属性将被跳过，并且属性值采用“序列化”格式，这可能与您通常从属性中读取的值略有不同；此方法的目的是返回无损地重构对象实例所需的信息。

参数:

include_defaults (bool, 可选) – 是否包含自对象创建以来尚未显式设置的属性。（默认值：True）

返回值:

从属性名称到其值的映射

Return type:

dict

query_properties_with_values(query: Callable[[PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

使用谓词查询 HasProps 实例的属性值。

参数:

• query (callable) – 一个可调用对象，它接受属性描述符并返回 True 或 False

• include_defaults (bool, 可选) – 是否包含用户尚未显式设置的属性（默认值：True）

返回值:

匹配属性的属性名称和值的映射

Return type:

dict

references() → set[Model]

返回此对象引用的所有 Models。

remove_on_change(attr: str, *callbacks: Callable[[str, Any, Any]], None]) → None

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

查询此对象及其所有引用，以查找与给定选择器匹配的对象。

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

查询此对象及其所有引用，以查找与给定选择器匹配的对象。如果找到多个对象，则引发错误。返回单个匹配对象，如果未找到任何对象，则返回 None :param selector: :type selector: JSON-like

返回值:

Model

set_from_json(name: str, value: Any, *, setter: Setter | None = None) → None

从 JSON 在此对象上设置属性值。

参数:

• name (str) – 要设置的属性的名称

• value (JSON-value) – 要设置为属性的值

• setter (ClientSession 或 ServerSession 或 None, 可选) –

  这用于防止对 Bokeh 应用程序的“回旋镖”更新。

  在 Bokeh 服务器应用程序的上下文中，传入的属性更新将使用正在执行更新的会话进行注释。此值会通过更新触发的任何后续更改通知进行传播。会话可以将事件 setter 与自身进行比较，并抑制任何源自自身的更新。

返回值:

None

set_select(selector: type[Model] | SelectorType, updates: dict[str, Any]) → None

使用指定的属性/值更新来更新与给定选择器匹配的对象。

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

删除任何主题值并恢复默认值。

返回值:

None

update(**kwargs: Any) → None

从给定的关键字参数更新对象的属性。

返回值:

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 ReciprocalMetricLength(*args: Any, id: ID | None = None, **kwargs: Any)

Bases: ReciprocalMetric

反长度测量的公制单位。

JSON 原型

{
  "base_unit": "m", 
  "exclude": [
    "dm", 
    "hm"
  ], 
  "full_unit": null, 
  "id": "p55044", 
  "include": null, 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "name": null, 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": [], 
  "ticks": [
    1, 
    2, 
    5, 
    10, 
    15, 
    20, 
    25, 
    50, 
    75, 
    100, 
    125, 
    150, 
    200, 
    250, 
    500, 
    750
  ]
}

base_unit = 'm'

Type:

Required(String)

基本单位的短名称，例如 "m" 代表米或 "eV" 代表电子伏特。

exclude = ['dm', 'hm']

Type:

List

要避免的基础单位的子集。

full_unit = None

Type:

Nullable(String)

基本单位的全称，例如 "meter" 或 "electronvolt"。

include = None

Type:

Nullable(List)

基础中首选单位的可选子集。

name = None

Type:

Nullable(String)

此模型的一个任意的、用户提供的名称。

当查询文档以检索特定的 Bokeh 模型时，此名称可能很有用。

>>> plot.scatter([1,2,3], [4,5,6], name="temp")
>>> plot.select(name="temp")
[GlyphRenderer(id='399d53f5-73e9-44d9-9527-544b761c7705', ...)]

注意

对于提供的任何名称，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用该名称。

syncable = True

Type:

布尔值

指示此模型在 Web 浏览器中更新时是否应同步回 Bokeh 服务器。当处理频繁更新的对象而我们不需要其更新值时，设置为 False 可能有助于减少网络流量。

注意

将此属性设置为 False 将阻止此对象上的任何 on_change() 回调被触发。但是，任何 JS 端的回调仍然有效。

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

当查询文档以检索特定的 Bokeh 模型时，此数据可能很有用

>>> r = plot.scatter([1,2,3], [4,5,6])
>>> r.tags = ["foo", 10]
>>> plot.select(tags=['foo', 10])
[GlyphRenderer(id='1de4c3df-a83d-480a-899b-fb263d3d5dd9', ...)]

或者只是将任何必要的元数据附加到可以通过 CustomJS 回调等访问的模型的一种便捷方式。

注意

对于提供的任何标签，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用这些标签。

ticks = [1, 2, 5, 10, 15, 20, 25, 50, 75, 100, 125, 150, 200, 250, 500, 750]

Type:

Required(List)

在非精确模式下选择的首选值。

apply_theme(property_values: dict[str, Any]) → None

应用一组主题值，这些值将代替默认值使用，但不会覆盖应用程序设置的值。

传入的字典可以保持原样并与其他实例共享以节省内存（因此调用者和 HasProps 实例都不应修改它）。

参数:

property_values (dict) – 用于代替默认值的主题值

返回值:

None

classmethod clear_extensions() → None

清除任何当前定义的自定义扩展。

序列化调用将导致任何当前定义的自定义扩展包含在生成的文档中，无论是否被使用。此方法可用于清除所有现有的自定义扩展定义。

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

这将创建原始模型的浅克隆，即任何可变容器或子模型都不会被复制。允许在克隆时覆盖特定属性。

classmethod dataspecs() → dict[str, DataSpec]

收集此类上所有 DataSpec 属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

on_change(attr: str, *callbacks: PropertyCallback) → None

在此对象上添加回调，以便在 attr 更改时触发。

参数:

• attr (str) – 此对象上的属性名称

• *callbacks (callable) – 要注册的回调函数

返回值:

None

示例

widget.on_change('value', callback1, callback2, ..., callback_n)

on_event(event: str | type[Event], *callbacks: Callable[[Event], None] | Callable[[], None]) → None

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 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]]

收集此类上所有也具有引用的属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

具有引用的属性的名称

Return type:

set[str]

properties_with_values(*, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

收集一个字典，将属性名称映射到它们的值。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

不可序列化的属性将被跳过，并且属性值采用“序列化”格式，这可能与您通常从属性中读取的值略有不同；此方法的目的是返回无损地重构对象实例所需的信息。

参数:

include_defaults (bool, 可选) – 是否包含自对象创建以来尚未显式设置的属性。（默认值：True）

返回值:

从属性名称到其值的映射

Return type:

dict

query_properties_with_values(query: Callable[[PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

使用谓词查询 HasProps 实例的属性值。

参数:

• query (callable) – 一个可调用对象，它接受属性描述符并返回 True 或 False

• include_defaults (bool, 可选) – 是否包含用户尚未显式设置的属性（默认值：True）

返回值:

匹配属性的属性名称和值的映射

Return type:

dict

references() → set[Model]

返回此对象引用的所有 Models。

remove_on_change(attr: str, *callbacks: Callable[[str, Any, Any]], None]) → None

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

查询此对象及其所有引用，以查找与给定选择器匹配的对象。

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

查询此对象及其所有引用，以查找与给定选择器匹配的对象。如果找到多个对象，则引发错误。返回单个匹配对象，如果未找到任何对象，则返回 None :param selector: :type selector: JSON-like

返回值:

Model

set_from_json(name: str, value: Any, *, setter: Setter | None = None) → None

从 JSON 在此对象上设置属性值。

参数:

• name (str) – 要设置的属性的名称

• value (JSON-value) – 要设置为属性的值

• setter (ClientSession 或 ServerSession 或 None, 可选) –

  这用于防止对 Bokeh 应用程序的“回旋镖”更新。

  在 Bokeh 服务器应用程序的上下文中，传入的属性更新将使用正在执行更新的会话进行注释。此值会通过更新触发的任何后续更改通知进行传播。会话可以将事件 setter 与自身进行比较，并抑制任何源自自身的更新。

返回值:

None

set_select(selector: type[Model] | SelectorType, updates: dict[str, Any]) → None

使用指定的属性/值更新来更新与给定选择器匹配的对象。

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

删除任何主题值并恢复默认值。

返回值:

None

update(**kwargs: Any) → None

从给定的关键字参数更新对象的属性。

返回值:

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 ScaleBar(*args: Any, id: ID | None = None, **kwargs: Any)

Bases: Annotation

表示比例尺注释。

JSON 原型

{
  "anchor": "auto", 
  "background_fill_alpha": 0.95, 
  "background_fill_color": "#ffffff", 
  "background_hatch_alpha": 1.0, 
  "background_hatch_color": "black", 
  "background_hatch_extra": {
    "type": "map"
  }, 
  "background_hatch_pattern": null, 
  "background_hatch_scale": 12.0, 
  "background_hatch_weight": 1.0, 
  "bar_length": 0.2, 
  "bar_length_units": "screen", 
  "bar_line_alpha": 1.0, 
  "bar_line_cap": "butt", 
  "bar_line_color": "black", 
  "bar_line_dash": [], 
  "bar_line_dash_offset": 0, 
  "bar_line_join": "bevel", 
  "bar_line_width": 2, 
  "border_line_alpha": 0.5, 
  "border_line_cap": "butt", 
  "border_line_color": "#e5e5e5", 
  "border_line_dash": [], 
  "border_line_dash_offset": 0, 
  "border_line_join": "bevel", 
  "border_line_width": 1, 
  "context_menu": null, 
  "coordinates": null, 
  "css_classes": [], 
  "css_variables": {
    "type": "map"
  }, 
  "dimensional": {
    "attributes": {
      "include": null
    }, 
    "id": "p55054", 
    "name": "MetricLength", 
    "type": "object"
  }, 
  "elements": [], 
  "group": null, 
  "html_attributes": {
    "type": "map"
  }, 
  "html_id": null, 
  "id": "p55053", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "label": "@{value} @{unit}", 
  "label_align": "center", 
  "label_location": "below", 
  "label_standoff": 5, 
  "label_text_align": "left", 
  "label_text_alpha": 1.0, 
  "label_text_baseline": "middle", 
  "label_text_color": "#444444", 
  "label_text_font": "helvetica", 
  "label_text_font_size": "13px", 
  "label_text_font_style": "normal", 
  "label_text_line_height": 1.2, 
  "label_text_outline_color": null, 
  "length_sizing": "adaptive", 
  "level": "annotation", 
  "location": "top_right", 
  "margin": 10, 
  "name": null, 
  "orientation": "horizontal", 
  "padding": 10, 
  "propagate_hover": false, 
  "range": "auto", 
  "renderers": [], 
  "styles": {
    "type": "map"
  }, 
  "stylesheets": [], 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": [], 
  "ticker": {
    "attributes": {
      "minor_ticks": [], 
      "ticks": []
    }, 
    "id": "p55055", 
    "name": "FixedTicker", 
    "type": "object"
  }, 
  "title": "", 
  "title_align": "center", 
  "title_location": "above", 
  "title_standoff": 5, 
  "title_text_align": "left", 
  "title_text_alpha": 1.0, 
  "title_text_baseline": "bottom", 
  "title_text_color": "#444444", 
  "title_text_font": "helvetica", 
  "title_text_font_size": "13px", 
  "title_text_font_style": "italic", 
  "title_text_line_height": 1.2, 
  "title_text_outline_color": null, 
  "unit": "m", 
  "visible": true, 
  "x_range_name": "default", 
  "x_units": "data", 
  "y_range_name": "default", 
  "y_units": "data"
}

anchor = 'auto'

Type:

Either(Auto, Enum(Anchor), Tuple(Either(Auto, Either(Enum(Align), Enum(HAlign), Percent)), Either(Auto, Either(Enum(Align), Enum(VAlign), Percent))))

比例尺定位的原点。

如果在任一维度或两个维度上为 "auto"，则这些维度上的锚点将根据位置确定，以使比例尺看起来良好。

background_fill_alpha = 0.95

Type:

Alpha（透明度）

比例尺背景填充样式的填充 alpha 值。

background_fill_color = '#ffffff'

Type:

Nullable(Color)

比例尺背景填充样式的填充颜色。

background_hatch_alpha = 1.0

Type:

Alpha（透明度）

比例尺背景阴影线样式的阴影线 alpha 值。

background_hatch_color = 'black'

Type:

Nullable(Color)

比例尺背景阴影线样式的阴影线颜色。

background_hatch_extra = {}

Type:

Dict(String, Instance(Texture))

比例尺背景阴影线样式的额外阴影线属性。

background_hatch_pattern = None

Type:

Nullable(String)

比例尺背景阴影线样式的阴影线图案。

background_hatch_scale = 12.0

Type:

尺寸

比例尺背景阴影线样式的阴影线比例。

background_hatch_weight = 1.0

Type:

尺寸

比例尺背景阴影线样式的阴影线粗细。

bar_length = 0.2

Type:

非负值

比例尺线的长度。

这可以是帧的一部分、像素数或数据空间中的距离，具体取决于 bar_length_units 的配置。

bar_length_units = 'screen'

Type:

Enum(Enumeration(screen, data, percent))

定义如何解释 bar_length。

支持的值包括：

• "screen" - 长度以像素为单位提供，或者如果提供的值在 [0, 1] 范围内，则以父容器（例如，帧）的百分比形式提供

• "data" - 长度以数据空间单位提供

• "percent" - 长度是父容器（例如，帧）的百分比

注意

"data" 单位假定使用线性比例或类似线性的比例（例如，分类比例）。否则，比例尺线的长度将取决于位置。

bar_line_alpha = 1.0

Type:

Alpha（透明度）

比例尺线样式的线条 alpha 值。

bar_line_cap = 'butt'

Type:

Enum(LineCap)

比例尺线样式的线帽值。

bar_line_color = 'black'

Type:

Nullable(Color)

比例尺线样式的线条颜色值。

bar_line_dash = []

Type:

虚线模式

比例尺线样式的线条虚线值。

bar_line_dash_offset = 0

Type:

整数

比例尺线样式的线条虚线偏移值。

bar_line_join = 'bevel'

Type:

Enum(LineJoin)

比例尺线样式的线条连接值。

bar_line_width = 2

Type:

浮点数

比例尺线样式的线条宽度值。

border_line_alpha = 0.5

Type:

Alpha（透明度）

比例尺边框线样式的线条 alpha 值。

border_line_cap = 'butt'

Type:

Enum(LineCap)

比例尺边框线样式的线帽。

border_line_color = '#e5e5e5'

Type:

Nullable(Color)

比例尺边框线样式的线条颜色。

border_line_dash = []

Type:

虚线模式

比例尺边框线样式的线条虚线。

border_line_dash_offset = 0

Type:

整数

比例尺边框线样式的线条虚线偏移。

border_line_join = 'bevel'

Type:

Enum(LineJoin)

比例尺边框线样式的线条连接。

border_line_width = 1

Type:

浮点数

比例尺边框线样式的线条宽度。

context_menu = None

Type:

Nullable(Instance(‘.models.ui.Menu’))

当用户右键单击组件时显示的菜单。

注意

右键单击时使用 shift 键显示原生上下文菜单。

css_classes = []

Type:

List

要添加到底层 DOM 元素的其他 CSS 类列表。

css_variables = {}

Type:

Dict(String, Either(String, Instance(Node)))

允许定义动态计算的 CSS 变量。

例如，这可以用于协调画布渲染器和/或视觉效果与基于 HTML 的 UI 元素之间的定位和样式设置。

此处定义的变量等效于在 CSS 样式表中的 :host { ... } 下设置相同的变量。

注意

此属性是实验性的，随时可能更改。

dimensional = MetricLength(id='p55143', ...)

Type:

Instance(Dimensional)

定义测量单位。

elements = []

Type:

List

附加到此渲染器的基于 DOM 的 UI 元素集合。

这可以包括浮动元素（如工具提示），从而允许在此渲染器及其 UI 元素之间建立父子关系。

注意

此属性等效于基于 DOM 的 UI 中的 Pane.elements。

group = None

Type:

Nullable(Instance(RendererGroup))

注意

此属性是实验性的，随时可能更改。

html_attributes = {}

Type:

Dict(String, String)

允许在底层 HTML 元素上配置 HTML 属性。

html_id = None

Type:

Nullable(String)

设置底层 HTML 元素的 id 属性。

这是常用 HTML id 属性的简写形式。或者，id 也可以在 html_attributes 字典中设置。html_id 优先。

label = '@{value} @{unit}'

Type:

String

标签模板。

这可以使用特殊变量

• @{value} 当前值。可以选择使用数字格式化程序，例如 @{value}{%.2f}。

• @{unit} 测量单位。

label_align = 'center'

Type:

Enum(Align)

指定沿比例尺线对齐比例尺标签的位置。

当将标签放置在水平比例尺线的上方或下方，或者垂直比例尺线的左侧或右侧时，此属性有效。

label_location = 'below'

Type:

Enum(Location)

指定标签将位于比例尺线的哪一侧。

label_standoff = 5

Type:

整数

将标签与比例尺线分隔开的距离（以像素为单位）。

label_text_align = 'left'

Type:

Enum(TextAlign)

标签文本样式的文本对齐值。

label_text_alpha = 1.0

Type:

Alpha（透明度）

标签文本样式的文本 alpha 值。

label_text_baseline = 'middle'

Type:

Enum(TextBaseline)

标签文本样式的文本基线值。

label_text_color = '#444444'

Type:

Nullable(Color)

标签文本样式的文本颜色值。

label_text_font = 'helvetica'

Type:

String

标签文本样式的文本字体值。

label_text_font_size = '13px'

Type:

FontSize

标签文本样式的文本字体大小值。

label_text_font_style = 'normal'

Type:

Enum(FontStyle)

标签文本样式的文本字体样式值。

label_text_line_height = 1.2

Type:

浮点数

标签文本样式的文本行高值。

label_text_outline_color = None

Type:

Nullable(Color)

标签文本样式的文本轮廓颜色值。

length_sizing = 'adaptive'

Type:

Enum(Enumeration(adaptive, exact))

定义如何解释比例尺线的长度。

这可以是：

• "adaptive" - 计算出的长度适合由维度模型提供的一组刻度线。如果未提供刻度线，则行为与使用 "exact" 大小时相同

• "exact" - 计算出的长度按原样使用

level = 'annotation'

Type:

Enum(RenderLevel)

指定绘制此渲染器的层级。

location = 'top_right'

Type:

Either(Enum(Anchor), Tuple(Either(Enum(HAlign), Float, Either(Float, Datetime, Factor)), Either(Enum(VAlign), Float, Either(Float, Datetime, Factor))))

刻度条在其父容器（通常是笛卡尔坐标系）中的位置。

margin = 10

Type:

整数

刻度条外部周围的边距大小（以像素为单位）。

name = None

Type:

Nullable(String)

此模型的一个任意的、用户提供的名称。

当查询文档以检索特定的 Bokeh 模型时，此名称可能很有用。

>>> plot.scatter([1,2,3], [4,5,6], name="temp")
>>> plot.select(name="temp")
[GlyphRenderer(id='399d53f5-73e9-44d9-9527-544b761c7705', ...)]

注意

对于提供的任何名称，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用该名称。

orientation = 'horizontal'

Type:

Enum(Orientation)

指示刻度条应水平还是垂直方向。

padding = 10

Type:

整数

刻度条内容与其边框之间的内边距大小（以像素为单位）。

propagate_hover = False

Type:

布尔值

允许将悬停事件传播到父级渲染器、框架或画布。

注意

此属性是实验性的，随时可能更改。

range = 'auto'

Type:

Either(Instance(Range), Auto)

用于显示刻度的范围。

它可以是范围引用或 "auto"，在这种情况下，刻度条将根据其方向选择框架的默认 x 或 y 范围。

renderers = []

Type:

List

附加到此渲染器的一组渲染器。

注意

此属性是实验性的，随时可能更改。

styles = {}

Type:

Either(Dict(String, Nullable(String)), Instance(Styles))

应用于底层 DOM 元素的内联 CSS 样式。

stylesheets = []

Type:

List

用于底层 DOM 元素的其他样式表。

请注意，所有 Bokeh 组件都使用 shadow DOM，因此任何包含的样式表都必须反映这一点，例如，使用 :host CSS 伪选择器来访问根 DOM 元素。

syncable = True

Type:

布尔值

指示此模型在 Web 浏览器中更新时是否应同步回 Bokeh 服务器。当处理频繁更新的对象而我们不需要其更新值时，设置为 False 可能有助于减少网络流量。

注意

将此属性设置为 False 将阻止此对象上的任何 on_change() 回调被触发。但是，任何 JS 端的回调仍然有效。

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

当查询文档以检索特定的 Bokeh 模型时，此数据可能很有用

>>> r = plot.scatter([1,2,3], [4,5,6])
>>> r.tags = ["foo", 10]
>>> plot.select(tags=['foo', 10])
[GlyphRenderer(id='1de4c3df-a83d-480a-899b-fb263d3d5dd9', ...)]

或者只是将任何必要的元数据附加到可以通过 CustomJS 回调等访问的模型的一种便捷方式。

注意

对于提供的任何标签，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用这些标签。

ticker = FixedTicker(id='p55240', ...)

Type:

Instance(Ticker)

用于计算轴组件位置的 Ticker。

请注意，如果使用默认的 fixed ticker 且没有预定义的刻度，则刻度条的外观将只是一个没有其他标记的实心条。

title = ''

Type:

String

要渲染的标题文本。

title_align = 'center'

Type:

Enum(Align)

指定刻度条标题沿条的对齐方式。

当将标题放置在水平刻度条的上方或下方，或垂直刻度条的左侧或右侧时，此属性有效。

title_location = 'above'

Type:

Enum(Location)

指定标题将位于图例的哪一侧。

title_standoff = 5

Type:

整数

标题与刻度条之间的距离（以像素为单位）。

title_text_align = 'left'

Type:

Enum(TextAlign)

标题文本样式的文本对齐值。

title_text_alpha = 1.0

Type:

Alpha（透明度）

标题文本样式的文本 alpha 值。

title_text_baseline = 'bottom'

Type:

Enum(TextBaseline)

标题文本样式的文本基线值。

title_text_color = '#444444'

Type:

Nullable(Color)

标题文本样式的文本颜色值。

title_text_font = 'helvetica'

Type:

String

标题文本样式的文本字体值。

title_text_font_size = '13px'

Type:

FontSize

标题文本样式的文本字体大小值。

title_text_font_style = 'italic'

Type:

Enum(FontStyle)

标题文本样式的文本字体样式值。

title_text_line_height = 1.2

Type:

浮点数

标题文本样式的文本行高值。

title_text_outline_color = None

Type:

Nullable(Color)

标题文本样式的文本轮廓颜色值。

unit = 'm'

Type:

String

range 属性的单位。

visible = True

Type:

布尔值

渲染器是否可见。

x_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）x 轴范围。如果未设置，则使用默认 x 轴范围。

x_units = 'data'

Type:

Enum(Enumeration(data, screen, view, percent))

position 属性中提供的 x 坐标值的解释。

y_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）y 轴范围。如果未设置，则使用默认 y 轴范围。

y_units = 'data'

Type:

Enum(Enumeration(data, screen, view, percent))

position 属性中提供的 y 坐标值的解释。

apply_theme(property_values: dict[str, Any]) → None

应用一组主题值，这些值将代替默认值使用，但不会覆盖应用程序设置的值。

传入的字典可以保持原样并与其他实例共享以节省内存（因此调用者和 HasProps 实例都不应修改它）。

参数:

property_values (dict) – 用于代替默认值的主题值

返回值:

None

classmethod clear_extensions() → None

清除任何当前定义的自定义扩展。

序列化调用将导致任何当前定义的自定义扩展包含在生成的文档中，无论是否被使用。此方法可用于清除所有现有的自定义扩展定义。

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

这将创建原始模型的浅克隆，即任何可变容器或子模型都不会被复制。允许在克隆时覆盖特定属性。

classmethod dataspecs() → dict[str, DataSpec]

收集此类上所有 DataSpec 属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

on_change(attr: str, *callbacks: PropertyCallback) → None

在此对象上添加回调，以便在 attr 更改时触发。

参数:

• attr (str) – 此对象上的属性名称

• *callbacks (callable) – 要注册的回调函数

返回值:

None

示例

widget.on_change('value', callback1, callback2, ..., callback_n)

on_event(event: str | type[Event], *callbacks: Callable[[Event], None] | Callable[[], None]) → None

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 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]]

收集此类上所有也具有引用的属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

具有引用的属性的名称

Return type:

set[str]

properties_with_values(*, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

收集一个字典，将属性名称映射到它们的值。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

不可序列化的属性将被跳过，并且属性值采用“序列化”格式，这可能与您通常从属性中读取的值略有不同；此方法的目的是返回无损地重构对象实例所需的信息。

参数:

include_defaults (bool, 可选) – 是否包含自对象创建以来尚未显式设置的属性。（默认值：True）

返回值:

从属性名称到其值的映射

Return type:

dict

query_properties_with_values(query: Callable[[PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

使用谓词查询 HasProps 实例的属性值。

参数:

• query (callable) – 一个可调用对象，它接受属性描述符并返回 True 或 False

• include_defaults (bool, 可选) – 是否包含用户尚未显式设置的属性（默认值：True）

返回值:

匹配属性的属性名称和值的映射

Return type:

dict

references() → set[Model]

返回此对象引用的所有 Models。

remove_on_change(attr: str, *callbacks: Callable[[str, Any, Any], None]) → None

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

查询此对象及其所有引用，以查找与给定选择器匹配的对象。

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

查询此对象及其所有引用，以查找与给定选择器匹配的对象。如果找到多个对象，则引发错误。返回单个匹配对象，如果未找到任何对象，则返回 None :param selector: :type selector: JSON-like

返回值:

Model

set_from_json(name: str, value: Any, *, setter: Setter | None = None) → None

从 JSON 在此对象上设置属性值。

参数:

• name (str) – 要设置的属性的名称

• value (JSON-value) – 要设置为属性的值

• setter (ClientSession 或 ServerSession 或 None, 可选) –

  这用于防止对 Bokeh 应用程序的“回旋镖”更新。

  在 Bokeh 服务器应用程序的上下文中，传入的属性更新将使用正在执行更新的会话进行注释。此值会通过更新触发的任何后续更改通知进行传播。会话可以将事件 setter 与自身进行比较，并抑制任何源自自身的更新。

返回值:

None

set_select(selector: type[Model] | SelectorType, updates: dict[str, Any]) → None

使用指定的属性/值更新来更新与给定选择器匹配的对象。

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

删除任何主题值并恢复默认值。

返回值:

None

update(**kwargs: Any) → None

从给定的关键字参数更新对象的属性。

返回值:

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 Slope(*args: Any, id: ID | None = None, **kwargs: Any)

Bases: Annotation

将倾斜线渲染为注释。

有关绘制斜率的信息，请参阅斜率。

JSON 原型

{
  "above_fill_alpha": 0.4, 
  "above_fill_color": null, 
  "above_hatch_alpha": 1.0, 
  "above_hatch_color": "black", 
  "above_hatch_extra": {
    "type": "map"
  }, 
  "above_hatch_pattern": null, 
  "above_hatch_scale": 12.0, 
  "above_hatch_weight": 1.0, 
  "below_fill_alpha": 0.4, 
  "below_fill_color": null, 
  "below_hatch_alpha": 1.0, 
  "below_hatch_color": "black", 
  "below_hatch_extra": {
    "type": "map"
  }, 
  "below_hatch_pattern": null, 
  "below_hatch_scale": 12.0, 
  "below_hatch_weight": 1.0, 
  "context_menu": null, 
  "coordinates": null, 
  "css_classes": [], 
  "css_variables": {
    "type": "map"
  }, 
  "elements": [], 
  "gradient": null, 
  "group": null, 
  "html_attributes": {
    "type": "map"
  }, 
  "html_id": null, 
  "id": "p55298", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "level": "annotation", 
  "line_alpha": 1.0, 
  "line_cap": "butt", 
  "line_color": "black", 
  "line_dash": [], 
  "line_dash_offset": 0, 
  "line_join": "bevel", 
  "line_width": 1, 
  "name": null, 
  "propagate_hover": false, 
  "renderers": [], 
  "styles": {
    "type": "map"
  }, 
  "stylesheets": [], 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": [], 
  "visible": true, 
  "x_range_name": "default", 
  "y_intercept": null, 
  "y_range_name": "default"
}

above_fill_alpha = 0.4

Type:

Alpha（透明度）

线上区域的填充 alpha 值。

above_fill_color = None

Type:

Nullable(Color)

线上区域的填充颜色值。

above_hatch_alpha = 1.0

Type:

Alpha（透明度）

线上区域的阴影线 alpha 值。

above_hatch_color = 'black'

Type:

Nullable(Color)

线上区域的阴影线颜色值。

above_hatch_extra = {}

Type:

Dict(String, Instance(Texture))

线上区域的额外阴影线值。

above_hatch_pattern = None

Type:

Nullable(String)

线上区域的阴影线图案值。

above_hatch_scale = 12.0

Type:

尺寸

线上区域的阴影线比例值。

above_hatch_weight = 1.0

Type:

尺寸

线上区域的阴影线粗细值。

below_fill_alpha = 0.4

Type:

Alpha（透明度）

线下区域的填充 alpha 值。

below_fill_color = None

Type:

Nullable(Color)

线下区域的填充颜色值。

below_hatch_alpha = 1.0

Type:

Alpha（透明度）

线下区域的阴影线 alpha 值。

below_hatch_color = 'black'

Type:

Nullable(Color)

线下区域的阴影线颜色值。

below_hatch_extra = {}

Type:

Dict(String, Instance(Texture))

线下区域的额外阴影线值。

below_hatch_pattern = None

Type:

Nullable(String)

线下区域的阴影线图案值。

below_hatch_scale = 12.0

Type:

尺寸

线下区域的阴影线比例值。

below_hatch_weight = 1.0

Type:

尺寸

线下区域的阴影线粗细值。

context_menu = None

Type:

Nullable(Instance(‘.models.ui.Menu’))

当用户右键单击组件时显示的菜单。

注意

右键单击时使用 shift 键显示原生上下文菜单。

css_classes = []

Type:

List

要添加到底层 DOM 元素的其他 CSS 类列表。

css_variables = {}

Type:

Dict(String, Either(String, Instance(Node)))

允许定义动态计算的 CSS 变量。

例如，这可以用于协调画布渲染器和/或视觉效果与基于 HTML 的 UI 元素之间的定位和样式设置。

此处定义的变量等效于在 CSS 样式表中的 :host { ... } 下设置相同的变量。

注意

此属性是实验性的，随时可能更改。

elements = []

Type:

List

附加到此渲染器的基于 DOM 的 UI 元素集合。

这可以包括浮动元素（如工具提示），从而允许在此渲染器及其 UI 元素之间建立父子关系。

注意

此属性等效于基于 DOM 的 UI 中的 Pane.elements。

gradient = None

Type:

Nullable(Float)

线的梯度，单位为数据单位

group = None

Type:

Nullable(Instance(RendererGroup))

注意

此属性是实验性的，随时可能更改。

html_attributes = {}

Type:

Dict(String, String)

允许在底层 HTML 元素上配置 HTML 属性。

html_id = None

Type:

Nullable(String)

设置底层 HTML 元素的 id 属性。

这是常用 HTML id 属性的简写形式。或者，id 也可以在 html_attributes 字典中设置。html_id 优先。

level = 'annotation'

Type:

Enum(RenderLevel)

指定绘制此渲染器的层级。

line_alpha = 1.0

Type:

Alpha（透明度）

线的线条 alpha 值。

line_cap = 'butt'

Type:

Enum(LineCap)

线的线帽值。

line_color = 'black'

Type:

Nullable(Color)

线的线条颜色值。

line_dash = []

Type:

虚线模式

线的线条虚线值。

line_dash_offset = 0

Type:

整数

线的线条虚线偏移值。

line_join = 'bevel'

Type:

Enum(LineJoin)

线的线连接值。

line_width = 1

Type:

浮点数

线的线条宽度值。

name = None

Type:

Nullable(String)

此模型的一个任意的、用户提供的名称。

当查询文档以检索特定的 Bokeh 模型时，此名称可能很有用。

>>> plot.scatter([1,2,3], [4,5,6], name="temp")
>>> plot.select(name="temp")
[GlyphRenderer(id='399d53f5-73e9-44d9-9527-544b761c7705', ...)]

注意

对于提供的任何名称，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用该名称。

propagate_hover = False

Type:

布尔值

允许将悬停事件传播到父级渲染器、框架或画布。

注意

此属性是实验性的，随时可能更改。

renderers = []

Type:

List

附加到此渲染器的一组渲染器。

注意

此属性是实验性的，随时可能更改。

styles = {}

Type:

Either(Dict(String, Nullable(String)), Instance(Styles))

应用于底层 DOM 元素的内联 CSS 样式。

stylesheets = []

Type:

List

用于底层 DOM 元素的其他样式表。

请注意，所有 Bokeh 组件都使用 shadow DOM，因此任何包含的样式表都必须反映这一点，例如，使用 :host CSS 伪选择器来访问根 DOM 元素。

syncable = True

Type:

布尔值

指示此模型在 Web 浏览器中更新时是否应同步回 Bokeh 服务器。当处理频繁更新的对象而我们不需要其更新值时，设置为 False 可能有助于减少网络流量。

注意

将此属性设置为 False 将阻止此对象上的任何 on_change() 回调被触发。但是，任何 JS 端的回调仍然有效。

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

当查询文档以检索特定的 Bokeh 模型时，此数据可能很有用

>>> r = plot.scatter([1,2,3], [4,5,6])
>>> r.tags = ["foo", 10]
>>> plot.select(tags=['foo', 10])
[GlyphRenderer(id='1de4c3df-a83d-480a-899b-fb263d3d5dd9', ...)]

或者只是将任何必要的元数据附加到可以通过 CustomJS 回调等访问的模型的一种便捷方式。

注意

对于提供的任何标签，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用这些标签。

visible = True

Type:

布尔值

渲染器是否可见。

x_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）x 轴范围。如果未设置，则使用默认 x 轴范围。

y_intercept = None

Type:

Nullable(Float)

线的 y 轴截距，单位为数据单位

y_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）y 轴范围。如果未设置，则使用默认 y 轴范围。

apply_theme(property_values: dict[str, Any]) → None

应用一组主题值，这些值将代替默认值使用，但不会覆盖应用程序设置的值。

传入的字典可以保持原样并与其他实例共享以节省内存（因此调用者和 HasProps 实例都不应修改它）。

参数:

property_values (dict) – 用于代替默认值的主题值

返回值:

None

classmethod clear_extensions() → None

清除任何当前定义的自定义扩展。

序列化调用将导致任何当前定义的自定义扩展包含在生成的文档中，无论是否被使用。此方法可用于清除所有现有的自定义扩展定义。

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

这将创建原始模型的浅克隆，即任何可变容器或子模型都不会被复制。允许在克隆时覆盖特定属性。

classmethod dataspecs() → dict[str, DataSpec]

收集此类上所有 DataSpec 属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

on_change(attr: str, *callbacks: PropertyCallback) → None

在此对象上添加回调，以便在 attr 更改时触发。

参数:

• attr (str) – 此对象上的属性名称

• *callbacks (callable) – 要注册的回调函数

返回值:

None

示例

widget.on_change('value', callback1, callback2, ..., callback_n)

on_event(event: str | type[Event], *callbacks: Callable[[Event], None] | Callable[[], None]) → None

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 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]]

收集此类上所有也具有引用的属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

具有引用的属性的名称

Return type:

set[str]

properties_with_values(*, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

收集一个字典，将属性名称映射到它们的值。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

不可序列化的属性将被跳过，并且属性值采用“序列化”格式，这可能与您通常从属性中读取的值略有不同；此方法的目的是返回无损地重构对象实例所需的信息。

参数:

include_defaults (bool, 可选) – 是否包含自对象创建以来尚未显式设置的属性。（默认值：True）

返回值:

从属性名称到其值的映射

Return type:

dict

query_properties_with_values(query: Callable[[PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

使用谓词查询 HasProps 实例的属性值。

参数:

• query (callable) – 一个可调用对象，它接受属性描述符并返回 True 或 False

• include_defaults (bool, 可选) – 是否包含用户尚未显式设置的属性（默认值：True）

返回值:

匹配属性的属性名称和值的映射

Return type:

dict

references() → set[Model]

返回此对象引用的所有 Models。

remove_on_change(attr: str, *callbacks: Callable[[str, Any, Any], None]) → None

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

查询此对象及其所有引用，以查找与给定选择器匹配的对象。

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

查询此对象及其所有引用，以查找与给定选择器匹配的对象。如果找到多个对象，则引发错误。返回单个匹配对象，如果未找到任何对象，则返回 None :param selector: :type selector: JSON-like

返回值:

Model

set_from_json(name: str, value: Any, *, setter: Setter | None = None) → None

从 JSON 在此对象上设置属性值。

参数:

• name (str) – 要设置的属性的名称

• value (JSON-value) – 要设置为属性的值

• setter (ClientSession 或 ServerSession 或 None, 可选) –

  这用于防止对 Bokeh 应用程序的“回旋镖”更新。

  在 Bokeh 服务器应用程序的上下文中，传入的属性更新将使用正在执行更新的会话进行注释。此值会通过更新触发的任何后续更改通知进行传播。会话可以将事件 setter 与自身进行比较，并抑制任何源自自身的更新。

返回值:

None

set_select(selector: type[Model] | SelectorType, updates: dict[str, Any]) → None

使用指定的属性/值更新来更新与给定选择器匹配的对象。

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

删除任何主题值并恢复默认值。

返回值:

None

update(**kwargs: Any) → None

从给定的关键字参数更新对象的属性。

返回值:

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 Span(*args: Any, id: ID | None = None, **kwargs: Any)

Bases: Annotation

渲染水平或垂直线跨度。

有关绘制跨度的信息，请参阅 跨度。

JSON 原型

{
  "context_menu": null, 
  "coordinates": null, 
  "css_classes": [], 
  "css_variables": {
    "type": "map"
  }, 
  "dimension": "width", 
  "editable": false, 
  "elements": [], 
  "group": null, 
  "hover_line_alpha": 0.3, 
  "hover_line_cap": "butt", 
  "hover_line_color": null, 
  "hover_line_dash": [], 
  "hover_line_dash_offset": 0, 
  "hover_line_join": "bevel", 
  "hover_line_width": 1, 
  "html_attributes": {
    "type": "map"
  }, 
  "html_id": null, 
  "id": "p55342", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "level": "annotation", 
  "line_alpha": 1.0, 
  "line_cap": "butt", 
  "line_color": "black", 
  "line_dash": [], 
  "line_dash_offset": 0, 
  "line_join": "bevel", 
  "line_width": 1, 
  "location": null, 
  "location_units": "data", 
  "name": null, 
  "propagate_hover": false, 
  "renderers": [], 
  "styles": {
    "type": "map"
  }, 
  "stylesheets": [], 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": [], 
  "visible": true, 
  "x_range_name": "default", 
  "y_range_name": "default"
}

context_menu = None

Type:

Nullable(Instance(‘.models.ui.Menu’))

当用户右键单击组件时显示的菜单。

注意

右键单击时使用 shift 键显示原生上下文菜单。

css_classes = []

Type:

List

要添加到底层 DOM 元素的其他 CSS 类列表。

css_variables = {}

Type:

Dict(String, Either(String, Instance(Node)))

允许定义动态计算的 CSS 变量。

例如，这可以用于协调画布渲染器和/或视觉效果与基于 HTML 的 UI 元素之间的定位和样式设置。

此处定义的变量等效于在 CSS 样式表中的 :host { ... } 下设置相同的变量。

注意

此属性是实验性的，随时可能更改。

dimension = 'width'

Type:

Enum(Dimension)

跨度的方向可以通过将此属性设置为“height”（y 方向）或“width”（x 方向）来指定。

editable = False

Type:

布尔值

允许交互式修改此跨度的几何形状。

注意

此属性是实验性的，随时可能更改。

elements = []

Type:

List

附加到此渲染器的基于 DOM 的 UI 元素集合。

这可以包括浮动元素（如工具提示），从而允许在此渲染器及其 UI 元素之间建立父子关系。

注意

此属性等效于基于 DOM 的 UI 中的 Pane.elements。

group = None

Type:

Nullable(Instance(RendererGroup))

注意

此属性是实验性的，随时可能更改。

hover_line_alpha = 0.3

Type:

Alpha（透明度）

悬停在跨度上方时的线条 alpha 值。

hover_line_cap = 'butt'

Type:

Enum(LineCap)

悬停在跨度上方时的线帽值。

hover_line_color = None

Type:

Nullable(Color)

悬停在跨度上方时的线条颜色值。

hover_line_dash = []

Type:

虚线模式

悬停在跨度上方时的线条虚线值。

hover_line_dash_offset = 0

Type:

整数

悬停在跨度上方时的线条虚线偏移值。

hover_line_join = 'bevel'

Type:

Enum(LineJoin)

悬停在跨度上方时的线条连接值。

hover_line_width = 1

Type:

浮点数

悬停在跨度上方时的线条宽度值。

html_attributes = {}

Type:

Dict(String, String)

允许在底层 HTML 元素上配置 HTML 属性。

html_id = None

Type:

Nullable(String)

设置底层 HTML 元素的 id 属性。

这是常用 HTML id 属性的简写形式。或者，id 也可以在 html_attributes 字典中设置。html_id 优先。

level = 'annotation'

Type:

Enum(RenderLevel)

指定绘制此渲染器的层级。

line_alpha = 1.0

Type:

Alpha（透明度）

跨度的线条 alpha 值。

line_cap = 'butt'

Type:

Enum(LineCap)

跨度的线帽值。

line_color = 'black'

Type:

Nullable(Color)

跨度的线条颜色值。

line_dash = []

Type:

虚线模式

跨度的线条虚线值。

line_dash_offset = 0

Type:

整数

跨度的线条虚线偏移值。

line_join = 'bevel'

Type:

Enum(LineJoin)

跨度的线条连接值。

line_width = 1

Type:

浮点数

跨度的线条宽度值。

location = None

Type:

Nullable(Either(Float, Datetime, Factor))

跨度沿 dimension 的位置。

location_units = 'data'

Type:

Enum(CoordinateUnits)

位置属性的单位类型。默认解释为“数据空间”单位。

name = None

Type:

Nullable(String)

此模型的一个任意的、用户提供的名称。

当查询文档以检索特定的 Bokeh 模型时，此名称可能很有用。

>>> plot.scatter([1,2,3], [4,5,6], name="temp")
>>> plot.select(name="temp")
[GlyphRenderer(id='399d53f5-73e9-44d9-9527-544b761c7705', ...)]

注意

对于提供的任何名称，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用该名称。

propagate_hover = False

Type:

布尔值

允许将悬停事件传播到父级渲染器、框架或画布。

注意

此属性是实验性的，随时可能更改。

renderers = []

Type:

List

附加到此渲染器的一组渲染器。

注意

此属性是实验性的，随时可能更改。

styles = {}

Type:

Either(Dict(String, Nullable(String)), Instance(Styles))

应用于底层 DOM 元素的内联 CSS 样式。

stylesheets = []

Type:

List

用于底层 DOM 元素的其他样式表。

请注意，所有 Bokeh 组件都使用 shadow DOM，因此任何包含的样式表都必须反映这一点，例如，使用 :host CSS 伪选择器来访问根 DOM 元素。

syncable = True

Type:

布尔值

指示此模型在 Web 浏览器中更新时是否应同步回 Bokeh 服务器。当处理频繁更新的对象而我们不需要其更新值时，设置为 False 可能有助于减少网络流量。

注意

将此属性设置为 False 将阻止此对象上的任何 on_change() 回调被触发。但是，任何 JS 端的回调仍然有效。

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

当查询文档以检索特定的 Bokeh 模型时，此数据可能很有用

>>> r = plot.scatter([1,2,3], [4,5,6])
>>> r.tags = ["foo", 10]
>>> plot.select(tags=['foo', 10])
[GlyphRenderer(id='1de4c3df-a83d-480a-899b-fb263d3d5dd9', ...)]

或者只是将任何必要的元数据附加到可以通过 CustomJS 回调等访问的模型的一种便捷方式。

注意

对于提供的任何标签，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用这些标签。

visible = True

Type:

布尔值

渲染器是否可见。

x_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）x 轴范围。如果未设置，则使用默认 x 轴范围。

y_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）y 轴范围。如果未设置，则使用默认 y 轴范围。

apply_theme(property_values: dict[str, Any]) → None

应用一组主题值，这些值将代替默认值使用，但不会覆盖应用程序设置的值。

传入的字典可以保持原样并与其他实例共享以节省内存（因此调用者和 HasProps 实例都不应修改它）。

参数:

property_values (dict) – 用于代替默认值的主题值

返回值:

None

classmethod clear_extensions() → None

清除任何当前定义的自定义扩展。

序列化调用将导致任何当前定义的自定义扩展包含在生成的文档中，无论是否被使用。此方法可用于清除所有现有的自定义扩展定义。

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

这将创建原始模型的浅克隆，即任何可变容器或子模型都不会被复制。允许在克隆时覆盖特定属性。

classmethod dataspecs() → dict[str, DataSpec]

收集此类上所有 DataSpec 属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

on_change(attr: str, *callbacks: PropertyCallback) → None

在此对象上添加回调，以便在 attr 更改时触发。

参数:

• attr (str) – 此对象上的属性名称

• *callbacks (callable) – 要注册的回调函数

返回值:

None

示例

widget.on_change('value', callback1, callback2, ..., callback_n)

on_event(event: str | type[Event], *callbacks: Callable[[Event], None] | Callable[[], None]) → None

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 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]]

收集此类上所有也具有引用的属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

具有引用的属性的名称

Return type:

set[str]

properties_with_values(*, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

收集一个字典，将属性名称映射到它们的值。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

不可序列化的属性将被跳过，并且属性值采用“序列化”格式，这可能与您通常从属性中读取的值略有不同；此方法的目的是返回无损地重构对象实例所需的信息。

参数:

include_defaults (bool, 可选) – 是否包含自对象创建以来尚未显式设置的属性。（默认值：True）

返回值:

从属性名称到其值的映射

Return type:

dict

query_properties_with_values(query: Callable[[PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

使用谓词查询 HasProps 实例的属性值。

参数:

• query (callable) – 一个可调用对象，它接受属性描述符并返回 True 或 False

• include_defaults (bool, 可选) – 是否包含用户尚未显式设置的属性（默认值：True）

返回值:

匹配属性的属性名称和值的映射

Return type:

dict

references() → set[Model]

返回此对象引用的所有 Models。

remove_on_change(attr: str, *callbacks: Callable[[str, Any, Any], None]) → None

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

查询此对象及其所有引用，以查找与给定选择器匹配的对象。

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

查询此对象及其所有引用，以查找与给定选择器匹配的对象。如果找到多个对象，则引发错误。返回单个匹配对象，如果未找到任何对象，则返回 None :param selector: :type selector: JSON-like

返回值:

Model

set_from_json(name: str, value: Any, *, setter: Setter | None = None) → None

从 JSON 在此对象上设置属性值。

参数:

• name (str) – 要设置的属性的名称

• value (JSON-value) – 要设置为属性的值

• setter (ClientSession 或 ServerSession 或 None, 可选) –

  这用于防止对 Bokeh 应用程序的“回旋镖”更新。

  在 Bokeh 服务器应用程序的上下文中，传入的属性更新将使用正在执行更新的会话进行注释。此值会通过更新触发的任何后续更改通知进行传播。会话可以将事件 setter 与自身进行比较，并抑制任何源自自身的更新。

返回值:

None

set_select(selector: type[Model] | SelectorType, updates: dict[str, Any]) → None

使用指定的属性/值更新来更新与给定选择器匹配的对象。

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

删除任何主题值并恢复默认值。

返回值:

None

update(**kwargs: Any) → None

从给定的关键字参数更新对象的属性。

返回值:

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 TeeHead(*args: Any, id: ID | None = None, **kwargs: Any)

基簎： ArrowHead

渲染 T 字形箭头头部。

JSON 原型

{
  "id": "p55379", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "line_alpha": {
    "type": "value", 
    "value": 1.0
  }, 
  "line_cap": {
    "type": "value", 
    "value": "butt"
  }, 
  "line_color": {
    "type": "value", 
    "value": "black"
  }, 
  "line_dash": {
    "type": "value", 
    "value": []
  }, 
  "line_dash_offset": {
    "type": "value", 
    "value": 0
  }, 
  "line_join": {
    "type": "value", 
    "value": "bevel"
  }, 
  "line_width": {
    "type": "value", 
    "value": 1
  }, 
  "name": null, 
  "size": {
    "type": "value", 
    "value": 25
  }, 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": []
}

line_alpha = 1.0

Type:

AlphaSpec

箭头轮廓的线条 alpha 值。

line_cap = 'butt'

Type:

LineCapSpec

箭头轮廓的线条端点值。

line_color = 'black'

Type:

ColorSpec

箭头轮廓的线条颜色值。

line_dash = []

Type:

DashPatternSpec

箭头轮廓的线条虚线值。

line_dash_offset = 0

Type:

IntSpec

箭头轮廓的线条虚线偏移值。

line_join = 'bevel'

Type:

LineJoinSpec

箭头轮廓的线条连接值。

line_width = 1

Type:

FloatSpec

箭头轮廓的线条宽度值。

name = None

Type:

Nullable(String)

此模型的一个任意的、用户提供的名称。

当查询文档以检索特定的 Bokeh 模型时，此名称可能很有用。

>>> plot.scatter([1,2,3], [4,5,6], name="temp")
>>> plot.select(name="temp")
[GlyphRenderer(id='399d53f5-73e9-44d9-9527-544b761c7705', ...)]

注意

对于提供的任何名称，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用该名称。

size = 25

Type:

NumberSpec

箭头箭头的大小，以像素为单位。

syncable = True

Type:

布尔值

指示此模型在 Web 浏览器中更新时是否应同步回 Bokeh 服务器。当处理频繁更新的对象而我们不需要其更新值时，设置为 False 可能有助于减少网络流量。

注意

将此属性设置为 False 将阻止此对象上的任何 on_change() 回调被触发。但是，任何 JS 端的回调仍然有效。

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

当查询文档以检索特定的 Bokeh 模型时，此数据可能很有用

>>> r = plot.scatter([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) – 用于代替默认值的主题值

返回值:

None

classmethod clear_extensions() → None

清除任何当前定义的自定义扩展。

序列化调用将导致任何当前定义的自定义扩展包含在生成的文档中，无论是否被使用。此方法可用于清除所有现有的自定义扩展定义。

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

这将创建原始模型的浅克隆，即任何可变容器或子模型都不会被复制。允许在克隆时覆盖特定属性。

classmethod dataspecs() → dict[str, DataSpec]

收集此类上所有 DataSpec 属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

on_change(attr: str, *callbacks: PropertyCallback) → None

在此对象上添加回调，以便在 attr 更改时触发。

参数:

• attr (str) – 此对象上的属性名称

• *callbacks (callable) – 要注册的回调函数

返回值:

None

示例

widget.on_change('value', callback1, callback2, ..., callback_n)

on_event(event: str | type[Event], *callbacks: Callable[[Event], None] | Callable[[], None]) → None

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 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]]

收集此类上所有也具有引用的属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

具有引用的属性的名称

Return type:

set[str]

properties_with_values(*, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

收集一个字典，将属性名称映射到它们的值。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

不可序列化的属性将被跳过，并且属性值采用“序列化”格式，这可能与您通常从属性中读取的值略有不同；此方法的目的是返回无损地重构对象实例所需的信息。

参数:

include_defaults (bool, 可选) – 是否包含自对象创建以来尚未显式设置的属性。（默认值：True）

返回值:

从属性名称到其值的映射

Return type:

dict

query_properties_with_values(query: Callable[[PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

使用谓词查询 HasProps 实例的属性值。

参数:

• query (callable) – 一个可调用对象，它接受属性描述符并返回 True 或 False

• include_defaults (bool, 可选) – 是否包含用户尚未显式设置的属性（默认值：True）

返回值:

匹配属性的属性名称和值的映射

Return type:

dict

references() → set[Model]

返回此对象引用的所有 Models。

remove_on_change(attr: str, *callbacks: Callable[[str, Any, Any], None]) → None

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

查询此对象及其所有引用，以查找与给定选择器匹配的对象。

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

查询此对象及其所有引用，以查找与给定选择器匹配的对象。如果找到多个对象，则引发错误。返回单个匹配对象，如果未找到任何对象，则返回 None :param selector: :type selector: JSON-like

返回值:

Model

set_from_json(name: str, value: Any, *, setter: Setter | None = None) → None

从 JSON 在此对象上设置属性值。

参数:

• name (str) – 要设置的属性的名称

• value (JSON-value) – 要设置为属性的值

• setter (ClientSession 或 ServerSession 或 None, 可选) –

  这用于防止对 Bokeh 应用程序的“回旋镖”更新。

  在 Bokeh 服务器应用程序的上下文中，传入的属性更新将使用正在执行更新的会话进行注释。此值会通过更新触发的任何后续更改通知进行传播。会话可以将事件 setter 与自身进行比较，并抑制任何源自自身的更新。

返回值:

None

set_select(selector: type[Model] | SelectorType, updates: dict[str, Any]) → None

使用指定的属性/值更新来更新与给定选择器匹配的对象。

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

删除任何主题值并恢复默认值。

返回值:

None

update(**kwargs: Any) → None

从给定的关键字参数更新对象的属性。

返回值:

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)

类 TextAnnotation(*args: Any, id: ID | None = None, **kwargs: Any)

Bases: Annotation

用于文本注释模型（如标签和标题）的基类。

注意

这是一个抽象基类，用于帮助组织 Bokeh 模型类型的层次结构。它本身实例化没有用处。

JSON 原型

{
  "background_fill_alpha": 1.0, 
  "background_fill_color": null, 
  "background_hatch_alpha": 1.0, 
  "background_hatch_color": "black", 
  "background_hatch_extra": {
    "type": "map"
  }, 
  "background_hatch_pattern": null, 
  "background_hatch_scale": 12.0, 
  "background_hatch_weight": 1.0, 
  "border_line_alpha": 1.0, 
  "border_line_cap": "butt", 
  "border_line_color": null, 
  "border_line_dash": [], 
  "border_line_dash_offset": 0, 
  "border_line_join": "bevel", 
  "border_line_width": 1, 
  "border_radius": 0, 
  "context_menu": null, 
  "coordinates": null, 
  "css_classes": [], 
  "css_variables": {
    "type": "map"
  }, 
  "elements": [], 
  "group": null, 
  "html_attributes": {
    "type": "map"
  }, 
  "html_id": null, 
  "id": "p55391", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "level": "annotation", 
  "name": null, 
  "padding": 0, 
  "propagate_hover": false, 
  "renderers": [], 
  "styles": {
    "type": "map"
  }, 
  "stylesheets": [], 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": [], 
  "text": "", 
  "text_align": "left", 
  "text_alpha": 1.0, 
  "text_baseline": "bottom", 
  "text_color": "#444444", 
  "text_font": "helvetica", 
  "text_font_size": "16px", 
  "text_font_style": "normal", 
  "text_line_height": 1.2, 
  "text_outline_color": null, 
  "visible": true, 
  "x_range_name": "default", 
  "y_range_name": "default"
}

background_fill_alpha = 1.0

Type:

Alpha（透明度）

文本边框的填充 alpha 值。

background_fill_color = None

Type:

Nullable(Color)

文本边框的填充颜色值。

background_hatch_alpha = 1.0

Type:

Alpha（透明度）

文本边框的阴影线 alpha 值。

background_hatch_color = 'black'

Type:

Nullable(Color)

文本边框的阴影线颜色值。

background_hatch_extra = {}

Type:

Dict(String, Instance(Texture))

文本边框的阴影线额外值。

background_hatch_pattern = None

Type:

Nullable(String)

文本边框的阴影线图案值。

background_hatch_scale = 12.0

Type:

尺寸

文本边框的阴影线比例值。

background_hatch_weight = 1.0

Type:

尺寸

文本边框的阴影线粗细值。

border_line_alpha = 1.0

Type:

Alpha（透明度）

文本边框的线条 alpha 值。

border_line_cap = 'butt'

Type:

Enum(LineCap)

文本边框的线条端帽值。

border_line_color = None

Type:

Nullable(Color)

文本边框的线条颜色值。

border_line_dash = []

Type:

虚线模式

文本边框的线条虚线值。

border_line_dash_offset = 0

Type:

整数

文本边框的线条虚线偏移值。

border_line_join = 'bevel'

Type:

Enum(LineJoin)

文本边框的线条连接值。

border_line_width = 1

Type:

浮点数

文本边框的线条宽度值。

border_radius = 0

Type:

Either(NonNegative, Tuple(NonNegative, NonNegative, NonNegative, NonNegative), Struct)

允许标签的框具有圆角。为了获得最佳效果，应与 padding 结合使用。

注意

此属性是实验性的，随时可能更改。

context_menu = None

Type:

Nullable(Instance(‘.models.ui.Menu’))

当用户右键单击组件时显示的菜单。

注意

右键单击时使用 shift 键显示原生上下文菜单。

css_classes = []

Type:

List

要添加到底层 DOM 元素的其他 CSS 类列表。

css_variables = {}

Type:

Dict(String, Either(String, Instance(Node)))

允许定义动态计算的 CSS 变量。

例如，这可以用于协调画布渲染器和/或视觉效果与基于 HTML 的 UI 元素之间的定位和样式设置。

此处定义的变量等效于在 CSS 样式表中的 :host { ... } 下设置相同的变量。

注意

此属性是实验性的，随时可能更改。

elements = []

Type:

List

附加到此渲染器的基于 DOM 的 UI 元素集合。

这可以包括浮动元素（如工具提示），从而允许在此渲染器及其 UI 元素之间建立父子关系。

注意

此属性等效于基于 DOM 的 UI 中的 Pane.elements。

group = None

Type:

Nullable(Instance(RendererGroup))

注意

此属性是实验性的，随时可能更改。

html_attributes = {}

Type:

Dict(String, String)

允许在底层 HTML 元素上配置 HTML 属性。

html_id = None

Type:

Nullable(String)

设置底层 HTML 元素的 id 属性。

这是常用 HTML id 属性的简写形式。或者，id 也可以在 html_attributes 字典中设置。html_id 优先。

level = 'annotation'

Type:

Enum(RenderLevel)

指定绘制此渲染器的层级。

name = None

Type:

Nullable(String)

此模型的一个任意的、用户提供的名称。

当查询文档以检索特定的 Bokeh 模型时，此名称可能很有用。

>>> plot.scatter([1,2,3], [4,5,6], name="temp")
>>> plot.select(name="temp")
[GlyphRenderer(id='399d53f5-73e9-44d9-9527-544b761c7705', ...)]

注意

对于提供的任何名称，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用该名称。

padding = 0

Type:

Either(NonNegative, Tuple(NonNegative, NonNegative), Struct, Tuple(NonNegative, NonNegative, NonNegative, NonNegative), Struct)

标签文本与其边框之间额外的空间。

注意

此属性是实验性的，随时可能更改。

propagate_hover = False

Type:

布尔值

允许将悬停事件传播到父级渲染器、框架或画布。

注意

此属性是实验性的，随时可能更改。

renderers = []

Type:

List

附加到此渲染器的一组渲染器。

注意

此属性是实验性的，随时可能更改。

styles = {}

Type:

Either(Dict(String, Nullable(String)), Instance(Styles))

应用于底层 DOM 元素的内联 CSS 样式。

stylesheets = []

Type:

List

用于底层 DOM 元素的其他样式表。

请注意，所有 Bokeh 组件都使用 shadow DOM，因此任何包含的样式表都必须反映这一点，例如，使用 :host CSS 伪选择器来访问根 DOM 元素。

syncable = True

Type:

布尔值

指示此模型在 Web 浏览器中更新时是否应同步回 Bokeh 服务器。当处理频繁更新的对象而我们不需要其更新值时，设置为 False 可能有助于减少网络流量。

注意

将此属性设置为 False 将阻止此对象上的任何 on_change() 回调被触发。但是，任何 JS 端的回调仍然有效。

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

当查询文档以检索特定的 Bokeh 模型时，此数据可能很有用

>>> r = plot.scatter([1,2,3], [4,5,6])
>>> r.tags = ["foo", 10]
>>> plot.select(tags=['foo', 10])
[GlyphRenderer(id='1de4c3df-a83d-480a-899b-fb263d3d5dd9', ...)]

或者只是将任何必要的元数据附加到可以通过 CustomJS 回调等访问的模型的一种便捷方式。

注意

对于提供的任何标签，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用这些标签。

text = ''

Type:

文本类型

要渲染的文本或 LaTeX 符号。

text_align = 'left'

Type:

Enum(TextAlign)

文本的文本对齐值。

text_alpha = 1.0

Type:

Alpha（透明度）

文本的文本 alpha 值。

text_baseline = 'bottom'

Type:

Enum(TextBaseline)

文本的文本基线值。

text_color = '#444444'

Type:

Nullable(Color)

文本的文本颜色值。

text_font = 'helvetica'

Type:

String

文本的文本字体值。

text_font_size = '16px'

Type:

FontSize

文本的文本字体大小值。

text_font_style = 'normal'

Type:

Enum(FontStyle)

文本的文本字体样式值。

text_line_height = 1.2

Type:

浮点数

文本的文本行高值。

text_outline_color = None

Type:

Nullable(Color)

文本的文本轮廓颜色值。

visible = True

Type:

布尔值

渲染器是否可见。

x_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）x 轴范围。如果未设置，则使用默认 x 轴范围。

y_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）y 轴范围。如果未设置，则使用默认 y 轴范围。

apply_theme(property_values: dict[str, Any]) → None

应用一组主题值，这些值将代替默认值使用，但不会覆盖应用程序设置的值。

传入的字典可以保持原样并与其他实例共享以节省内存（因此调用者和 HasProps 实例都不应修改它）。

参数:

property_values (dict) – 用于代替默认值的主题值

返回值:

None

类方法 clear_extensions() → None

清除任何当前定义的自定义扩展。

序列化调用将导致任何当前定义的自定义扩展包含在生成的文档中，无论是否被使用。此方法可用于清除所有现有的自定义扩展定义。

clone(**覆盖: Any) → Self

复制一个 HasProps 对象。

这将创建原始模型的浅克隆，即任何可变容器或子模型都不会被复制。允许在克隆时覆盖特定属性。

类方法 dataspecs() → dict[str, DataSpec]

收集此类上所有 DataSpec 属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

on_change(attr: str, *callbacks: PropertyCallback) → None

在此对象上添加回调，以便在 attr 更改时触发。

参数:

• attr (str) – 此对象上的属性名称

• *callbacks (callable) – 要注册的回调函数

返回值:

None

示例

widget.on_change('value', callback1, callback2, ..., callback_n)

on_event(event: str | type[Event], *callbacks: Callable[[Event], None] | Callable[[], None]) → None

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 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]]

收集此类上所有也具有引用的属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

具有引用的属性的名称

Return type:

set[str]

properties_with_values(*, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

收集一个字典，将属性名称映射到它们的值。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

不可序列化的属性将被跳过，并且属性值采用“序列化”格式，这可能与您通常从属性中读取的值略有不同；此方法的目的是返回无损地重构对象实例所需的信息。

参数:

include_defaults (bool, 可选) – 是否包含自对象创建以来尚未显式设置的属性。（默认值：True）

返回值:

从属性名称到其值的映射

Return type:

dict

query_properties_with_values(query: Callable[[PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

使用谓词查询 HasProps 实例的属性值。

参数:

• query (callable) – 一个可调用对象，它接受属性描述符并返回 True 或 False

• include_defaults (bool, 可选) – 是否包含用户尚未显式设置的属性（默认值：True）

返回值:

匹配属性的属性名称和值的映射

Return type:

dict

references() → set[Model]

返回此对象引用的所有 Models。

remove_on_change(attr: str, *callbacks: Callable[[str, Any, Any], None]) → None

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

查询此对象及其所有引用，以查找与给定选择器匹配的对象。

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

查询此对象及其所有引用，以查找与给定选择器匹配的对象。如果找到多个对象，则引发错误。返回单个匹配对象，如果未找到任何对象，则返回 None :param selector: :type selector: JSON-like

返回值:

Model

set_from_json(name: str, value: Any, *, setter: Setter | None = None) → None

从 JSON 在此对象上设置属性值。

参数:

• name (str) – 要设置的属性的名称

• value (JSON-value) – 要设置为属性的值

• setter (ClientSession 或 ServerSession 或 None, 可选) –

  这用于防止对 Bokeh 应用程序的“回旋镖”更新。

  在 Bokeh 服务器应用程序的上下文中，传入的属性更新将使用正在执行更新的会话进行注释。此值会通过更新触发的任何后续更改通知进行传播。会话可以将事件 setter 与自身进行比较，并抑制任何源自自身的更新。

返回值:

None

set_select(selector: type[Model] | SelectorType, updates: dict:[str, Any]) → None

使用指定的属性/值更新来更新与给定选择器匹配的对象。

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

删除任何主题值并恢复默认值。

返回值:

None

update(**kwargs: Any) → None

从给定的关键字参数更新对象的属性。

返回值:

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 Title(*args: Any, id: ID | None = None, **kwargs: Any)

基类: TextAnnotation

将单个标题框渲染为注释。

有关绘制标题的信息，请参阅 标题。

JSON 原型

{
  "align": "left", 
  "background_fill_alpha": 1.0, 
  "background_fill_color": null, 
  "background_hatch_alpha": 1.0, 
  "background_hatch_color": "black", 
  "background_hatch_extra": {
    "type": "map"
  }, 
  "background_hatch_pattern": null, 
  "background_hatch_scale": 12.0, 
  "background_hatch_weight": 1.0, 
  "border_line_alpha": 1.0, 
  "border_line_cap": "butt", 
  "border_line_color": null, 
  "border_line_dash": [], 
  "border_line_dash_offset": 0, 
  "border_line_join": "bevel", 
  "border_line_width": 1, 
  "border_radius": 0, 
  "context_menu": null, 
  "coordinates": null, 
  "css_classes": [], 
  "css_variables": {
    "type": "map"
  }, 
  "elements": [], 
  "group": null, 
  "html_attributes": {
    "type": "map"
  }, 
  "html_id": null, 
  "id": "p55437", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "level": "annotation", 
  "name": null, 
  "offset": 0, 
  "padding": 0, 
  "propagate_hover": false, 
  "renderers": [], 
  "standoff": 10, 
  "styles": {
    "type": "map"
  }, 
  "stylesheets": [], 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": [], 
  "text": "", 
  "text_align": "left", 
  "text_alpha": 1.0, 
  "text_baseline": "bottom", 
  "text_color": "#444444", 
  "text_font": "helvetica", 
  "text_font_size": "13px", 
  "text_font_style": "bold", 
  "text_line_height": 1.0, 
  "text_outline_color": null, 
  "vertical_align": "bottom", 
  "visible": true, 
  "x_range_name": "default", 
  "y_range_name": "default"
}

align = 'left'

Type:

Enum(TextAlign)

文本在其封闭空间内的对齐方式，沿着文本的方向。

background_fill_alpha = 1.0

Type:

Alpha（透明度）

文本边框的填充 alpha 值。

background_fill_color = None

Type:

Nullable(Color)

文本边框的填充颜色值。

background_hatch_alpha = 1.0

Type:

Alpha（透明度）

文本边框的阴影线 alpha 值。

background_hatch_color = 'black'

Type:

Nullable(Color)

文本边框的阴影线颜色值。

background_hatch_extra = {}

Type:

Dict(String, Instance(Texture))

文本边框的阴影线额外值。

background_hatch_pattern = None

Type:

Nullable(String)

文本边框的阴影线图案值。

background_hatch_scale = 12.0

Type:

尺寸

文本边框的阴影线比例值。

background_hatch_weight = 1.0

Type:

尺寸

文本边框的阴影线粗细值。

border_line_alpha = 1.0

Type:

Alpha（透明度）

文本边框的线条 alpha 值。

border_line_cap = 'butt'

Type:

Enum(LineCap)

文本边框的线条端帽值。

border_line_color = None

Type:

Nullable(Color)

文本边框的线条颜色值。

border_line_dash = []

Type:

虚线模式

文本边框的线条虚线值。

border_line_dash_offset = 0

Type:

整数

文本边框的线条虚线偏移值。

border_line_join = 'bevel'

Type:

Enum(LineJoin)

文本边框的线条连接值。

border_line_width = 1

Type:

浮点数

文本边框的线条宽度值。

border_radius = 0

Type:

Either(NonNegative, Tuple(NonNegative, NonNegative, NonNegative, NonNegative), Struct)

允许标签的框具有圆角。为了获得最佳效果，应与 padding 结合使用。

注意

此属性是实验性的，随时可能更改。

context_menu = None

Type:

Nullable(Instance(‘.models.ui.Menu’))

当用户右键单击组件时显示的菜单。

注意

右键单击时使用 shift 键显示原生上下文菜单。

css_classes = []

Type:

List

要添加到底层 DOM 元素的其他 CSS 类列表。

css_variables = {}

Type:

Dict(String, Either(String, Instance(Node)))

允许定义动态计算的 CSS 变量。

例如，这可以用于协调画布渲染器和/或视觉效果与基于 HTML 的 UI 元素之间的定位和样式设置。

此处定义的变量等效于在 CSS 样式表中的 :host { ... } 下设置相同的变量。

注意

此属性是实验性的，随时可能更改。

elements = []

Type:

List

附加到此渲染器的基于 DOM 的 UI 元素集合。

这可以包括浮动元素（如工具提示），从而允许在此渲染器及其 UI 元素之间建立父子关系。

注意

此属性等效于基于 DOM 的 UI 中的 Pane.elements。

group = None

Type:

Nullable(Instance(RendererGroup))

注意

此属性是实验性的，随时可能更改。

html_attributes = {}

Type:

Dict(String, String)

允许在底层 HTML 元素上配置 HTML 属性。

html_id = None

Type:

Nullable(String)

设置底层 HTML 元素的 id 属性。

这是常用 HTML id 属性的简写形式。或者，id 也可以在 html_attributes 字典中设置。html_id 优先。

level = 'annotation'

Type:

Enum(RenderLevel)

指定绘制此渲染器的层级。

name = None

Type:

Nullable(String)

此模型的一个任意的、用户提供的名称。

当查询文档以检索特定的 Bokeh 模型时，此名称可能很有用。

>>> plot.scatter([1,2,3], [4,5,6], name="temp")
>>> plot.select(name="temp")
[GlyphRenderer(id='399d53f5-73e9-44d9-9527-544b761c7705', ...)]

注意

对于提供的任何名称，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用该名称。

offset = 0

Type:

浮点数

以像素为单位偏移文本（可以是正数或负数）。根据标题的位置在不同方向上移动文本

• 上方：向右移动标题

• 右侧：向下移动标题

• 下方：向右移动标题

• 左侧：向上移动标题

padding = 0

Type:

Either(NonNegative, Tuple(NonNegative, NonNegative), Struct, Tuple(NonNegative, NonNegative, NonNegative, NonNegative), Struct)

标签文本与其边框之间额外的空间。

注意

此属性是实验性的，随时可能更改。

propagate_hover = False

Type:

布尔值

允许将悬停事件传播到父级渲染器、框架或画布。

注意

此属性是实验性的，随时可能更改。

renderers = []

Type:

List

附加到此渲染器的一组渲染器。

注意

此属性是实验性的，随时可能更改。

standoff = 10

Type:

浮点数

styles = {}

Type:

Either(Dict(String, Nullable(String)), Instance(Styles))

应用于底层 DOM 元素的内联 CSS 样式。

stylesheets = []

Type:

List

用于底层 DOM 元素的其他样式表。

请注意，所有 Bokeh 组件都使用 shadow DOM，因此任何包含的样式表都必须反映这一点，例如，使用 :host CSS 伪选择器来访问根 DOM 元素。

syncable = True

Type:

布尔值

指示此模型在 Web 浏览器中更新时是否应同步回 Bokeh 服务器。当处理频繁更新的对象而我们不需要其更新值时，设置为 False 可能有助于减少网络流量。

注意

将此属性设置为 False 将阻止此对象上的任何 on_change() 回调被触发。但是，任何 JS 端的回调仍然有效。

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

当查询文档以检索特定的 Bokeh 模型时，此数据可能很有用

>>> r = plot.scatter([1,2,3], [4,5,6])
>>> r.tags = ["foo", 10]
>>> plot.select(tags=['foo', 10])
[GlyphRenderer(id='1de4c3df-a83d-480a-899b-fb263d3d5dd9', ...)]

或者只是将任何必要的元数据附加到可以通过 CustomJS 回调等访问的模型的一种便捷方式。

注意

对于提供的任何标签，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用这些标签。

text = ''

Type:

文本类型

要渲染的文本或 LaTeX 符号。

text_align = 'left'

Type:

Enum(TextAlign)

文本的文本对齐值。

text_alpha = 1.0

Type:

Alpha（透明度）

文本的文本 alpha 值。

text_baseline = 'bottom'

Type:

Enum(TextBaseline)

文本的文本基线值。

text_color = '#444444'

Type:

Nullable(Color)

文本的文本颜色值。

text_font = 'helvetica'

Type:

String

文本的文本字体值。

text_font_size = '13px'

Type:

FontSize

文本的文本字体大小值。

text_font_style = 'bold'

Type:

Enum(FontStyle)

文本的文本字体样式值。

text_line_height = 1.0

Type:

浮点数

文本的文本行高值。

text_outline_color = None

Type:

Nullable(Color)

文本的文本轮廓颜色值。

vertical_align = 'bottom'

Type:

Enum(VerticalAlign)

文本在其封闭空间内的对齐方式，横跨文本方向。

visible = True

Type:

布尔值

渲染器是否可见。

x_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）x 轴范围。如果未设置，则使用默认 x 轴范围。

y_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）y 轴范围。如果未设置，则使用默认 y 轴范围。

apply_theme(property_values: dict:[str, Any]) → None

应用一组主题值，这些值将代替默认值使用，但不会覆盖应用程序设置的值。

传入的字典可以保持原样并与其他实例共享以节省内存（因此调用者和 HasProps 实例都不应修改它）。

参数:

property_values (dict) – 用于代替默认值的主题值

返回值:

None

classmethod clear_extensions() → None

清除任何当前定义的自定义扩展。

序列化调用将导致任何当前定义的自定义扩展包含在生成的文档中，无论是否被使用。此方法可用于清除所有现有的自定义扩展定义。

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

这将创建原始模型的浅克隆，即任何可变容器或子模型都不会被复制。允许在克隆时覆盖特定属性。

classmethod dataspecs() → dict:[str, DataSpec]

收集此类上所有 DataSpec 属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

DataSpec 属性的名称

Return type:

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:

使用 JavaScript 链接两个 Bokeh 模型属性。

这是一种便捷方法，简化了添加 CustomJS 回调，以便在一个 Bokeh 模型属性的值更改时更新另一个属性。

参数:

• attr (str) – 此模型上 Bokeh 属性的名称

• other (Model) – 要链接到 self.attr 的 Bokeh 模型

• other_attr (str) – other 上要链接在一起的属性

• attr_selector (int | str) – 用于链接可下标 attr 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

on_change(attr: str, *callbacks: PropertyCallback) → None

在此对象上添加回调，以便在 attr 更改时触发。

参数:

• attr (str) – 此对象上的属性名称

• *callbacks (callable) – 要注册的回调函数

返回值:

None

示例

widget.on_change('value', callback1, callback2, ..., callback_n)

on_event(event: str | type:[Event], *callbacks: Callable:[:[Event], None] | Callable:[:[], None]) → None

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 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]]

收集此类上所有也具有引用的属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

具有引用的属性的名称

Return type:

set[str]

properties_with_values(*, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

收集一个字典，将属性名称映射到它们的值。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

不可序列化的属性将被跳过，并且属性值采用“序列化”格式，这可能与您通常从属性中读取的值略有不同；此方法的目的是返回无损地重构对象实例所需的信息。

参数:

include_defaults (bool, 可选) – 是否包含自对象创建以来尚未显式设置的属性。（默认值：True）

返回值:

从属性名称到其值的映射

Return type:

dict

query_properties_with_values(query: Callable[[PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

使用谓词查询 HasProps 实例的属性值。

参数:

• query (callable) – 一个可调用对象，它接受属性描述符并返回 True 或 False

• include_defaults (bool, 可选) – 是否包含用户尚未显式设置的属性（默认值：True）

返回值:

匹配属性的属性名称和值的映射

Return type:

dict

references() → set[Model]

返回此对象引用的所有 Models。

remove_on_change(attr: str, *callbacks: Callable[[str, Any, Any], None]) → None

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

查询此对象及其所有引用，以查找与给定选择器匹配的对象。

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

查询此对象及其所有引用，以查找与给定选择器匹配的对象。如果找到多个对象，则引发错误。返回单个匹配对象，如果未找到任何对象，则返回 None :param selector: :type selector: JSON-like

返回值:

Model

set_from_json(name: str, value: Any, *, setter: Setter | None = None) → None

从 JSON 在此对象上设置属性值。

参数:

• name (str) – 要设置的属性的名称

• value (JSON-value) – 要设置为属性的值

• setter (ClientSession 或 ServerSession 或 None, 可选) –

  这用于防止对 Bokeh 应用程序的“回旋镖”更新。

  在 Bokeh 服务器应用程序的上下文中，传入的属性更新将使用正在执行更新的会话进行注释。此值会通过更新触发的任何后续更改通知进行传播。会话可以将事件 setter 与自身进行比较，并抑制任何源自自身的更新。

返回值:

None

set_select(selector: type[Model] | SelectorType, updates: dict[str, Any]) → None

使用指定的属性/值更新来更新与给定选择器匹配的对象。

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

删除任何主题值并恢复默认值。

返回值:

None

update(**kwargs: Any) → None

从给定的关键字参数更新对象的属性。

返回值:

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 ToolbarPanel(*args: Any, id: ID | None = None, **kwargs: Any)

Bases: HTMLAnnotation

JSON 原型

{
  "context_menu": null, 
  "coordinates": null, 
  "css_classes": [], 
  "css_variables": {
    "type": "map"
  }, 
  "elements": [], 
  "group": null, 
  "html_attributes": {
    "type": "map"
  }, 
  "html_id": null, 
  "id": "p55487", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "level": "annotation", 
  "name": null, 
  "propagate_hover": false, 
  "renderers": [], 
  "styles": {
    "type": "map"
  }, 
  "stylesheets": [], 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": [], 
  "toolbar": {
    "name": "unset", 
    "type": "symbol"
  }, 
  "visible": true, 
  "x_range_name": "default", 
  "y_range_name": "default"
}

context_menu = None

Type:

Nullable(Instance(‘.models.ui.Menu’))

当用户右键单击组件时显示的菜单。

注意

右键单击时使用 shift 键显示原生上下文菜单。

css_classes = []

Type:

List

要添加到底层 DOM 元素的其他 CSS 类列表。

css_variables = {}

Type:

Dict(String, Either(String, Instance(Node)))

允许定义动态计算的 CSS 变量。

例如，这可以用于协调画布渲染器和/或视觉效果与基于 HTML 的 UI 元素之间的定位和样式设置。

此处定义的变量等效于在 CSS 样式表中的 :host { ... } 下设置相同的变量。

注意

此属性是实验性的，随时可能更改。

elements = []

Type:

List

附加到此渲染器的基于 DOM 的 UI 元素集合。

这可以包括浮动元素（如工具提示），从而允许在此渲染器及其 UI 元素之间建立父子关系。

注意

此属性等效于基于 DOM 的 UI 中的 Pane.elements。

group = None

Type:

Nullable(Instance(RendererGroup))

注意

此属性是实验性的，随时可能更改。

html_attributes = {}

Type:

Dict(String, String)

允许在底层 HTML 元素上配置 HTML 属性。

html_id = None

Type:

Nullable(String)

设置底层 HTML 元素的 id 属性。

这是常用 HTML id 属性的简写形式。或者，id 也可以在 html_attributes 字典中设置。html_id 优先。

level = 'annotation'

Type:

Enum(RenderLevel)

指定绘制此渲染器的层级。

name = None

Type:

Nullable(String)

此模型的一个任意的、用户提供的名称。

当查询文档以检索特定的 Bokeh 模型时，此名称可能很有用。

>>> plot.scatter([1,2,3], [4,5,6], name="temp")
>>> plot.select(name="temp")
[GlyphRenderer(id='399d53f5-73e9-44d9-9527-544b761c7705', ...)]

注意

对于提供的任何名称，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用该名称。

propagate_hover = False

Type:

布尔值

允许将悬停事件传播到父级渲染器、框架或画布。

注意

此属性是实验性的，随时可能更改。

renderers = []

Type:

List

附加到此渲染器的一组渲染器。

注意

此属性是实验性的，随时可能更改。

styles = {}

Type:

Either(Dict(String, Nullable(String)), Instance(Styles))

应用于底层 DOM 元素的内联 CSS 样式。

stylesheets = []

Type:

List

用于底层 DOM 元素的其他样式表。

请注意，所有 Bokeh 组件都使用 shadow DOM，因此任何包含的样式表都必须反映这一点，例如，使用 :host CSS 伪选择器来访问根 DOM 元素。

syncable = True

Type:

布尔值

指示此模型在 Web 浏览器中更新时是否应同步回 Bokeh 服务器。当处理频繁更新的对象而我们不需要其更新值时，设置为 False 可能有助于减少网络流量。

注意

将此属性设置为 False 将阻止此对象上的任何 on_change() 回调被触发。但是，任何 JS 端的回调仍然有效。

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

当查询文档以检索特定的 Bokeh 模型时，此数据可能很有用

>>> r = plot.scatter([1,2,3], [4,5,6])
>>> r.tags = ["foo", 10]
>>> plot.select(tags=['foo', 10])
[GlyphRenderer(id='1de4c3df-a83d-480a-899b-fb263d3d5dd9', ...)]

或者只是将任何必要的元数据附加到可以通过 CustomJS 回调等访问的模型的一种便捷方式。

注意

对于提供的任何标签，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用这些标签。

toolbar = Undefined

Type:

Instance(Toolbar)

A toolbar to display.

visible = True

Type:

布尔值

渲染器是否可见。

x_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）x 轴范围。如果未设置，则使用默认 x 轴范围。

y_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）y 轴范围。如果未设置，则使用默认 y 轴范围。

apply_theme(property_values: dict[str, Any]) → None

应用一组主题值，这些值将代替默认值使用，但不会覆盖应用程序设置的值。

传入的字典可以保持原样并与其他实例共享以节省内存（因此调用者和 HasProps 实例都不应修改它）。

参数:

property_values (dict) – 用于代替默认值的主题值

返回值:

None

classmethod clear_extensions() → None

清除任何当前定义的自定义扩展。

序列化调用将导致任何当前定义的自定义扩展包含在生成的文档中，无论是否被使用。此方法可用于清除所有现有的自定义扩展定义。

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

这将创建原始模型的浅克隆，即任何可变容器或子模型都不会被复制。允许在克隆时覆盖特定属性。

classmethod dataspecs() → dict[str, DataSpec]

收集此类上所有 DataSpec 属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

on_change(attr: str, *callbacks: PropertyCallback) → None

在此对象上添加回调，以便在 attr 更改时触发。

参数:

• attr (str) – 此对象上的属性名称

• *callbacks (callable) – 要注册的回调函数

返回值:

None

示例

widget.on_change('value', callback1, callback2, ..., callback_n)

on_event(event: str | type[Event], *callbacks: Callable[[Event], None] | Callable[[], None]) → None

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 bokeh.events 中的特定事件。

classmethod parameters() → list[Parameter]

生成适用于从 glyph 派生的函数的 Python Parameter 值。

返回值:

list(Parameter)

类方法 properties(*, _with_props: bool = False) → set[str] | dict[str, Property[Any]]

收集此类上的属性名称。

警告

在 Bokeh 的未来版本中，此方法将返回一个字典，将属性名称映射到属性对象。为了使当前对此方法的使用具有前瞻性，请将返回值包装在 list 中。

返回值:

属性名称

classmethod properties_with_refs() → dict[str, Property[Any]]

收集此类上所有也具有引用的属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

具有引用的属性的名称

Return type:

set[str]

properties_with_values(*, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

收集一个字典，将属性名称映射到它们的值。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

不可序列化的属性将被跳过，并且属性值采用“序列化”格式，这可能与您通常从属性中读取的值略有不同；此方法的目的是返回无损地重构对象实例所需的信息。

参数:

include_defaults (bool, 可选) – 是否包含自对象创建以来尚未显式设置的属性。（默认值：True）

返回值:

从属性名称到其值的映射

Return type:

dict

query_properties_with_values(query: Callable[[PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

使用谓词查询 HasProps 实例的属性值。

参数:

• query (callable) – 一个可调用对象，它接受属性描述符并返回 True 或 False

• include_defaults (bool, 可选) – 是否包含用户尚未显式设置的属性（默认值：True）

返回值:

匹配属性的属性名称和值的映射

Return type:

dict

references() → set[Model]

返回此对象引用的所有 Models。

remove_on_change(attr: str, *callbacks: Callable[[str, Any, Any], None]) → None

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

查询此对象及其所有引用，以查找与给定选择器匹配的对象。

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

查询此对象及其所有引用，以查找与给定选择器匹配的对象。如果找到多个对象，则引发错误。返回单个匹配对象，如果未找到任何对象，则返回 None :param selector: :type selector: JSON-like

返回值:

Model

set_from_json(name: str, value: Any, *, setter: Setter | None = None) → None

从 JSON 在此对象上设置属性值。

参数:

• name (str) – 要设置的属性的名称

• value (JSON-value) – 要设置为属性的值

• setter (ClientSession 或 ServerSession 或 None, 可选) –

  这用于防止对 Bokeh 应用程序的“回旋镖”更新。

  在 Bokeh 服务器应用程序的上下文中，传入的属性更新将使用正在执行更新的会话进行注释。此值会通过更新触发的任何后续更改通知进行传播。会话可以将事件 setter 与自身进行比较，并抑制任何源自自身的更新。

返回值:

None

set_select(selector: type[Model] | SelectorType, updates: dict[str, Any]) → None

使用指定的属性/值更新来更新与给定选择器匹配的对象。

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

删除任何主题值并恢复默认值。

返回值:

None

update(**kwargs: Any) → None

从给定的关键字参数更新对象的属性。

返回值:

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)

类 VeeHead(*args: Any, id: ID | None = None, **kwargs: Any)

基簎： ArrowHead

渲染 V 形箭头头部。

JSON 原型

{
  "fill_alpha": {
    "type": "value", 
    "value": 1.0
  }, 
  "fill_color": {
    "type": "value", 
    "value": "black"
  }, 
  "hatch_alpha": {
    "type": "value", 
    "value": 1.0
  }, 
  "hatch_color": {
    "type": "value", 
    "value": "black"
  }, 
  "hatch_extra": {
    "type": "map"
  }, 
  "hatch_pattern": {
    "type": "value", 
    "value": null
  }, 
  "hatch_scale": {
    "type": "value", 
    "value": 12.0
  }, 
  "hatch_weight": {
    "type": "value", 
    "value": 1.0
  }, 
  "id": "p55507", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "line_alpha": {
    "type": "value", 
    "value": 1.0
  }, 
  "line_cap": {
    "type": "value", 
    "value": "butt"
  }, 
  "line_color": {
    "type": "value", 
    "value": "black"
  }, 
  "line_dash": {
    "type": "value", 
    "value": []
  }, 
  "line_dash_offset": {
    "type": "value", 
    "value": 0
  }, 
  "line_join": {
    "type": "value", 
    "value": "bevel"
  }, 
  "line_width": {
    "type": "value", 
    "value": 1
  }, 
  "name": null, 
  "size": {
    "type": "value", 
    "value": 25
  }, 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": []
}

fill_alpha = 1.0

Type:

AlphaSpec

箭头内部的填充 alpha 值。

fill_color = 'black'

Type:

ColorSpec

箭头内部的填充颜色值。

hatch_alpha = 1.0

Type:

AlphaSpec

箭头内部的孵化纹理 alpha 值。

hatch_color = 'black'

Type:

ColorSpec

箭头内部的孵化纹理颜色值。

hatch_extra = {}

Type:

Dict(String, Instance(Texture))

箭头内部的孵化纹理额外值。

hatch_pattern = None

Type:

HatchPatternSpec

箭头内部的孵化纹理值。

hatch_scale = 12.0

Type:

FloatSpec

箭头内部的孵化纹理缩放值。

hatch_weight = 1.0

Type:

FloatSpec

箭头内部的孵化纹理粗细值。

line_alpha = 1.0

Type:

AlphaSpec

箭头轮廓的线条 alpha 值。

line_cap = 'butt'

Type:

LineCapSpec

箭头轮廓的线条端点值。

line_color = 'black'

Type:

ColorSpec

箭头轮廓的线条颜色值。

line_dash = []

Type:

DashPatternSpec

箭头轮廓的线条虚线值。

line_dash_offset = 0

Type:

IntSpec

箭头轮廓的线条虚线偏移值。

line_join = 'bevel'

Type:

LineJoinSpec

箭头轮廓的线条连接值。

line_width = 1

Type:

FloatSpec

箭头轮廓的线条宽度值。

name = None

Type:

Nullable(String)

此模型的一个任意的、用户提供的名称。

当查询文档以检索特定的 Bokeh 模型时，此名称可能很有用。

>>> plot.scatter([1,2,3], [4,5,6], name="temp")
>>> plot.select(name="temp")
[GlyphRenderer(id='399d53f5-73e9-44d9-9527-544b761c7705', ...)]

注意

对于提供的任何名称，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用该名称。

size = 25

Type:

NumberSpec

箭头箭头的大小，以像素为单位。

syncable = True

Type:

布尔值

指示此模型在 Web 浏览器中更新时是否应同步回 Bokeh 服务器。当处理频繁更新的对象而我们不需要其更新值时，设置为 False 可能有助于减少网络流量。

注意

将此属性设置为 False 将阻止此对象上的任何 on_change() 回调被触发。但是，任何 JS 端的回调仍然有效。

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

当查询文档以检索特定的 Bokeh 模型时，此数据可能很有用

>>> r = plot.scatter([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) – 用于代替默认值的主题值

返回值:

None

类方法 clear_extensions() → None

清除任何当前定义的自定义扩展。

序列化调用将导致任何当前定义的自定义扩展包含在生成的文档中，无论是否被使用。此方法可用于清除所有现有的自定义扩展定义。

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

这将创建原始模型的浅克隆，即任何可变容器或子模型都不会被复制。允许在克隆时覆盖特定属性。

类方法 dataspecs() → dict[str, DataSpec]

收集此类上所有 DataSpec 属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

on_change(attr: str, *callbacks: PropertyCallback) → None

在此对象上添加回调，以便在 attr 更改时触发。

参数:

• attr (str) – 此对象上的属性名称

• *callbacks (callable) – 要注册的回调函数

返回值:

None

示例

widget.on_change('value', callback1, callback2, ..., callback_n)

on_event(event: str | type[Event], *callbacks: Callable[[Event], None] | Callable[[], None]) → None

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 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]]

收集此类上所有也具有引用的属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

具有引用的属性的名称

Return type:

set[str]

properties_with_values(*, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

收集一个字典，将属性名称映射到它们的值。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

不可序列化的属性将被跳过，并且属性值采用“序列化”格式，这可能与您通常从属性中读取的值略有不同；此方法的目的是返回无损地重构对象实例所需的信息。

参数:

include_defaults (bool, 可选) – 是否包含自对象创建以来尚未显式设置的属性。（默认值：True）

返回值:

从属性名称到其值的映射

Return type:

dict

query_properties_with_values(query: Callable[[PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

使用谓词查询 HasProps 实例的属性值。

参数:

• query (callable) – 一个可调用对象，它接受属性描述符并返回 True 或 False

• include_defaults (bool, 可选) – 是否包含用户尚未显式设置的属性（默认值：True）

返回值:

匹配属性的属性名称和值的映射

Return type:

dict

references() → set[Model]

返回此对象引用的所有 Models。

remove_on_change(attr: str, *callbacks: Callable[[str, Any, Any], None]) → None

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

查询此对象及其所有引用，以查找与给定选择器匹配的对象。

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

查询此对象及其所有引用，以查找与给定选择器匹配的对象。如果找到多个对象，则引发错误。返回单个匹配对象，如果未找到任何对象，则返回 None :param selector: :type selector: JSON-like

返回值:

Model

set_from_json(name: str, value: Any, *, setter: Setter | None = None) → None

从 JSON 在此对象上设置属性值。

参数:

• name (str) – 要设置的属性的名称

• value (JSON-value) – 要设置为属性的值

• setter (ClientSession 或 ServerSession 或 None, 可选) –

  这用于防止对 Bokeh 应用程序的“回旋镖”更新。

  在 Bokeh 服务器应用程序的上下文中，传入的属性更新将使用正在执行更新的会话进行注释。此值会通过更新触发的任何后续更改通知进行传播。会话可以将事件 setter 与自身进行比较，并抑制任何源自自身的更新。

返回值:

None

set_select(selector: type[Model] | SelectorType, updates: dict[str, Any]) → None

使用指定的属性/值更新来更新与给定选择器匹配的对象。

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

删除任何主题值并恢复默认值。

返回值:

None

update(**kwargs: Any) → None

从给定的关键字参数更新对象的属性。

返回值:

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 Whisker(*args: Any, id: ID | None = None, **kwargs: Any)

Bases: DataAnnotation

沿着一个维度渲染须状线。

有关绘制须状线的信息，请参阅 须状线。

JSON 原型

{
  "base": {
    "field": "base", 
    "type": "field"
  }, 
  "context_menu": null, 
  "coordinates": null, 
  "css_classes": [], 
  "css_variables": {
    "type": "map"
  }, 
  "dimension": "height", 
  "elements": [], 
  "group": null, 
  "html_attributes": {
    "type": "map"
  }, 
  "html_id": null, 
  "id": "p55527", 
  "js_event_callbacks": {
    "type": "map"
  }, 
  "js_property_callbacks": {
    "type": "map"
  }, 
  "level": "underlay", 
  "line_alpha": {
    "type": "value", 
    "value": 1.0
  }, 
  "line_cap": {
    "type": "value", 
    "value": "butt"
  }, 
  "line_color": {
    "type": "value", 
    "value": "black"
  }, 
  "line_dash": {
    "type": "value", 
    "value": []
  }, 
  "line_dash_offset": {
    "type": "value", 
    "value": 0
  }, 
  "line_join": {
    "type": "value", 
    "value": "bevel"
  }, 
  "line_width": {
    "type": "value", 
    "value": 1
  }, 
  "lower": {
    "field": "lower", 
    "type": "field"
  }, 
  "lower_head": {
    "attributes": {
      "size": {
        "type": "value", 
        "value": 10
      }
    }, 
    "id": "p55531", 
    "name": "TeeHead", 
    "type": "object"
  }, 
  "name": null, 
  "propagate_hover": false, 
  "renderers": [], 
  "source": {
    "attributes": {
      "data": {
        "type": "map"
      }, 
      "selected": {
        "attributes": {
          "indices": [], 
          "line_indices": []
        }, 
        "id": "p55529", 
        "name": "Selection", 
        "type": "object"
      }, 
      "selection_policy": {
        "id": "p55530", 
        "name": "UnionRenderers", 
        "type": "object"
      }
    }, 
    "id": "p55528", 
    "name": "ColumnDataSource", 
    "type": "object"
  }, 
  "styles": {
    "type": "map"
  }, 
  "stylesheets": [], 
  "subscribed_events": {
    "type": "set"
  }, 
  "syncable": true, 
  "tags": [], 
  "upper": {
    "field": "upper", 
    "type": "field"
  }, 
  "upper_head": {
    "attributes": {
      "size": {
        "type": "value", 
        "value": 10
      }
    }, 
    "id": "p55532", 
    "name": "TeeHead", 
    "type": "object"
  }, 
  "visible": true, 
  "x_range_name": "default", 
  "y_range_name": "default"
}

base = Field(field='base', transform=Unspecified, units=Unspecified)

Type:

单位规格

上值和下值的正交坐标。

base_units = 'data'

Type:

NotSerialized(Enum(CoordinateUnits))

用于关联属性的单位：canvas、screen 或 data

context_menu = None

Type:

Nullable(Instance(‘.models.ui.Menu’))

当用户右键单击组件时显示的菜单。

注意

右键单击时使用 shift 键显示原生上下文菜单。

css_classes = []

Type:

List

要添加到底层 DOM 元素的其他 CSS 类列表。

css_variables = {}

Type:

Dict(String, Either(String, Instance(Node)))

允许定义动态计算的 CSS 变量。

例如，这可以用于协调画布渲染器和/或视觉效果与基于 HTML 的 UI 元素之间的定位和样式设置。

此处定义的变量等效于在 CSS 样式表中的 :host { ... } 下设置相同的变量。

注意

此属性是实验性的，随时可能更改。

dimension = 'height'

Type:

Enum(Dimension)

须状线的方向可以通过将此属性设置为 “height”（y 方向）或 “width”（x 方向）来指定。

elements = []

Type:

List

附加到此渲染器的基于 DOM 的 UI 元素集合。

这可以包括浮动元素（如工具提示），从而允许在此渲染器及其 UI 元素之间建立父子关系。

注意

此属性等效于基于 DOM 的 UI 中的 Pane.elements。

group = None

Type:

Nullable(Instance(RendererGroup))

注意

此属性是实验性的，随时可能更改。

html_attributes = {}

Type:

Dict(String, String)

允许在底层 HTML 元素上配置 HTML 属性。

html_id = None

Type:

Nullable(String)

设置底层 HTML 元素的 id 属性。

这是常用 HTML id 属性的简写形式。或者，id 也可以在 html_attributes 字典中设置。html_id 优先。

level = 'underlay'

Type:

Enum(RenderLevel)

指定绘制此渲染器的层级。

line_alpha = 1.0

Type:

AlphaSpec

须状线主体的线条 alpha 值。

line_cap = 'butt'

Type:

LineCapSpec

须状线主体的线帽值。

line_color = 'black'

Type:

ColorSpec

须状线主体的线条颜色值。

line_dash = []

Type:

DashPatternSpec

须状线主体的线条虚线值。

line_dash_offset = 0

Type:

IntSpec

须状线主体的线条虚线偏移值。

line_join = 'bevel'

Type:

LineJoinSpec

须状线主体的线条连接值。

line_width = 1

Type:

FloatSpec

须状线主体的线条宽度值。

lower = Field(field='lower', transform=Unspecified, units=Unspecified)

Type:

单位规格

须状线下端的坐标。

lower_head = TeeHead(id='p55653', ...)

Type:

Nullable(Instance(ArrowHead))

ArrowHead 的实例。

lower_units = 'data'

Type:

NotSerialized(Enum(CoordinateUnits))

用于关联属性的单位：canvas、screen 或 data

name = None

Type:

Nullable(String)

此模型的一个任意的、用户提供的名称。

当查询文档以检索特定的 Bokeh 模型时，此名称可能很有用。

>>> plot.scatter([1,2,3], [4,5,6], name="temp")
>>> plot.select(name="temp")
[GlyphRenderer(id='399d53f5-73e9-44d9-9527-544b761c7705', ...)]

注意

对于提供的任何名称，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用该名称。

propagate_hover = False

Type:

布尔值

允许将悬停事件传播到父级渲染器、框架或画布。

注意

此属性是实验性的，随时可能更改。

renderers = []

Type:

List

附加到此渲染器的一组渲染器。

注意

此属性是实验性的，随时可能更改。

source = ColumnDataSource(id='p55684', ...)

Type:

Instance(DataSource)

用于在绘图上渲染注释的本地数据源。

styles = {}

Type:

Either(Dict(String, Nullable(String)), Instance(Styles))

应用于底层 DOM 元素的内联 CSS 样式。

stylesheets = []

Type:

List

用于底层 DOM 元素的其他样式表。

请注意，所有 Bokeh 组件都使用 shadow DOM，因此任何包含的样式表都必须反映这一点，例如，使用 :host CSS 伪选择器来访问根 DOM 元素。

syncable = True

Type:

布尔值

指示此模型在 Web 浏览器中更新时是否应同步回 Bokeh 服务器。当处理频繁更新的对象而我们不需要其更新值时，设置为 False 可能有助于减少网络流量。

注意

将此属性设置为 False 将阻止此对象上的任何 on_change() 回调被触发。但是，任何 JS 端的回调仍然有效。

tags = []

Type:

List

要附加到此模型的可选的、用户提供的任意值列表。

当查询文档以检索特定的 Bokeh 模型时，此数据可能很有用

>>> r = plot.scatter([1,2,3], [4,5,6])
>>> r.tags = ["foo", 10]
>>> plot.select(tags=['foo', 10])
[GlyphRenderer(id='1de4c3df-a83d-480a-899b-fb263d3d5dd9', ...)]

或者只是将任何必要的元数据附加到可以通过 CustomJS 回调等访问的模型的一种便捷方式。

注意

对于提供的任何标签，不强制执行唯一性保证或其他条件，Bokeh 也不会出于任何原因直接使用这些标签。

upper = Field(field='upper', transform=Unspecified, units=Unspecified)

Type:

单位规格

须状线上端的坐标。

upper_head = TeeHead(id='p55723', ...)

Type:

Nullable(Instance(ArrowHead))

ArrowHead 的实例。

upper_units = 'data'

Type:

NotSerialized(Enum(CoordinateUnits))

用于关联属性的单位：canvas、screen 或 data

visible = True

Type:

布尔值

渲染器是否可见。

x_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）x 轴范围。如果未设置，则使用默认 x 轴范围。

y_range_name = 'default'

Type:

String

用于在绘图上渲染字形时计算屏幕位置的特定（命名）y 轴范围。如果未设置，则使用默认 y 轴范围。

apply_theme(property_values: dict[str, Any]) → None

应用一组主题值，这些值将代替默认值使用，但不会覆盖应用程序设置的值。

传入的字典可以保持原样并与其他实例共享以节省内存（因此调用者和 HasProps 实例都不应修改它）。

参数:

property_values (dict) – 用于代替默认值的主题值

返回值:

None

classmethod clear_extensions() → None

清除任何当前定义的自定义扩展。

序列化调用将导致任何当前定义的自定义扩展包含在生成的文档中，无论是否被使用。此方法可用于清除所有现有的自定义扩展定义。

clone(**overrides: Any) → Self

复制一个 HasProps 对象。

这将创建原始模型的浅克隆，即任何可变容器或子模型都不会被复制。允许在克隆时覆盖特定属性。

classmethod dataspecs() → dict[str, DataSpec]

收集此类上所有 DataSpec 属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

DataSpec 属性的名称

Return type:

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 中项目的索引

Added in version 1.1

Raises:

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)

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: 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 的属性的描述符

Return type:

PropertyDescriptor

on_change(attr: str, *callbacks: PropertyCallback) → None

在此对象上添加回调，以便在 attr 更改时触发。

参数:

• attr (str) – 此对象上的属性名称

• *callbacks (callable) – 要注册的回调函数

返回值:

None

示例

widget.on_change('value', callback1, callback2, ..., callback_n)

on_event(event: str | type[Event], *callbacks: Callable[[Event], None] | Callable[[], None]) → None

在此 Model 上指定的事件发生时运行回调

并非所有 Model 都支持所有事件。有关哪些 Model 能够触发哪些事件的更多信息，请参阅 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]]

收集此类上所有也具有引用的属性的名称。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

返回值:

具有引用的属性的名称

Return type:

set[str]

properties_with_values(*, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

收集一个字典，将属性名称映射到它们的值。

此方法始终遍历类层次结构，并包括在任何父类上定义的属性。

不可序列化的属性将被跳过，并且属性值采用“序列化”格式，这可能与您通常从属性中读取的值略有不同；此方法的目的是返回无损地重构对象实例所需的信息。

参数:

include_defaults (bool, 可选) – 是否包含自对象创建以来尚未显式设置的属性。（默认值：True）

返回值:

从属性名称到其值的映射

Return type:

dict

query_properties_with_values(query: Callable[[PropertyDescriptor[Any]], bool], *, include_defaults: bool = True, include_undefined: bool = False) → dict[str, Any]

使用谓词查询 HasProps 实例的属性值。

参数:

• query (callable) – 一个可调用对象，它接受属性描述符并返回 True 或 False

• include_defaults (bool, 可选) – 是否包含用户尚未显式设置的属性（默认值：True）

返回值:

匹配属性的属性名称和值的映射

Return type:

dict

references() → set[Model]

返回此对象引用的所有 Models。

remove_on_change(attr: str, *callbacks: Callable[[str, Any, Any], None]) → None

从此对象中删除回调

select(selector: SelectorType) → Iterable[Model]

查询此对象及其所有引用，以查找与给定选择器匹配的对象。

参数:

selector (JSON-like)

返回值:

seq[Model]

select_one(selector: SelectorType) → Model | None

查询此对象及其所有引用，以查找与给定选择器匹配的对象。如果找到多个对象，则引发错误。返回单个匹配对象，如果未找到任何对象，则返回 None :param selector: :type selector: JSON-like

返回值:

Model

set_from_json(name: str, value: Any, *, setter: Setter | None = None) → None

从 JSON 在此对象上设置属性值。

参数:

• name (str) – 要设置的属性的名称

• value (JSON-value) – 要设置为属性的值

• setter (ClientSession 或 ServerSession 或 None, 可选) –

  这用于防止对 Bokeh 应用程序的“回旋镖”更新。

  在 Bokeh 服务器应用程序的上下文中，传入的属性更新将使用正在执行更新的会话进行注释。此值会通过更新触发的任何后续更改通知进行传播。会话可以将事件 setter 与自身进行比较，并抑制任何源自自身的更新。

返回值:

None

set_select(selector: type[Model] | SelectorType, updates: dict[str, Any]) → None

使用指定的属性/值更新来更新与给定选择器匹配的对象。

参数:

• selector (JSON-like)

• updates (dict)

返回值:

None

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

删除任何主题值并恢复默认值。

返回值:

None

update(**kwargs: Any) → None

从给定的关键字参数更新对象的属性。

返回值:

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)