bokeh.core.properties#

为了简化和自动化模型的创建和使用，这些模型可以用于描述绘图和场景，Bokeh 提供了一系列属性和属性混入。属性类为大量有用的类型提供自动验证和序列化。混入和容器类提供了将属性批量添加到模型类的简便方法。

为 Bokeh 模型提供属性类型

属性是可以作为 Bokeh 模型上的类属性分配的对象，以提供自动序列化、验证和文档。

本文档分为以下几节

概述 #

模块中定义了许多属性类型，例如 Int 表示整数值，Seq 表示序列（例如列表或元组等）。属性也可以组合：Seq(Float) 表示浮点数值序列。

例如，以下代码定义了一个模型，该模型具有整数、字符串和 list[float] 属性

class SomeModel(Model):
    foo = Int
    bar = String(default="something")
    baz = List(Float, help="docs for baz prop")

如所见，属性可以声明为仅属性类型，例如 foo = Int，在这种情况下，属性会在新的 Model 对象上自动实例化。或者，可以在类上实例化属性，并使用默认值和帮助字符串进行配置。

可以通过为初始化程序指定关键字参数来初始化此类的属性

m = SomeModel(foo=10, bar="a str", baz=[1,2,3,4])

也可以通过在实例上设置属性来初始化

m.foo = 20

尝试将属性设置为错误类型的值将导致 ValueError 异常

>>> m.foo = 2.3
Traceback (most recent call last):

  << traceback omitted >>

ValueError: expected a value of type Integral, got 2.3 of type float

具有属性的模型知道如何序列化自身，以便 BokehJS 理解。此外，可以使用 bokeh.sphinxext 模块中的 Sphinx 扩展轻松自动提取属性上提供的任何帮助字符串。

基本属性 #

class Alpha(default: float | UndefinedType | IntrinsicType = 1.0, *, help: str | None = None)[source]#

class Angle(default: float | UndefinedType | IntrinsicType = 0.0, *, help: str | None = None)[source]#

接受浮点角度值。

Angle 等效于 Float，但为了在语义上更有意义的情况下提供。

参数:

default (float, 可选) – 从此属性创建的属性的默认值。
help (str 或 None, 可选) – 此属性的文档字符串。在生成 Sphinx 文档时，bokeh_prop 扩展将自动使用它。（默认值：None）

class Any(default: Any | UndefinedType | IntrinsicType | None = None, help: str | None = None)[source]#

接受所有值。

Any 属性不执行任何验证或转换。

参数:

default (obj 或 None, 可选) – 从此属性创建的属性的默认值（默认值：None）
help (str 或 None, 可选) – 此属性的文档字符串。在生成 Sphinx 文档时，bokeh_prop 扩展将自动使用它。（默认值：None）

示例

>>> class AnyModel(HasProps):
...     prop = Any()
...

>>> m = AnyModel()

>>> m.prop = True

>>> m.prop = 10

>>> m.prop = 3.14

>>> m.prop = "foo"

>>> m.prop = [1, 2, 3]

class AnyRef(default: Any | UndefinedType | IntrinsicType | None = None, help: str | None = None)[source]#: 接受所有值并强制引用发现。

class Auto[source]#

仅接受字符串 “auto”。

对于可以配置为“自动”行为的属性很有用。

示例

此属性通常与 Either 属性结合使用时最有用。

>>> class AutoModel(HasProps):
...     prop = Either(Float, Auto)
...

>>> m = AutoModel()

>>> m.prop = 10.2

>>> m.prop = "auto"

>>> m.prop = "foo"      # ValueError !!

>>> m.prop = [1, 2, 3]  # ValueError !!

class Bool(default: bool | UndefinedType | IntrinsicType = False, *, help: str | None = None)[source]#

接受布尔值。

参数:

default (obj, 可选) – 从此属性创建的属性的默认值。
help (str 或 None, 可选) – 此属性的文档字符串。在生成 Sphinx 文档时，bokeh_prop 扩展将自动使用它。（默认值：None）

示例

>>> class BoolModel(HasProps):
...     prop = Bool(default=False)
...

>>> m = BoolModel()

>>> m.prop = True

>>> m.prop = False

>>> m.prop = 10  # ValueError !!

class Byte(default: int | UndefinedType | IntrinsicType = 0, help: str | None = None)[source]#

