Anaconda Enterprise: Documentation

# bokeh.models.sources

class `bokeh.models.sources.``AjaxDataSource`(*args, **kw)

  Bases: `bokeh.models.sources.RemoteSource`

  `content_type`

    property type: `String`

    Set the “contentType” parameter for the Ajax request.

  `http_headers`

    property type: `Dict` ( `String` , `String` )

    HTTP headers to set for the Ajax request.

  `if_modified`

    property type: `Bool`

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

  `max_size`

    property type: `Int`

    Maximum size of the data array being kept after each pull requests. Larger than that size, the data will be right shifted.

  `method`

    property type: `Enum` ( Enumeration(POST, GET) )

    http method - GET or POST

  `mode`

    property type: `Enum` ( Enumeration(replace, append) )

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

JSON Prototype

    {
      "callback": null,
      "column_names": [],
      "content_type": "application/json",
      "data": {},
      "data_url": null,
      "http_headers": {},
      "id": "e75b661e-643d-46ce-8067-81f9ce07c5b5",
      "if_modified": false,
      "js_event_callbacks": {},
      "js_property_callbacks": {},
      "max_size": null,
      "method": "POST",
      "mode": "replace",
      "name": null,
      "polling_interval": null,
      "selected": {
        "0d": {
          "glyph": null,
          "indices": []
        },
        "1d": {
          "indices": []
        },
        "2d": {
          "indices": {}
        }
      },
      "subscribed_events": [],
      "tags": []
    }

class `bokeh.models.sources.``CDSView`(**kwargs)

  Bases: `bokeh.model.Model`

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

  `filters`

    property type: `List` ( `Instance` ( `Filter` ) )

    List of filters that the view comprises.

  `source`

    property type: `Instance` ( `ColumnarDataSource` )

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

JSON Prototype

    {
      "filters": [],
      "id": "98ed81b5-d34b-4c35-8d51-f73dc4db9e74",
      "js_event_callbacks": {},
      "js_property_callbacks": {},
      "name": null,
      "source": null,
      "subscribed_events": [],
      "tags": []
    }

class `bokeh.models.sources.``ColumnDataSource`(*args, **kw)

  Bases: `bokeh.models.sources.ColumnarDataSource`

  Maps names of columns to sequences or arrays.

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

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

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

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

        source = ColumnDataSource(data)

  - A Pandas `DataFrame` object

        source = ColumnDataSource(df)

    In this case the CDS will have columns corresponding to the columns of the `DataFrame`. If the `DataFrame` has a named index column, then CDS will also have a column with this name. However, if the index name (or any subname of a `MultiIndex`) is `None`, then the CDS will have a column generically named `index` for the index.

  - A Pandas `GroupBy` object

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

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

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

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

  Note

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

  `data`

    property type: `ColumnData` ( `String` , `Seq` ( `Any` ) )

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

  `add`(data, name=None)

    Appends a new column of data to the data source.

    Parameters: | data (seq) – new data to add name (str, optional) – column name to use. If not supplied, generate a name of the form “Series ####”
    Returns: | the column name used
    Return type: | str

  classmethod `from_df`(data)

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

    Parameters: | data (DataFrame) – data to convert
    Returns: | dict[str, np.array]

  classmethod `from_groupby`(data)

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

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

    Parameters: | data (Groupby) – data to convert
    Returns: | dict[str, np.array]

  `patch`(patches, setter=None)

    Efficiently update data source columns at specific locations

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

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

        (index, new_value)  # replace a single column value

        # or

        (slice, new_values) # replace several column values

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

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

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

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

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

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

        data[2][:, 10] = new_data

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

    - Negative `start`, `stop`, or `step` values for slices will result in a `ValueError`.
    - In a slice, `start > stop` will result in a `ValueError`
    - When patching 1d or 2d subitems, the subitems must be NumPy arrays.
    - New values must be supplied as a flattened one-dimensional array of the appropriate size.

    Parameters: | patches (dict[str, list[tuple]]) – lists of patches for each column
    Returns: | None
    Raises: | `ValueError`

    Example:

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

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

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

        source.patch(patches)

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

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

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

  `remove`(name)

    Remove a column of data.

    Parameters: | name (str) – name of the column to remove
    Returns: | None

    Note

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

  `stream`(new_data, rollover=None)

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

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

    Parameters: | new_data (dict[str, seq]) – a mapping of column names to sequences of new data to append to each column. All columns of the data source must be present in `new_data`, with identical-length append data. rollover (int, optional) – A maximum column size, above which data from the start of the column begins to be discarded. If None, then columns will continue to grow unbounded (default: None)
    Returns: | None
    Raises: | `ValueError`

    Example:

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

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

        source.stream(new_data)

  `to_df`()

    Convert this data source to pandas dataframe.

    If `column_names` is set, use those. Otherwise let Pandas infer the column names. The `column_names` property can be used both to order and filter the columns.

    Returns: | DataFrame

