bluesky_tiled_plugins.clients.document

Module Contents

Classes

Document	Document is an immutable dict subclass.
Start	Document is an immutable dict subclass.
Stop	Document is an immutable dict subclass.
Resource	Document is an immutable dict subclass.
StreamResource	Document is an immutable dict subclass.
Descriptor	Document is an immutable dict subclass.
Event	Document is an immutable dict subclass.
EventPage	Document is an immutable dict subclass.
Datum	Document is an immutable dict subclass.
StreamDatum	Document is an immutable dict subclass.
DatumPage	Document is an immutable dict subclass.

API

exception bluesky_tiled_plugins.clients.document.NotMutable

Bases: Exception

Common base class for all non-exit exceptions.

class bluesky_tiled_plugins.clients.document.Document(*args, **kwargs)

Bases: dict

Document is an immutable dict subclass.

It is immutable to help consumer code avoid accidentally corrupting data that another part of the consumer code was expected to use unchanged.

Subclasses of Document must define dask_tokenize. The tokenization schemes typically uniquely identify the document based on only a subset of its contents, and mutating the contents can thereby create situations where two unequal objects have colliding tokens. Immutability helps guard against this too.

Note that Documents are not recursively immutable. Just as it is possible create a tuple (immutable) of lists (mutable) and mutate the lists, it is possible to mutate the internal contents of a Document, but this should not be done. It is safer to use the to_dict() method to create a mutable deep copy.

This is implemented as a dict subclass in order to satisfy certain consumers that expect an object that satisfies isinstance(obj, dict). This implementation detail may change in the future.

pop

None

popitem

None

clear

None

setdefault

None

update

None

to_dict()

Create a mutable deep copy.

class bluesky_tiled_plugins.clients.document.Start(*args, **kwargs)

Bases: bluesky_tiled_plugins.clients.document.Document

Document is an immutable dict subclass.

It is immutable to help consumer code avoid accidentally corrupting data that another part of the consumer code was expected to use unchanged.

Subclasses of Document must define dask_tokenize. The tokenization schemes typically uniquely identify the document based on only a subset of its contents, and mutating the contents can thereby create situations where two unequal objects have colliding tokens. Immutability helps guard against this too.

Note that Documents are not recursively immutable. Just as it is possible create a tuple (immutable) of lists (mutable) and mutate the lists, it is possible to mutate the internal contents of a Document, but this should not be done. It is safer to use the to_dict() method to create a mutable deep copy.

This is implemented as a dict subclass in order to satisfy certain consumers that expect an object that satisfies isinstance(obj, dict). This implementation detail may change in the future.

class bluesky_tiled_plugins.clients.document.Stop(*args, **kwargs)

Bases: bluesky_tiled_plugins.clients.document.Document

Document is an immutable dict subclass.

It is immutable to help consumer code avoid accidentally corrupting data that another part of the consumer code was expected to use unchanged.

Subclasses of Document must define dask_tokenize. The tokenization schemes typically uniquely identify the document based on only a subset of its contents, and mutating the contents can thereby create situations where two unequal objects have colliding tokens. Immutability helps guard against this too.

Note that Documents are not recursively immutable. Just as it is possible create a tuple (immutable) of lists (mutable) and mutate the lists, it is possible to mutate the internal contents of a Document, but this should not be done. It is safer to use the to_dict() method to create a mutable deep copy.

This is implemented as a dict subclass in order to satisfy certain consumers that expect an object that satisfies isinstance(obj, dict). This implementation detail may change in the future.

class bluesky_tiled_plugins.clients.document.Resource(*args, **kwargs)

Bases: bluesky_tiled_plugins.clients.document.Document

Document is an immutable dict subclass.

It is immutable to help consumer code avoid accidentally corrupting data that another part of the consumer code was expected to use unchanged.

Subclasses of Document must define dask_tokenize. The tokenization schemes typically uniquely identify the document based on only a subset of its contents, and mutating the contents can thereby create situations where two unequal objects have colliding tokens. Immutability helps guard against this too.

Note that Documents are not recursively immutable. Just as it is possible create a tuple (immutable) of lists (mutable) and mutate the lists, it is possible to mutate the internal contents of a Document, but this should not be done. It is safer to use the to_dict() method to create a mutable deep copy.

This is implemented as a dict subclass in order to satisfy certain consumers that expect an object that satisfies isinstance(obj, dict). This implementation detail may change in the future.

class bluesky_tiled_plugins.clients.document.StreamResource(*args, **kwargs)

Bases: bluesky_tiled_plugins.clients.document.Document

Document is an immutable dict subclass.

It is immutable to help consumer code avoid accidentally corrupting data that another part of the consumer code was expected to use unchanged.

Subclasses of Document must define dask_tokenize. The tokenization schemes typically uniquely identify the document based on only a subset of its contents, and mutating the contents can thereby create situations where two unequal objects have colliding tokens. Immutability helps guard against this too.

Note that Documents are not recursively immutable. Just as it is possible create a tuple (immutable) of lists (mutable) and mutate the lists, it is possible to mutate the internal contents of a Document, but this should not be done. It is safer to use the to_dict() method to create a mutable deep copy.

This is implemented as a dict subclass in order to satisfy certain consumers that expect an object that satisfies isinstance(obj, dict). This implementation detail may change in the future.

class bluesky_tiled_plugins.clients.document.Descriptor(*args, **kwargs)