接受整数字节值 (0-255)。

示例

>>> class ByteModel(HasProps):
...     prop = Byte(default=0)
...

>>> m = ByteModel()

>>> m.prop = 255

>>> m.prop = 256  # ValueError !!

>>> m.prop = 10.3 # ValueError !!

class Bytes(default: bytes | UndefinedType | IntrinsicType = b'', *, help: str | None = None)[source]#: 接受字节值。

class CSSLength(default: str | UndefinedType | IntrinsicType = '', *, help: str | None = None)[source]#

以多种方式接受颜色值。

如果颜色以字符串形式提供，Bokeh 会确定此字符串是否表示命名的 CSS 颜色之一（例如“red”）、CSS4 颜色字符串（例如“rgb(0, 200, 0)”）或十六进制值（例如“#00FF00”）。
如果提供 3 元组，则将其视为 RGB 值（介于 0 和 255 之间）。
如果提供 4 元组，则将其视为 RGBA 值（RGB 介于 0 和 255 之间，alpha 为介于 0 和 1 之间的浮点数）。
如果提供 32 位无符号整数，则将其视为 RGBA 值，采用 0xRRGGBBAA 字节顺序模式。

示例

>>> class ColorModel(HasProps):
...     prop = Color()
...

>>> m = ColorModel()

>>> m.prop = "firebrick"

>>> m.prop = "#a240a2"

>>> m.prop = (100, 100, 255)

>>> m.prop = (100, 100, 255, 0.5)

>>> m.prop = "junk"              # ValueError !!

>>> m.prop = (100.2, 57.3, 10.2) # ValueError !!

class Complex(default: complex | UndefinedType | IntrinsicType = 0j, *, help: str | None = None)[source]#

接受复数浮点值。

参数:

default (complex, 可选) – 从此属性创建的属性的默认值。
help (str 或 None, 可选) – 此属性的文档字符串。在生成 Sphinx 文档时，bokeh_prop 扩展将自动使用它。（默认值：None）

CoordinateLike#: 别名：Either(Float, Datetime, Factor(Either(String, Tuple(String, String), Tuple(String, String, String))))

class DashPattern(default=[], *, help: str | None = None)[source]#

接受线条虚线规范。

表达描述线条虚线的模式。DashPattern 值可以通过多种方式指定

枚举：“solid”、“dashed”、“dotted”、“dotdash”、“dashdot”
HTML5 画布虚线规范样式中的整数元组或列表。HTML5 Canvas dash specification style。请注意，如果整数列表具有奇数个元素，则会复制它，并且复制的列表将成为新的虚线列表。

要指示虚线已关闭（实线），请指定空列表 []。

class Date(*, default: T | UndefinedType | IntrinsicType = Intrinsic, help: str | None = None)[source]#: 接受 ISO 格式日期（但不是日期时间）值。

class Datetime(default: str | date | datetime | UndefinedType | IntrinsicType = Undefined, *, help: str | None = None)[source]#: 接受 ISO 格式的 Datetime 值。

接受根据其他属性类型序列的值。

示例

>>> class EitherModel(HasProps):
...     prop = Either(Bool, Int, Auto)
...

>>> m = EitherModel()

>>> m.prop = True

>>> m.prop = 10

>>> m.prop = "auto"

>>> m.prop = 10.3   # ValueError !!

>>> m.prop = "foo"  # ValueError !!

class Enum(enum: Enumeration, *, default: str | UndefinedType | IntrinsicType = ..., help: str | None = ...)[source]#

class Enum(enum: str, *values: str, default: str | UndefinedType | IntrinsicType = ..., help: str | None = ...)

接受来自枚举的值。

除非使用 default 关键字参数，否则枚举中的第一个值将用作默认值。

有关更多信息，请参阅 bokeh.core.enums。

class Float(default: float | UndefinedType | IntrinsicType = 0.0, *, help: str | None = None)[source]#

接受浮点数值。

参数:

default (float, 可选) – 从此属性创建的属性的默认值。
help (str 或 None, 可选) – 此属性的文档字符串。在生成 Sphinx 文档时，bokeh_prop 扩展将自动使用它。（默认值：None）

示例

>>> class FloatModel(HasProps):
...     prop = Float()
...

>>> m = FloatModel()

>>> m.prop = 10

>>> m.prop = 10.3