JSON Prototype

    {
      "callback": null,
      "column_names": [],
      "data": {},
      "id": "599958f1-08c2-4207-9164-050255b685cf",
      "js_event_callbacks": {},
      "js_property_callbacks": {},
      "name": null,
      "selected": {
        "0d": {
          "glyph": null,
          "indices": []
        },
        "1d": {
          "indices": []
        },
        "2d": {
          "indices": {}
        }
      },
      "subscribed_events": [],
      "tags": []
    }

class `bokeh.models.sources.``ColumnarDataSource`(**kwargs)

  Bases: `bokeh.models.sources.DataSource`

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

  Note

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

  `column_names`

    property type: `List` ( `String` )

    An list of names for all the columns in this DataSource.

JSON Prototype

    {
      "callback": null,
      "column_names": [],
      "id": "e4055ff1-8807-49ba-a890-7d8b7775aa7a",
      "js_event_callbacks": {},
      "js_property_callbacks": {},
      "name": null,
      "selected": {
        "0d": {
          "glyph": null,
          "indices": []
        },
        "1d": {
          "indices": []
        },
        "2d": {
          "indices": {}
        }
      },
      "subscribed_events": [],
      "tags": []
    }

class `bokeh.models.sources.``DataSource`(**kwargs)

  Bases: `bokeh.model.Model`

  A base class for data source types.

  Note

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

  `callback`

    property type: `Instance` ( `Callback` )

    A callback to run in the browser whenever the selection is changed.

  `selected`

    property type: `Dict` ( `String` , `Dict` ( `String` , `Any` ) )

    A dict to indicate selected indices on different dimensions on this DataSource. Keys are:

        # selection information for line and patch glyphs
        '0d' : {
          # the glyph that was selected
          'glyph': None

          # array with the [smallest] index of the segment of the line that was hit
          'indices': []
        }

        # selection for most (point-like) glyphs, except lines and patches
        '1d': {
          # indices of the points included in the selection
          indices: []
        }

        # selection information for multiline and patches glyphs
        '2d': {
          # mapping of indices of the multiglyph to array of glyph indices that were hit
          # e.g. {3: [5, 6], 4: [5]}
          indices: {}
        }

JSON Prototype

    {
      "callback": null,
      "id": "55f273e7-308c-4166-bc32-49a10317fbc6",
      "js_event_callbacks": {},
      "js_property_callbacks": {},
      "name": null,
      "selected": {
        "0d": {
          "glyph": null,
          "indices": []
        },
        "1d": {
          "indices": []
        },
        "2d": {
          "indices": {}
        }
      },
      "subscribed_events": [],
      "tags": []
    }

class `bokeh.models.sources.``GeoJSONDataSource`(**kwargs)

  Bases: `bokeh.models.sources.ColumnarDataSource`

  `geojson`

    property type: `JSON`

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

JSON Prototype

    {
      "callback": null,
      "column_names": [],
      "geojson": null,
      "id": "5c1c8f63-2113-433b-988d-96f607da2e8a",
      "js_event_callbacks": {},
      "js_property_callbacks": {},
      "name": null,
      "selected": {
        "0d": {
          "glyph": null,
          "indices": []
        },
        "1d": {
          "indices": []
        },
        "2d": {
          "indices": {}
        }
      },
      "subscribed_events": [],
      "tags": []
    }

class `bokeh.models.sources.``RemoteSource`(*args, **kw)

  Bases: `bokeh.models.sources.ColumnDataSource`

  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.

  `data_url`

    property type: `String`

    The URL to the endpoint for the data.

  `polling_interval`

    property type: `Int`

    polling interval for updating data source in milliseconds

JSON Prototype

    {
      "callback": null,
      "column_names": [],
      "data": {},
      "data_url": null,
      "id": "3e7b2223-cab5-4090-b62b-dcede6fd479c",
      "js_event_callbacks": {},
      "js_property_callbacks": {},
      "name": null,
      "polling_interval": null,
      "selected": {
        "0d": {
          "glyph": null,
          "indices": []
        },
        "1d": {
          "indices": []
        },
        "2d": {
          "indices": {}
        }
      },
      "subscribed_events": [],
      "tags": []
    }