expressions

Represent array expressions to be computed on the client (browser) side by BokehJS.

Expression models are useful as DataSpec values when it is desired that the array values be computed in the browser:

p.scatter(x={'expr': some_expression}, ...)

or using the expr convenience function:

from bokeh.core.properties import expr

p.scatter(x=expr(some_expression), ...)

In this case, the values of the x coordinates will be computed in the browser by the JavaScript implementation of some_expression using a ColumnDataSource as input.

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

An expression for generating arrays by cumulatively summing a single column from a ColumnDataSource.

field

The name of a ColumnDataSource column to cumulatively sum for new values.

include_zero

Whether to include zero at the start of the result. Note that the length of the result is always the same as the input column. Therefore if this property is True, then the last value of the column will not be included in the sum.

source = ColumnDataSource(data=dict(foo=[1, 2, 3, 4]))

CumSum(field='foo')
# -> [1, 3, 6, 10]

CumSum(field='foo', include_zero=True)
# -> [0, 1, 3, 6]

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

Evaluate a JavaScript function/generator.

Warning

The explicit purpose of this Bokeh Model is to embed raw JavaScript code for a browser to execute. If any part of the code is derived from untrusted user inputs, then you must take appropriate care to sanitize the user input prior to passing to Bokeh.

args

A mapping of names to Python objects. In particular those can be bokeh’s models. These objects are made available to the callback’s code snippet as the values of named parameters to the callback. There is no need to manually include the data source of the associated glyph renderer, as it is available within the scope of the code via this keyword (e.g. this.data will give access to raw data).

code

A snippet of JavaScript code to execute in the browser. The code is made into the body of a generator function, and all of of the named objects in args are available as parameters that the code can use. One can either return an array-like object (array, typed array, nd-array), an iterable (which will be converted to an array) or a scalar value (which will be converted into an array of an appropriate length), or alternatively yield values that will be collected into an array.

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

Base class for Expression models that represent a computation

to be carried out on the client-side.

JavaScripts implementations should implement the following methods:

v_compute(source: ColumnarDataSource): Arrayable {
    // compute and return array of values
}

Note

If you wish for results to be cached per source and updated only if the source changes, implement _v_compute: (source) instead.

Note

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

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

Transform from polar to cartesian coordinates.

angle

The angular coordinate (i.e. the angle from the reference axis).

angle_units

deg, rad, grad or turn

Type:

Units to use for the associated property

direction

Whether angle measures clockwise or anti-clockwise from the reference axis.

radius

The radial coordinate (i.e. the distance from the origin).

Negative radius is allowed, which is equivalent to using positive radius and changing direction to the opposite value.

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

An expression for generating arrays by summing different columns from a ColumnDataSource.

This expression is useful for implementing stacked bar charts at a low level.

fields

A sequence of fields from a ColumnDataSource to sum (elementwise). For example:

Stack(fields=['sales', 'marketing'])

Will compute an array of values (in the browser) by adding the elements of the 'sales' and 'marketing' columns of a data source.