>>> m.prop = "foo"  # ValueError !!

class FontSize(default: str | UndefinedType | IntrinsicType = '', *, help: str | None = None)[source]#

class Image(*, default: T | UndefinedType | IntrinsicType = Intrinsic, help: str | None = None)[source]#

接受图像文件类型，例如 PNG、JPEG、TIFF 等。

此属性可以使用以下内容进行配置

一个 pathlib.Path 图像文件路径
一个数据 URL 编码的图像字符串
一个字符串文件名，将使用 PIL.Image.open 加载
一个 RGB(A) NumPy 数组，将被转换为 PNG
一个 PIL.Image.Image 对象

在所有情况下，图像数据都序列化为 Base64 编码的字符串。

class Int(default: int | UndefinedType | IntrinsicType = 0, *, help: str | None = None)[source]#

接受有符号整数值。

参数:

default (int, 可选) – 从该属性创建的属性要具有的默认值。
help (str 或 None, 可选) – 此属性的文档字符串。在生成 Sphinx 文档时，bokeh_prop 扩展将自动使用它。（默认值：None）

示例

>>> class IntModel(HasProps):
...     prop = Int()
...

>>> m = IntModel()

>>> m.prop = 10

>>> m.prop = -200

>>> m.prop = 10.3  # ValueError !!

class Interval(type_param: type[Property[T]] | Property[T], start: T, end: T, *, default: T | UndefinedType | IntrinsicType = Undefined, help: str | None = None)[source]#

接受包含在给定区间内的数值。

参数:

interval_type (数值属性) – 范围的数值类型，例如 Int, Float
start (数字) – 范围的最小允许值。小于 start 的值将导致验证错误。
end (数字) – 范围的最大允许值。大于 end 的值将导致验证错误。

示例

>>> class RangeModel(HasProps):
...     prop = Range(Float, 10, 20)
...

>>> m = RangeModel()

>>> m.prop = 10

>>> m.prop = 20

>>> m.prop = 15

>>> m.prop = 2     # ValueError !!

>>> m.prop = 22    # ValueError !!

>>> m.prop = "foo" # ValueError !!

class JSON(default: str | UndefinedType | IntrinsicType = '', *, help: str | None = None)[source]#

接受 JSON 字符串值。

该值作为包含 JSON 内容的字符串传输并由 BokehJS 接收。即，您必须使用 JSON.parse 将值解包到 JavaScript 哈希中。

参数:

default (字符串, 可选) – 从该属性创建的属性要具有的默认值。
help (str 或 None, 可选) – 此属性的文档字符串。在生成 Sphinx 文档时，bokeh_prop 扩展将自动使用它。（默认值：None）

class MarkerType(**kw)[source]#

class MinMaxBounds(default='auto', *, accept_datetime: bool = False, help: str | None = None)[source]#

接受 (min, max) 边界元组，用于 Ranges。

边界以 (min, max) 元组形式提供，因此无论您的范围是递增还是递减，第一项都应该是范围的最小值，第二项都应该是最大值。设置 min > max 将导致 ValueError。

将边界设置为 None 将允许您的绘图尽可能地平移/缩放。如果您只想约束绘图的一端，则可以将 min 或 max 设置为 None，例如 DataRange1d(bounds=(None, 12))

class NonNegative(type_param: type[Property[T]] | Property[T], *, default: T | UndefinedType | IntrinsicType = Intrinsic, help: str | None = None)[source]#: 一个属性，接受某种其他类型的值，同时具有未定义的默认值。

class Nothing(*, help: str | None = None)[source]#: bokeh 类型系统的底层类型。它不接受任何值。

class Null(default: None | UndefinedType | IntrinsicType = None, *, help: str | None = None)[source]#

仅接受 None 值。

与 Either(Null, Type) 结合使用或用作 Nullable(Type)。

class Percent(default: float | UndefinedType | IntrinsicType = 0.0, *, help: str | None = None)[source]#

接受浮点百分比值。

Percent 对于指定 alpha 值和范围之类的东西可能很有用且在语义上很有意义。

参数:

default (float, 可选) – 从此属性创建的属性的默认值。
help (str 或 None, 可选) – 此属性的文档字符串。在生成 Sphinx 文档时，bokeh_prop 扩展将自动使用它。（默认值：None）

示例