Bases: bluesky_tiled_plugins.clients.document.Document

Document is an immutable dict subclass.

It is immutable to help consumer code avoid accidentally corrupting data that another part of the consumer code was expected to use unchanged.

Subclasses of Document must define dask_tokenize. The tokenization schemes typically uniquely identify the document based on only a subset of its contents, and mutating the contents can thereby create situations where two unequal objects have colliding tokens. Immutability helps guard against this too.

Note that Documents are not recursively immutable. Just as it is possible create a tuple (immutable) of lists (mutable) and mutate the lists, it is possible to mutate the internal contents of a Document, but this should not be done. It is safer to use the to_dict() method to create a mutable deep copy.

This is implemented as a dict subclass in order to satisfy certain consumers that expect an object that satisfies isinstance(obj, dict). This implementation detail may change in the future.

class bluesky_tiled_plugins.clients.document.Event(*args, **kwargs)

Bases: bluesky_tiled_plugins.clients.document.Document

Document is an immutable dict subclass.

It is immutable to help consumer code avoid accidentally corrupting data that another part of the consumer code was expected to use unchanged.

Subclasses of Document must define dask_tokenize. The tokenization schemes typically uniquely identify the document based on only a subset of its contents, and mutating the contents can thereby create situations where two unequal objects have colliding tokens. Immutability helps guard against this too.

Note that Documents are not recursively immutable. Just as it is possible create a tuple (immutable) of lists (mutable) and mutate the lists, it is possible to mutate the internal contents of a Document, but this should not be done. It is safer to use the to_dict() method to create a mutable deep copy.

This is implemented as a dict subclass in order to satisfy certain consumers that expect an object that satisfies isinstance(obj, dict). This implementation detail may change in the future.

class bluesky_tiled_plugins.clients.document.EventPage(*args, **kwargs)

Bases: bluesky_tiled_plugins.clients.document.Document

Document is an immutable dict subclass.

It is immutable to help consumer code avoid accidentally corrupting data that another part of the consumer code was expected to use unchanged.

Subclasses of Document must define dask_tokenize. The tokenization schemes typically uniquely identify the document based on only a subset of its contents, and mutating the contents can thereby create situations where two unequal objects have colliding tokens. Immutability helps guard against this too.

Note that Documents are not recursively immutable. Just as it is possible create a tuple (immutable) of lists (mutable) and mutate the lists, it is possible to mutate the internal contents of a Document, but this should not be done. It is safer to use the to_dict() method to create a mutable deep copy.

This is implemented as a dict subclass in order to satisfy certain consumers that expect an object that satisfies isinstance(obj, dict). This implementation detail may change in the future.

class bluesky_tiled_plugins.clients.document.Datum(*args, **kwargs)

Bases: bluesky_tiled_plugins.clients.document.Document

Document is an immutable dict subclass.

It is immutable to help consumer code avoid accidentally corrupting data that another part of the consumer code was expected to use unchanged.

Subclasses of Document must define dask_tokenize. The tokenization schemes typically uniquely identify the document based on only a subset of its contents, and mutating the contents can thereby create situations where two unequal objects have colliding tokens. Immutability helps guard against this too.

Note that Documents are not recursively immutable. Just as it is possible create a tuple (immutable) of lists (mutable) and mutate the lists, it is possible to mutate the internal contents of a Document, but this should not be done. It is safer to use the to_dict() method to create a mutable deep copy.

This is implemented as a dict subclass in order to satisfy certain consumers that expect an object that satisfies isinstance(obj, dict). This implementation detail may change in the future.

class bluesky_tiled_plugins.clients.document.StreamDatum(*args, **kwargs)

Bases: bluesky_tiled_plugins.clients.document.Document

Document is an immutable dict subclass.

It is immutable to help consumer code avoid accidentally corrupting data that another part of the consumer code was expected to use unchanged.

Subclasses of Document must define dask_tokenize. The tokenization schemes typically uniquely identify the document based on only a subset of its contents, and mutating the contents can thereby create situations where two unequal objects have colliding tokens. Immutability helps guard against this too.

Note that Documents are not recursively immutable. Just as it is possible create a tuple (immutable) of lists (mutable) and mutate the lists, it is possible to mutate the internal contents of a Document, but this should not be done. It is safer to use the to_dict() method to create a mutable deep copy.

This is implemented as a dict subclass in order to satisfy certain consumers that expect an object that satisfies isinstance(obj, dict). This implementation detail may change in the future.

class bluesky_tiled_plugins.clients.document.DatumPage(*args, **kwargs)

Bases: bluesky_tiled_plugins.clients.document.Document

Document is an immutable dict subclass.

It is immutable to help consumer code avoid accidentally corrupting data that another part of the consumer code was expected to use unchanged.

Subclasses of Document must define dask_tokenize. The tokenization schemes typically uniquely identify the document based on only a subset of its contents, and mutating the contents can thereby create situations where two unequal objects have colliding tokens. Immutability helps guard against this too.

Note that Documents are not recursively immutable. Just as it is possible create a tuple (immutable) of lists (mutable) and mutate the lists, it is possible to mutate the internal contents of a Document, but this should not be done. It is safer to use the to_dict() method to create a mutable deep copy.

This is implemented as a dict subclass in order to satisfy certain consumers that expect an object that satisfies isinstance(obj, dict). This implementation detail may change in the future.