>>> class PercentModel(HasProps):
...     prop = Percent()
...

>>> m = PercentModel()

>>> m.prop = 0.0

>>> m.prop = 0.2

>>> m.prop = 1.0

>>> m.prop = -2  # ValueError !!

>>> m.prop = 5   # ValueError !!

class Positive(type_param: type[Property[T]] | Property[T], *, default: T | UndefinedType | IntrinsicType = Intrinsic, help: str | None = None)[source]#: 一个属性，接受某种其他类型的值，同时具有未定义的默认值。

class RGB(*, default: T | UndefinedType | IntrinsicType = Intrinsic, help: str | None = None)[source]#: 接受 colors.RGB 值。

class Regex(regex: str, *, default: str | UndefinedType | IntrinsicType = Undefined, help: str | None = None)[source]#

接受与给定正则表达式匹配的字符串。

参数:

default (字符串, 可选) – 从该属性创建的属性要具有的默认值。
help (str 或 None, 可选) – 此属性的文档字符串。在生成 Sphinx 文档时，bokeh_prop 扩展将自动使用它。（默认值：None）

示例

>>> class RegexModel(HasProps):
...     prop = Regex("foo[0-9]+bar")
...

>>> m = RegexModel()

>>> m.prop = "foo123bar"

>>> m.prop = "foo"      # ValueError !!

>>> m.prop = [1, 2, 3]  # ValueError !!

class Size(default: float | UndefinedType | IntrinsicType = 0.0, *, help: str | None = None)[source]#

接受非负数值。

参数:

default (float, 可选) – 从此属性创建的属性的默认值。
help (str 或 None, 可选) – 此属性的文档字符串。在生成 Sphinx 文档时，bokeh_prop 扩展将自动使用它。（默认值：None）

示例

>>> class SizeModel(HasProps):
...     prop = Size()
...

>>> m = SizeModel()

>>> m.prop = 0

>>> m.prop = 10e6

>>> m.prop = -10   # ValueError !!

>>> m.prop = "foo" # ValueError !!

class String(default: str | UndefinedType | IntrinsicType = '', *, help: str | None = None)[source]#

接受字符串值。

参数:

default (字符串, 可选) – 从该属性创建的属性要具有的默认值。
help (str 或 None, 可选) – 此属性的文档字符串。在生成 Sphinx 文档时，bokeh_prop 扩展将自动使用它。（默认值：None）

示例

>>> class StringModel(HasProps):
...     prop = String()
...

>>> m = StringModel()

>>> m.prop = "foo"

>>> m.prop = 10.3       # ValueError !!

>>> m.prop = [1, 2, 3]  # ValueError !!

class Struct(**fields: Any)[source]#: 接受结构体的值。

class Time(default: str | time | UndefinedType | IntrinsicType = Undefined, *, help: str | None = None)[source]#: 接受 ISO 格式的时间值。

class TimeDelta(default: timedelta | UndefinedType | IntrinsicType = datetime.timedelta(0), *, help: str | None = None)[source]#: 接受 TimeDelta 值。

容器属性 #

class Array(item_type: type[Property[T]] | Property[T], *, default: T | UndefinedType | IntrinsicType = Undefined, help: str | None = None)[source]#: 接受 NumPy 数组值。

class ColumnData(keys_type: type[Property[Any]] | Property[Any], values_type: type[Property[Any]] | Property[Any], *, default: T | UndefinedType | IntrinsicType = {}, help: str | None = None)[source]#

接受适合作为 ColumnDataSource 的 data 属性的 Python 字典。

此类是 Dict 的一个特殊化，可以高效地处理编码为 NumPy 数组的列。

class Dict(keys_type: type[Property[Any]] | Property[Any], values_type: type[Property[Any]] | Property[Any], *, default: T | UndefinedType | IntrinsicType = {}, help: str | None = None)[source]#

接受 Python 字典值。

如果传入默认值，则将使用其浅拷贝用于此属性的每次新使用。

class List(item_type: type[Property[T]] | Property[T], *, default: list[T] | UndefinedType | IntrinsicType = [], help: str | None = None)[source]#: 接受 Python 列表值。

class RelativeDelta(default={}, *, help: str | None = None)[source]#: 接受用于时间增量值的 RelativeDelta 字典。

class Seq(item_type: type[Property[T]] | Property[T], *, default: T | UndefinedType | IntrinsicType = Undefined, help: str | None = None)[source]#: 接受值的非字符串有序序列，例如 list、tuple、array。

class Set(item_type: type[Property[T]] | Property[T], *, default: T | UndefinedType | IntrinsicType = {}, help: str | None = None)[source]#: 接受 Python set() 值。

class Tuple(*type_params: type[Property[Any]] | Property[Any], default: T | UndefinedType | IntrinsicType = Undefined, help: str | None = None)[source]#: 接受 Python 元组值。

class RestrictedDict(keys_type, values_type, disallow, default={}, *, help: str | None = None)[source]#: 检查不允许的键。

DataSpec 属性 #

class AlphaSpec(default=1.0, *, help: str | None = None)[source]#

class AngleSpec(default=Undefined, units_default='rad', *, help: str | None = None)[source]#

一个 DataSpec 属性，它接受数值固定值，并且还提供关联的 units 属性来存储角度单位。

单位可接受的值为 "deg"、 "rad"、 "grad" 和 "turn"。

class ColorSpec(default, *, help: str | None = None)[source]#

接受 Color 固定值的 DataSpec 属性。

ColorSpec 属性尝试首先将字符串值解释为颜色。否则，字符串值将被解释为字段名称。例如：

m.color = "#a4225f"   # value (hex color string)

m.color = "firebrick" # value (named CSS color string)

m.color = "foo"       # field (named "foo")

这种自动解释可以使用字典格式直接覆盖，或者使用 field() 函数覆盖。

m.color = { "field": "firebrick" } # field (named "firebrick")

m.color = field("firebrick")       # field (named "firebrick")

class DataSpec(value_type, default, *, help: str | None = None)[source]#

接受固定值或引用 ColumnDataSource 中列名的字符串的属性的基类。

许多 Bokeh 模型都具有用户可能希望设置为单个固定值，或者希望属性从数据源的某些列中获取值的属性。作为一个具体的例子，考虑一个带有用于定位的 x 属性的字形。我们可能希望将绘制的所有字形设置为具有相同的位置，例如 x=10。能够直接写成如下形式将会很方便：

glyph.x = 10

或者，也许每个绘制的字形都应该根据数据源的“pressure”列具有不同的位置。在这种情况下，我们希望能够写成如下形式：

glyph.x = "pressure"

Bokeh DataSpec 属性（及其子类）提供了这种易用性和表达式的一致性。最终，所有 DataSpec 属性都解析为字典值，具体取决于其设置方式，字典值带有 "value" 键或 "field" 键。

例如：

glyph.x = 10          # => { 'value': 10 }

glyph.x = "pressure"  # => { 'field': 'pressure' }

当这些底层字典值在浏览器中接收到时，BokehJS 知道如何解释它们并采取正确的预期操作（即，在 x=10 处绘制字形，或者使用来自“pressure”列的 x 坐标绘制字形）。通过这种方式，两种用例都可以轻松地在 python 中表达，而无需从用户角度进行任何不同的处理。

值得注意的是，DataSpec 属性也可以使用正确格式的字典值直接设置。

glyph.x = { 'value': 10 }         # same as glyph.x = 10

glyph.x = { 'field': 'pressure' } # same as glyph.x = "pressure"

直接将属性设置为字典在某些情况下可能很有用。例如，某些 DataSpec 子类还在字典中添加了 "units" 键。此键通常是自动设置的，但字典格式提供了一种在必要时进行覆盖的直接机制。此外，DataSpec 可以具有 "transform" 键，该键指定应在客户端应用的变换，以便在它们被使用之前应用于任何固定值或字段值。例如，您可能希望将 Jitter 变换应用于 x 值。

glyph.x = { 'value': 10, 'transform': Jitter(width=0.4) }

请注意，DataSpec 通常不能单独使用。通常，模型将使用子类之一（例如 NumberSpec 或 ColorSpec）定义属性。例如，具有可以自动处理固定值或列的 x、 y 和 color 属性的 Bokeh 模型可能如下所示：

class SomeModel(Model):

    x = NumberSpec(default=0, help="docs for x")

    y = NumberSpec(default=0, help="docs for y")

    color = ColorSpec(help="docs for color") # defaults to None

class DistanceSpec(default=Undefined, units_default='data', *, help: str | None = None)[source]#: 接受数值型固定值或引用 ColumnDataSource 中列名的字符串的 DataSpec 属性，并且还提供关联的 units 属性来存储单位信息。单位可接受的值为 "screen" 和 "data"。

class FloatSpec(default, *, help: str | None = None)[source]#

class FontSizeSpec(default, *, help: str | None = None)[source]#

接受字体大小固定值的 DataSpec 属性。

FontSizeSpec 属性尝试首先将字符串值解释为字体大小（即，有效的 CSS 长度值）。否则，字符串值将被解释为字段名称。例如：

m.font_size = "13px"  # value

m.font_size = "1.5em" # value

m.font_size = "foo"   # field

所有有效的 CSS 长度单位的完整列表可以在这里找到：

https://drafts.csswg.org/css-values/#lengths

class MarkerSpec(default, *, help: str | None = None)[source]#

接受标记类型作为固定值的 DataSpec 属性。

MarkerSpec 属性尝试首先将字符串值解释为标记类型。否则，字符串值将被解释为字段名称。例如：

m.font_size = "circle" # value

m.font_size = "square" # value

m.font_size = "foo"    # field

class NumberSpec(default=Undefined, *, help: str | None = None, accept_datetime: bool = True, accept_timedelta: bool = True)[source]#

接受数值和日期时间固定值的 DataSpec 属性。

默认情况下，日期和日期时间值会立即转换为自 epoch 以来的毫秒数。可以通过传递 accept_datetime=False 来禁用日期时间值的处理。

默认情况下，timedelta 值会立即转换为绝对毫秒数。可以通过传递 accept_timedelta=False 来禁用 timedelta 值的处理。

Timedelta 值被解释为绝对毫秒数。

m.location = 10.3  # value

m.location = "foo" # field

class SizeSpec(default=Undefined, *, help: str | None = None, accept_datetime: bool = True, accept_timedelta: bool = True)[source]#: 接受大小值的非负数值型固定值或引用 ColumnDataSource 中列名的字符串的 DataSpec 属性。

class StringSpec(default, *, help: str | None = None)[source]#

接受字符串固定值的 DataSpec 属性。

由于可接受的固定值和字段名称都是字符串，因此可能需要显式消除这些可能性。默认情况下，字符串值被解释为字段，但您可以使用 value() 函数来指定将字符串解释为值。

m.title = value("foo") # value

m.title = "foo"        # field

class UnitsSpec(default, units_enum, units_default, *, help: str | None = None)[source]#: 接受数值型固定值的 DataSpec 属性，并且还提供关联的 units 属性来存储单位信息。

辅助函数 #

expr(expr: Expression, transform: NotRequired[Transform] = Unspecified, units: NotRequired[str] = Unspecified) → None#: Expr(expr: ‘Expression’, transform: ‘NotRequired[Transform]’ = Unspecified, units: ‘NotRequired[str]’ = Unspecified)

field(field: str, transform: NotRequired[Transform] = Unspecified, units: NotRequired[str] = Unspecified) → None#: Field(field: ‘str’, transform: ‘NotRequired[Transform]’ = Unspecified, units: ‘NotRequired[str]’ = Unspecified)

value(value: T, transform: NotRequired[Transform] = Unspecified, units: NotRequired[str] = Unspecified) → None#: Value(value: ‘T’, transform: ‘NotRequired[Transform]’ = Unspecified, units: ‘NotRequired[str]’ = Unspecified)

特殊属性 #

class Instance(instance_type: type[T] | Callable[[], type[T]] | str, default: T | UndefinedType | IntrinsicType = Undefined, help: str | None = None)[source]#: 接受作为可序列化类型实例的值（例如 HasProps）。

class InstanceDefault(model: type[I], **kwargs: Any)[source]#

为 Instance 默认值提供延迟初始化器。

这对于具有 Instance 属性的 Bokeh 模型很有用，这些属性应该为每个模型实例提供唯一的默认值。与 lambda 初始化器相比，使用 InstanceDefault 将提供更好面向用户的文档。

class Include(delegate: type[HasProps], *, help: str = '', prefix: str | None = None)[source]#

在 Bokeh 模型中包含 “mix-in” 属性集合。

有关更多详细信息，请参见 bokeh.core.property_mixins。

class Nullable(type_param: type[Property[T]] | Property[T], *, default: T | None | UndefinedType | IntrinsicType = None, help: str | None = None)[source]#: 一个接受 None 或其他类型值的属性。

class NotSerialized(type_param: type[Property[T]] | Property[T], *, default: T | UndefinedType | IntrinsicType = Intrinsic, help: str | None = None)[source]#: 一个状态不会与浏览器同步的属性。

class Object(instance_type: type[T] | Callable[[], type[T]] | str, default: T | UndefinedType | IntrinsicType = Undefined, help: str | None = None)[source]#: 接受任何类的实例值。

注意

这主要用于验证目的。不可序列化的对象在序列化过程中始终会失败。

class Override(*, default: T)[source]#

在派生的 Model 中覆盖 Bokeh 属性的特性。

当继承 Bokeh Model 时，可能需要更改属性本身的一些特性，使其与基类上的特性不同。这可以通过使用 Override 类来实现。

目前，Override 只能用于覆盖属性的 default 值。

关键词参数:: default (obj) – 子类上此属性的默认值

示例

考虑以下类定义

from bokeh.model import Model
from bokeh.properties import Int, Override

class Parent(Model):
    foo = Int(default=10)

class Child(Parent):
    foo = Override(default=20)

父类具有一个整数属性 foo，默认值为 10。子类使用以下代码

foo = Override(default=20)

来指定子类实例上 foo 属性的默认值应为 20

>>> p = Parent()
>>> p.foo
10

>>> c = Child()
>>> c.foo
20

class Required(type_param: type[Property[T]] | Property[T], *, default: T | UndefinedType | IntrinsicType = Undefined, help: str | None = None)[source]#: 一个属性，接受某种其他类型的值，同时具有未定义的默认值。

class TypeOfAttr(type_param: type[Property[T]] | Property[T], name: str, type: type[Property[Any]] | Property[Any], *, default: T | UndefinedType | IntrinsicType = Intrinsic, help: str | None = None)[source]#: 允许检查对象的属性是否满足给定的类型或类型集合。

仅验证属性 #

class EagerDataFrame(*, default: T | UndefinedType | IntrinsicType = Intrinsic, help: str | None = None)[source]#

接受 Narwhals 支持的 eager dataframe。

此属性仅用于支持类型验证，例如用于 “accepts” 子句。它本身不可序列化，并且直接添加到 Bokeh 模型中没有用处。

class EagerSeries(*, default: T | UndefinedType | IntrinsicType = Intrinsic, help: str | None = None)[source]#

接受 Narwhals 支持的 eager series。

此属性仅用于支持类型验证，例如用于 “accepts” 子句。它本身不可序列化，并且直接添加到 Bokeh 模型中没有用处。

class PandasDataFrame[source]#

接受 Pandas DataFrame 值。

这个类是 pandas 特有的 - 更通用的是 EagerDataFrame()。

此属性仅用于支持类型验证，例如用于 “accepts” 子句。它本身不可序列化，并且直接添加到 Bokeh 模型中没有用处。

class PandasGroupBy(*, default: T | UndefinedType | IntrinsicType = Intrinsic, help: str | None = None)[source]#

接受 Pandas DataFrame 值。

此属性仅用于支持类型验证，例如用于 “accepts” 子句。它本身不可序列化，并且直接添加到 Bokeh 模型中没有用处。

验证控制 #

默认情况下，Bokeh 属性对值执行类型验证。这有助于确保 Python 和 JavaScript 之间交换的任何数据的一致性，并在用户尝试设置错误类型的值时提供详细且即时的反馈。但是，这些类型检查会产生一些开销。在某些情况下，可能需要在特定位置甚至完全关闭验证，以提高性能。以下 API 可用于控制何时进行类型验证。

class validate(value)[source]#

控制 bokeh 属性的验证

这可以用作上下文管理器，或作为普通的可调用对象

参数:: value (bool) – 是否应进行验证

示例

with validate(False):  # do no validate while within this block
    pass

validate(False)  # don't validate ever

另请参阅

validation_on(): 检查验证状态

without_property_validation(): 函数装饰器

without_property_validation(input_function)[source]#

在更新回调期间关闭属性验证

示例

@without_property_validation
def update(attr, old, new):
    # do things without validation

另请参阅

validate: 用于更细粒度控制的上下文管理器